static void *get_data(unsigned long size) { git_zstream stream; void *buf = xmalloc(size); memset(&stream, 0, sizeof(stream)); stream.next_out = buf; stream.avail_out = size; stream.next_in = fill(1); stream.avail_in = len; git_inflate_init(&stream); for (;;) { int ret = git_inflate(&stream, 0); use(len - stream.avail_in); if (stream.total_out == size && ret == Z_STREAM_END) break; if (ret != Z_OK) { error("inflate returned %d", ret); free(buf); buf = NULL; if (!recover) exit(1); has_errors = 1; break; } stream.next_in = fill(1); stream.avail_in = len; } git_inflate_end(&stream); return buf; }
static void inflate_request(const char *prog_name, int out, int buffer_input) { git_zstream stream; unsigned char *full_request = NULL; unsigned char in_buf[8192]; unsigned char out_buf[8192]; unsigned long cnt = 0; memset(&stream, 0, sizeof(stream)); git_inflate_init_gzip_only(&stream); while (1) { ssize_t n; if (buffer_input) { if (full_request) n = 0; /* nothing left to read */ else n = read_request(0, &full_request); stream.next_in = full_request; } else { n = xread(0, in_buf, sizeof(in_buf)); stream.next_in = in_buf; } if (n <= 0) die("request ended in the middle of the gzip stream"); stream.avail_in = n; while (0 < stream.avail_in) { int ret; stream.next_out = out_buf; stream.avail_out = sizeof(out_buf); ret = git_inflate(&stream, Z_NO_FLUSH); if (ret != Z_OK && ret != Z_STREAM_END) die("zlib error inflating request, result %d", ret); n = stream.total_out - cnt; if (write_in_full(out, out_buf, n) != n) die("%s aborted reading request", prog_name); cnt += n; if (ret == Z_STREAM_END) goto done; } } done: git_inflate_end(&stream); close(out); free(full_request); }
static read_method_decl(pack_non_delta) { size_t total_read = 0; switch (st->z_state) { case z_unused: memset(&st->z, 0, sizeof(st->z)); git_inflate_init(&st->z); st->z_state = z_used; break; case z_done: return 0; case z_error: return -1; case z_used: break; } while (total_read < sz) { int status; struct pack_window *window = NULL; unsigned char *mapped; mapped = use_pack(st->u.in_pack.pack, &window, st->u.in_pack.pos, &st->z.avail_in); st->z.next_out = (unsigned char *)buf + total_read; st->z.avail_out = sz - total_read; st->z.next_in = mapped; status = git_inflate(&st->z, Z_FINISH); st->u.in_pack.pos += st->z.next_in - mapped; total_read = st->z.next_out - (unsigned char *)buf; unuse_pack(&window); if (status == Z_STREAM_END) { git_inflate_end(&st->z); st->z_state = z_done; break; } if (status != Z_OK && status != Z_BUF_ERROR) { git_inflate_end(&st->z); st->z_state = z_error; return -1; } } return total_read; }
static read_method_decl(loose) { size_t total_read = 0; switch (st->z_state) { case z_done: return 0; case z_error: return -1; default: break; } if (st->u.loose.hdr_used < st->u.loose.hdr_avail) { size_t to_copy = st->u.loose.hdr_avail - st->u.loose.hdr_used; if (sz < to_copy) to_copy = sz; memcpy(buf, st->u.loose.hdr + st->u.loose.hdr_used, to_copy); st->u.loose.hdr_used += to_copy; total_read += to_copy; } while (total_read < sz) { int status; st->z.next_out = (unsigned char *)buf + total_read; st->z.avail_out = sz - total_read; status = git_inflate(&st->z, Z_FINISH); total_read = st->z.next_out - (unsigned char *)buf; if (status == Z_STREAM_END) { git_inflate_end(&st->z); st->z_state = z_done; break; } if (status != Z_OK && (status != Z_BUF_ERROR || total_read < sz)) { git_inflate_end(&st->z); st->z_state = z_error; return -1; } } return total_read; }
static void *get_data_from_pack(struct object_entry *obj) { off_t from = obj[0].idx.offset + obj[0].hdr_size; unsigned long len = obj[1].idx.offset - from; unsigned char *data, *inbuf; git_zstream stream; int status; data = xmalloc(obj->size); inbuf = xmalloc((len < 64*1024) ? len : 64*1024); memset(&stream, 0, sizeof(stream)); git_inflate_init(&stream); stream.next_out = data; stream.avail_out = obj->size; do { ssize_t n = (len < 64*1024) ? len : 64*1024; n = pread(pack_fd, inbuf, n, from); if (n < 0) die_errno(_("cannot pread pack file")); if (!n) die(Q_("premature end of pack file, %lu byte missing", "premature end of pack file, %lu bytes missing", len), len); from += n; len -= n; stream.next_in = inbuf; stream.avail_in = n; status = git_inflate(&stream, 0); } while (len && status == Z_OK && !stream.avail_in); /* This has been inflated OK when first encountered, so... */ if (status != Z_STREAM_END || stream.total_out != obj->size) die(_("serious inflate inconsistency")); git_inflate_end(&stream); free(inbuf); return data; }
static void *unpack_entry_data(unsigned long offset, unsigned long size) { int status; z_stream stream; void *buf = xmalloc(size); memset(&stream, 0, sizeof(stream)); git_inflate_init(&stream); stream.next_out = buf; stream.avail_out = size; do { stream.next_in = fill(1); stream.avail_in = input_len; status = git_inflate(&stream, 0); use(input_len - stream.avail_in); } while (status == Z_OK); if (stream.total_out != size || status != Z_STREAM_END) bad_object(offset, "inflate returned %d", status); git_inflate_end(&stream); return buf; }