| #include "git-compat-util.h" |
| #include "test-tool.h" |
| #include "pkt-line.h" |
| #include "sideband.h" |
| #include "write-or-die.h" |
| #include "parse-options.h" |
| |
| static void pack_line(const char *line) |
| { |
| if (!strcmp(line, "0000") || !strcmp(line, "0000\n")) |
| packet_flush(1); |
| else if (!strcmp(line, "0001") || !strcmp(line, "0001\n")) |
| packet_delim(1); |
| else |
| packet_write_fmt(1, "%s", line); |
| } |
| |
| static void pack(int argc, const char **argv) |
| { |
| if (argc) { /* read from argv */ |
| int i; |
| for (i = 0; i < argc; i++) |
| pack_line(argv[i]); |
| } else { /* read from stdin */ |
| char line[LARGE_PACKET_MAX]; |
| while (fgets(line, sizeof(line), stdin)) { |
| pack_line(line); |
| } |
| } |
| } |
| |
| static void pack_raw_stdin(void) |
| { |
| struct strbuf sb = STRBUF_INIT; |
| |
| if (strbuf_read(&sb, 0, 0) < 0) |
| die_errno("failed to read from stdin"); |
| packet_write(1, sb.buf, sb.len); |
| strbuf_release(&sb); |
| } |
| |
| static void unpack(void) |
| { |
| struct packet_reader reader; |
| packet_reader_init(&reader, 0, NULL, 0, |
| PACKET_READ_GENTLE_ON_EOF | |
| PACKET_READ_CHOMP_NEWLINE); |
| |
| while (packet_reader_read(&reader) != PACKET_READ_EOF) { |
| switch (reader.status) { |
| case PACKET_READ_EOF: |
| break; |
| case PACKET_READ_NORMAL: |
| printf("%s\n", reader.line); |
| break; |
| case PACKET_READ_FLUSH: |
| printf("0000\n"); |
| break; |
| case PACKET_READ_DELIM: |
| printf("0001\n"); |
| break; |
| case PACKET_READ_RESPONSE_END: |
| printf("0002\n"); |
| break; |
| } |
| } |
| } |
| |
| static void unpack_sideband(int argc, const char **argv) |
| { |
| struct packet_reader reader; |
| int options = PACKET_READ_GENTLE_ON_EOF; |
| int chomp_newline = 1; |
| int reader_use_sideband = 0; |
| const char *const unpack_sideband_usage[] = { |
| "test_tool unpack_sideband [options...]", NULL |
| }; |
| struct option cmd_options[] = { |
| OPT_BOOL(0, "reader-use-sideband", &reader_use_sideband, |
| "set use_sideband bit for packet reader (Default: off)"), |
| OPT_BOOL(0, "chomp-newline", &chomp_newline, |
| "chomp newline in packet (Default: on)"), |
| OPT_END() |
| }; |
| |
| argc = parse_options(argc, argv, "", cmd_options, unpack_sideband_usage, |
| 0); |
| if (argc > 0) |
| usage_msg_opt(_("too many arguments"), unpack_sideband_usage, |
| cmd_options); |
| |
| if (chomp_newline) |
| options |= PACKET_READ_CHOMP_NEWLINE; |
| packet_reader_init(&reader, 0, NULL, 0, options); |
| reader.use_sideband = reader_use_sideband; |
| |
| while (packet_reader_read(&reader) != PACKET_READ_EOF) { |
| int band; |
| int fd; |
| |
| switch (reader.status) { |
| case PACKET_READ_EOF: |
| break; |
| case PACKET_READ_NORMAL: |
| /* |
| * When the "use_sideband" field of the reader is turned |
| * on, sideband packets other than the payload have been |
| * parsed and consumed in packet_reader_read(), and only |
| * the payload arrives here. |
| */ |
| if (reader.use_sideband) { |
| write_or_die(1, reader.line, reader.pktlen - 1); |
| break; |
| } |
| |
| band = reader.line[0] & 0xff; |
| if (band < 1 || band > 2) |
| continue; /* skip non-sideband packets */ |
| fd = band; |
| |
| write_or_die(fd, reader.line + 1, reader.pktlen - 1); |
| break; |
| case PACKET_READ_FLUSH: |
| return; |
| case PACKET_READ_DELIM: |
| case PACKET_READ_RESPONSE_END: |
| break; |
| } |
| } |
| } |
| |
| static int send_split_sideband(void) |
| { |
| const char *foo = "Foo.\n"; |
| const char *bar = "Bar.\n"; |
| const char *part1 = "Hello,"; |
| const char *primary = "\001primary: regular output\n"; |
| const char *part2 = " world!\n"; |
| |
| /* Each sideband message has a trailing newline character. */ |
| send_sideband(1, 2, foo, strlen(foo), LARGE_PACKET_MAX); |
| send_sideband(1, 2, bar, strlen(bar), LARGE_PACKET_MAX); |
| |
| /* |
| * One sideband message is divided into part1 and part2 |
| * by the primary message. |
| */ |
| send_sideband(1, 2, part1, strlen(part1), LARGE_PACKET_MAX); |
| packet_write(1, primary, strlen(primary)); |
| send_sideband(1, 2, part2, strlen(part2), LARGE_PACKET_MAX); |
| packet_response_end(1); |
| |
| /* |
| * We use unpack_sideband() to consume packets. A flush packet |
| * is required to end parsing. |
| */ |
| packet_flush(1); |
| |
| return 0; |
| } |
| |
| static int receive_sideband(void) |
| { |
| return recv_sideband("sideband", 0, 1); |
| } |
| |
| int cmd__pkt_line(int argc, const char **argv) |
| { |
| if (argc < 2) |
| die("too few arguments"); |
| |
| if (!strcmp(argv[1], "pack")) |
| pack(argc - 2, argv + 2); |
| else if (!strcmp(argv[1], "pack-raw-stdin")) |
| pack_raw_stdin(); |
| else if (!strcmp(argv[1], "unpack")) |
| unpack(); |
| else if (!strcmp(argv[1], "unpack-sideband")) |
| unpack_sideband(argc - 1, argv + 1); |
| else if (!strcmp(argv[1], "send-split-sideband")) |
| send_split_sideband(); |
| else if (!strcmp(argv[1], "receive-sideband")) |
| receive_sideband(); |
| else |
| die("invalid argument '%s'", argv[1]); |
| |
| return 0; |
| } |