/* * Processes a section header in a server's response and checks if it matches * `section`. If the value of `peek` is 1, the header line will be peeked (and * not consumed); if 0, the line will be consumed and the function will die if * the section header doesn't match what was expected. */ static int process_section_header(struct packet_reader *reader, const char *section, int peek) { int ret; if (packet_reader_peek(reader) != PACKET_READ_NORMAL) die(_("error reading section header '%s'"), section); ret = !strcmp(reader->line, section); if (!peek) { if (!ret) die(_("expected '%s', received '%s'"), section, reader->line); packet_reader_read(reader); } return ret; }
static int stateless_connect(const char *service_name) { struct discovery *discover; struct proxy_state p; /* * Run the info/refs request and see if the server supports protocol * v2. If and only if the server supports v2 can we successfully * establish a stateless connection, otherwise we need to tell the * client to fallback to using other transport helper functions to * complete their request. */ discover = discover_refs(service_name, 0); if (discover->version != protocol_v2) { printf("fallback\n"); fflush(stdout); return -1; } else { /* Stateless Connection established */ printf("\n"); fflush(stdout); } proxy_state_init(&p, service_name, discover->version); /* * Dump the capability listing that we got from the server earlier * during the info/refs request. */ write_or_die(p.out, discover->buf, discover->len); /* Peek the next packet line. Until we see EOF keep sending POSTs */ while (packet_reader_peek(&p.reader) != PACKET_READ_EOF) { if (proxy_request(&p)) { /* We would have an err here */ break; } } proxy_state_clear(&p); return 0; }
enum protocol_version discover_version(struct packet_reader *reader) { enum protocol_version version = protocol_unknown_version; /* * Peek the first line of the server's response to * determine the protocol version the server is speaking. */ switch (packet_reader_peek(reader)) { case PACKET_READ_EOF: die_initial_contact(0); case PACKET_READ_FLUSH: case PACKET_READ_DELIM: version = protocol_v0; break; case PACKET_READ_NORMAL: version = determine_protocol_version_client(reader->line); break; } switch (version) { case protocol_v2: process_capabilities_v2(reader); break; case protocol_v1: /* Read the peeked version line */ packet_reader_read(reader); break; case protocol_v0: break; case protocol_unknown_version: BUG("unknown protocol version"); } return version; }