static void read_props(void) { uint32_t len; uint32_t key = ~0; char *val = NULL; char *t; while ((t = buffer_read_line()) && strcmp(t, "PROPS-END")) { if (!strncmp(t, "K ", 2)) { len = atoi(&t[2]); key = pool_intern(buffer_read_string(len)); buffer_read_line(); } else if (!strncmp(t, "V ", 2)) { len = atoi(&t[2]); val = buffer_read_string(len); if (key == keys.svn_log) { /* Value length excludes terminating nul. */ rev_ctx.log = log_copy(len + 1, val); } else if (key == keys.svn_author) { rev_ctx.author = pool_intern(val); } else if (key == keys.svn_date) { if (parse_date_basic(val, &rev_ctx.timestamp, NULL)) fprintf(stderr, "Invalid timestamp: %s\n", val); } else if (key == keys.svn_executable) { node_ctx.type = REPO_MODE_EXE; } else if (key == keys.svn_special) { node_ctx.type = REPO_MODE_LNK; } key = ~0; buffer_read_line(); } } }
static int _search_process_lines_from_buffer(ReaderArgs *args) { int status = PROCESS_STATUS_OK; assert(args != NULL); assert(args->buffer != NULL); args->count = 0; while(status == PROCESS_STATUS_OK && buffer_read_line(args->buffer, &args->line, &args->llen)) { status = _search_process_line(args); if(status == PROCESS_STATUS_OK) { if(args->count < INT32_MAX) { ++args->count; } } } return status; }
static const char *get_response_line(void) { const char *line = buffer_read_line(&report_buffer); if (line) return line; if (buffer_ferror(&report_buffer)) die_errno("error reading from fast-import"); die("unexpected end of fast-import feedback"); }
static void read_props(void) { static struct strbuf key = STRBUF_INIT; static struct strbuf val = STRBUF_INIT; const char *t; /* * NEEDSWORK: to support simple mode changes like * K 11 * svn:special * V 1 * * * D 14 * svn:executable * we keep track of whether a mode has been set and reset to * plain file only if not. We should be keeping track of the * symlink and executable bits separately instead. */ uint32_t type_set = 0; while ((t = buffer_read_line(&input)) && strcmp(t, "PROPS-END")) { uint32_t len; const char type = t[0]; int ch; if (!type || t[1] != ' ') die("invalid property line: %s\n", t); len = atoi(&t[2]); strbuf_reset(&val); buffer_read_binary(&input, &val, len); if (val.len < len) die_short_read(); /* Discard trailing newline. */ ch = buffer_read_char(&input); if (ch == EOF) die_short_read(); if (ch != '\n') die("invalid dump: expected newline after %s", val.buf); switch (type) { case 'K': strbuf_swap(&key, &val); continue; case 'D': handle_property(&val, NULL, &type_set); continue; case 'V': handle_property(&key, &val, &type_set); strbuf_reset(&key); continue; default: die("invalid property line: %s\n", t); } } }
int main(int argc, char *argv[]) { char *s; if (argc != 1) usage("test-line-buffer < input.txt"); if (buffer_init(NULL)) die_errno("open error"); while ((s = buffer_read_line())) { s = buffer_read_string(strtouint32(s)); fputs(s, stdout); fputc('\n', stdout); buffer_skip_bytes(1); if (!(s = buffer_read_line())) break; buffer_copy_bytes(strtouint32(s) + 1); } if (buffer_deinit()) die("input error"); if (ferror(stdout)) die("output error"); buffer_reset(); return 0; }
int cmd_main(int argc, const char **argv) { struct line_buffer stdin_buf = LINE_BUFFER_INIT; struct line_buffer file_buf = LINE_BUFFER_INIT; struct line_buffer *input = &stdin_buf; const char *filename; char *s; if (argc == 1) filename = NULL; else if (argc == 2) filename = argv[1]; else usage("test-line-buffer [file | &fd] < script"); if (buffer_init(&stdin_buf, NULL)) die_errno("open error"); if (filename) { if (*filename == '&') { if (buffer_fdinit(&file_buf, strtouint32(filename + 1))) die_errno("error opening fd %s", filename + 1); } else { if (buffer_init(&file_buf, filename)) die_errno("error opening %s", filename); } input = &file_buf; } while ((s = buffer_read_line(&stdin_buf))) handle_line(s, input); if (filename && buffer_deinit(&file_buf)) die("error reading from %s", filename); if (buffer_deinit(&stdin_buf)) die("input error"); if (ferror(stdout)) die("output error"); return 0; }
void svndump_read(const char *url) { char *val; char *t; uint32_t active_ctx = DUMP_CTX; uint32_t len; uint32_t key; reset_dump_ctx(pool_intern(url)); while ((t = buffer_read_line())) { val = strstr(t, ": "); if (!val) continue; *val++ = '\0'; *val++ = '\0'; key = pool_intern(t); if (key == keys.uuid) { dump_ctx.uuid = pool_intern(val); } else if (key == keys.revision_number) { if (active_ctx == NODE_CTX) handle_node(); if (active_ctx != DUMP_CTX) handle_revision(); active_ctx = REV_CTX; reset_rev_ctx(atoi(val)); } else if (key == keys.node_path) { if (active_ctx == NODE_CTX) handle_node(); active_ctx = NODE_CTX; reset_node_ctx(val); } else if (key == keys.node_kind) { if (!strcmp(val, "dir")) node_ctx.type = REPO_MODE_DIR; else if (!strcmp(val, "file")) node_ctx.type = REPO_MODE_BLB; else fprintf(stderr, "Unknown node-kind: %s\n", val); } else if (key == keys.node_action) { if (!strcmp(val, "delete")) { node_ctx.action = NODEACT_DELETE; } else if (!strcmp(val, "add")) { node_ctx.action = NODEACT_ADD; } else if (!strcmp(val, "change")) { node_ctx.action = NODEACT_CHANGE; } else if (!strcmp(val, "replace")) { node_ctx.action = NODEACT_REPLACE; } else { fprintf(stderr, "Unknown node-action: %s\n", val); node_ctx.action = NODEACT_UNKNOWN; } } else if (key == keys.node_copyfrom_path) { pool_tok_seq(REPO_MAX_PATH_DEPTH, node_ctx.src, "/", val); } else if (key == keys.node_copyfrom_rev) { node_ctx.srcRev = atoi(val); } else if (key == keys.text_content_length) { node_ctx.textLength = atoi(val); } else if (key == keys.prop_content_length) { node_ctx.propLength = atoi(val); } else if (key == keys.content_length) { len = atoi(val); buffer_read_line(); if (active_ctx == REV_CTX) { read_props(); } else if (active_ctx == NODE_CTX) { handle_node(); active_ctx = REV_CTX; } else { fprintf(stderr, "Unexpected content length header: %d\n", len); buffer_skip_bytes(len); } } } if (active_ctx == NODE_CTX) handle_node(); if (active_ctx != DUMP_CTX) handle_revision(); }
void svndump_read(const char *url) { char *val; char *t; uint32_t active_ctx = DUMP_CTX; uint32_t len; reset_dump_ctx(url); while ((t = buffer_read_line(&input))) { val = strchr(t, ':'); if (!val) continue; val++; if (*val != ' ') continue; val++; /* strlen(key) + 1 */ switch (val - t - 1) { case sizeof("SVN-fs-dump-format-version"): if (constcmp(t, "SVN-fs-dump-format-version")) continue; dump_ctx.version = atoi(val); if (dump_ctx.version > 3) die("expected svn dump format version <= 3, found %"PRIu32, dump_ctx.version); break; case sizeof("UUID"): if (constcmp(t, "UUID")) continue; strbuf_reset(&dump_ctx.uuid); strbuf_addstr(&dump_ctx.uuid, val); break; case sizeof("Revision-number"): if (constcmp(t, "Revision-number")) continue; if (active_ctx == NODE_CTX) handle_node(); if (active_ctx == REV_CTX) begin_revision(); if (active_ctx != DUMP_CTX) end_revision(); active_ctx = REV_CTX; reset_rev_ctx(atoi(val)); break; case sizeof("Node-path"): if (prefixcmp(t, "Node-")) continue; if (!constcmp(t + strlen("Node-"), "path")) { if (active_ctx == NODE_CTX) handle_node(); if (active_ctx == REV_CTX) begin_revision(); active_ctx = NODE_CTX; reset_node_ctx(val); break; } if (constcmp(t + strlen("Node-"), "kind")) continue; if (!strcmp(val, "dir")) node_ctx.type = REPO_MODE_DIR; else if (!strcmp(val, "file")) node_ctx.type = REPO_MODE_BLB; else fprintf(stderr, "Unknown node-kind: %s\n", val); break; case sizeof("Node-action"): if (constcmp(t, "Node-action")) continue; if (!strcmp(val, "delete")) { node_ctx.action = NODEACT_DELETE; } else if (!strcmp(val, "add")) { node_ctx.action = NODEACT_ADD; } else if (!strcmp(val, "change")) { node_ctx.action = NODEACT_CHANGE; } else if (!strcmp(val, "replace")) { node_ctx.action = NODEACT_REPLACE; } else { fprintf(stderr, "Unknown node-action: %s\n", val); node_ctx.action = NODEACT_UNKNOWN; } break; case sizeof("Node-copyfrom-path"): if (constcmp(t, "Node-copyfrom-path")) continue; strbuf_reset(&node_ctx.src); strbuf_addstr(&node_ctx.src, val); break; case sizeof("Node-copyfrom-rev"): if (constcmp(t, "Node-copyfrom-rev")) continue; node_ctx.srcRev = atoi(val); break; case sizeof("Text-content-length"): if (!constcmp(t, "Text-content-length")) { char *end; uintmax_t textlen; textlen = strtoumax(val, &end, 10); if (!isdigit(*val) || *end) die("invalid dump: non-numeric length %s", val); if (textlen > maximum_signed_value_of_type(off_t)) die("unrepresentable length in dump: %s", val); node_ctx.text_length = (off_t) textlen; break; } if (constcmp(t, "Prop-content-length")) continue; node_ctx.propLength = atoi(val); break; case sizeof("Text-delta"): if (!constcmp(t, "Text-delta")) { node_ctx.text_delta = !strcmp(val, "true"); break; } if (constcmp(t, "Prop-delta")) continue; node_ctx.prop_delta = !strcmp(val, "true"); break; case sizeof("Content-length"): if (constcmp(t, "Content-length")) continue; len = atoi(val); t = buffer_read_line(&input); if (!t) die_short_read(); if (*t) die("invalid dump: expected blank line after content length header"); if (active_ctx == REV_CTX) { read_props(); } else if (active_ctx == NODE_CTX) { handle_node(); active_ctx = INTERNODE_CTX; } else { fprintf(stderr, "Unexpected content length header: %"PRIu32"\n", len); if (buffer_skip_bytes(&input, len) != len) die_short_read(); } } } if (buffer_ferror(&input)) die_short_read(); if (active_ctx == NODE_CTX) handle_node(); if (active_ctx == REV_CTX) begin_revision(); if (active_ctx != DUMP_CTX) end_revision(); }