git-pack-objects: add "--stdout" flag to write the pack file to stdout
[git/git.git] / unpack-objects.c
CommitLineData
bad50dc8 1#include "cache.h"
74536958 2#include "object.h"
8ee378a0 3#include "delta.h"
bad50dc8 4
74536958 5static int dry_run;
bad50dc8
LT
6static int nr_entries;
7static const char *base_name;
8static const char unpack_usage[] = "git-unpack-objects basename";
9
10struct pack_entry {
8ee378a0 11 unsigned int offset; /* network byte order */
bad50dc8
LT
12 unsigned char sha1[20];
13};
14
74536958
LT
15static void *pack_base;
16static unsigned long pack_size;
8ee378a0
JH
17static void *index_base;
18static unsigned long index_size;
74536958 19
bad50dc8
LT
20static struct pack_entry **pack_list;
21
22static void *map_file(const char *suffix, unsigned long *sizep)
23{
24 static char pathname[PATH_MAX];
25 unsigned long len;
26 int fd;
27 struct stat st;
28 void *map;
29
30 len = snprintf(pathname, PATH_MAX, "%s.%s", base_name, suffix);
31 if (len >= PATH_MAX)
32 die("bad pack base-name");
33 fd = open(pathname, O_RDONLY);
34 if (fd < 0 || fstat(fd, &st))
35 die("unable to open '%s'", pathname);
36 len = st.st_size;
37 if (!len)
38 die("bad pack file '%s'", pathname);
39 map = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
40 if (-1 == (int)(long)map)
41 die("unable to mmap '%s'", pathname);
42 close(fd);
43 *sizep = len;
44 return map;
45}
46
47static int sort_by_offset(const void *_a, const void *_b)
48{
49 struct pack_entry *a = *(struct pack_entry **)_a;
50 struct pack_entry *b = *(struct pack_entry **)_b;
51 unsigned int o1, o2;
52
53 o1 = ntohl(a->offset);
54 o2 = ntohl(b->offset);
55 return o1 < o2 ? -1 : 1;
56}
57
8ee378a0 58static int check_index(void)
bad50dc8 59{
8ee378a0 60 unsigned int *array = index_base;
bad50dc8
LT
61 unsigned int nr;
62 int i;
63
c38138cd 64 if (index_size < 4*256 + 20)
bad50dc8
LT
65 return error("index file too small");
66 nr = 0;
67 for (i = 0; i < 256; i++) {
68 unsigned int n = ntohl(array[i]);
69 if (n < nr)
70 return error("non-monotonic index");
71 nr = n;
72 }
c38138cd
LT
73 /*
74 * Total size:
75 * - 256 index entries 4 bytes each
76 * - 24-byte entries * nr (20-byte sha1 + 4-byte offset)
e1808845 77 * - 20-byte SHA1 of the packfile
c38138cd
LT
78 * - 20-byte SHA1 file checksum
79 */
e1808845 80 if (index_size != 4*256 + nr * 24 + 20 + 20)
bad50dc8 81 return error("wrong index file size");
bad50dc8
LT
82
83 nr_entries = nr;
84 pack_list = xmalloc(nr * sizeof(struct pack_entry *));
85 for (i = 0; i < nr; i++)
8ee378a0 86 pack_list[i] = index_base + 4*256 + i*24;
bad50dc8
LT
87
88 qsort(pack_list, nr, sizeof(*pack_list), sort_by_offset);
89
90 printf("%d entries\n", nr);
91 return 0;
92}
93
8ee378a0 94static int unpack_non_delta_entry(struct pack_entry *entry,
c4fb06c0
LT
95 int kind,
96 unsigned char *data,
97 unsigned long size,
98 unsigned long left)
74536958 99{
c4fb06c0 100 int st;
8ee378a0
JH
101 z_stream stream;
102 char *buffer;
103 unsigned char sha1[20];
104 char *type_s;
8ee378a0 105
8ee378a0 106 printf("%s %c %lu\n", sha1_to_hex(entry->sha1), kind, size);
c4fb06c0
LT
107 if (dry_run)
108 return 0;
8ee378a0
JH
109
110 buffer = xmalloc(size + 1);
111 buffer[size] = 0;
112 memset(&stream, 0, sizeof(stream));
c4fb06c0
LT
113 stream.next_in = data;
114 stream.avail_in = left;
8ee378a0
JH
115 stream.next_out = buffer;
116 stream.avail_out = size;
117
118 inflateInit(&stream);
119 st = inflate(&stream, Z_FINISH);
120 inflateEnd(&stream);
121 if ((st != Z_STREAM_END) || stream.total_out != size)
122 goto err_finish;
123 switch (kind) {
124 case 'C': type_s = "commit"; break;
125 case 'T': type_s = "tree"; break;
126 case 'B': type_s = "blob"; break;
a69d0943 127 case 'G': type_s = "tag"; break;
8ee378a0
JH
128 default: goto err_finish;
129 }
130 if (write_sha1_file(buffer, size, type_s, sha1) < 0)
131 die("failed to write %s (%s)",
132 sha1_to_hex(entry->sha1), type_s);
133 printf("%s %s\n", sha1_to_hex(sha1), type_s);
134 if (memcmp(sha1, entry->sha1, 20))
135 die("resulting %s have wrong SHA1", type_s);
136
137 finish:
138 st = 0;
139 free(buffer);
140 return st;
141 err_finish:
142 st = -1;
143 goto finish;
144}
145
146static int find_pack_entry(unsigned char *sha1, struct pack_entry **ent)
147{
148 int *level1_ofs = index_base;
149 int hi = ntohl(level1_ofs[*sha1]);
150 int lo = ((*sha1 == 0x0) ? 0 : ntohl(level1_ofs[*sha1 - 1]));
151 void *index = index_base + 4*256;
152
153 do {
154 int mi = (lo + hi) / 2;
155 int cmp = memcmp(index + 24 * mi + 4, sha1, 20);
156 if (!cmp) {
157 *ent = index + 24 * mi;
158 return 1;
159 }
c4fb06c0 160 if (cmp > 0)
8ee378a0
JH
161 hi = mi;
162 else
c4fb06c0 163 lo = mi+1;
8ee378a0
JH
164 } while (lo < hi);
165 return 0;
166}
167
168/* forward declaration for a mutually recursive function */
169static void unpack_entry(struct pack_entry *);
170
c4fb06c0
LT
171static int unpack_delta_entry(struct pack_entry *entry,
172 unsigned char *base_sha1,
173 unsigned long delta_size,
174 unsigned long left)
8ee378a0 175{
c4fb06c0
LT
176 void *data, *delta_data, *result, *base;
177 unsigned long data_size, result_size, base_size;
8ee378a0
JH
178 z_stream stream;
179 int st;
180 char type[20];
181 unsigned char sha1[20];
182
c4fb06c0
LT
183 if (left < 20)
184 die("truncated pack file");
185 data = base_sha1 + 20;
186 data_size = left - 20;
187 printf("%s D %lu", sha1_to_hex(entry->sha1), delta_size);
188 printf(" %s\n", sha1_to_hex(base_sha1));
189
190 if (dry_run)
191 return 0;
8ee378a0 192
c4fb06c0 193 /* pack+5 is the base sha1, unless we have it, we need to
8ee378a0
JH
194 * unpack it first.
195 */
c4fb06c0 196 if (!has_sha1_file(base_sha1)) {
8ee378a0 197 struct pack_entry *base;
c4fb06c0 198 if (!find_pack_entry(base_sha1, &base))
8ee378a0
JH
199 die("cannot find delta-pack base object");
200 unpack_entry(base);
201 }
c4fb06c0 202 delta_data = xmalloc(delta_size);
8ee378a0
JH
203
204 memset(&stream, 0, sizeof(stream));
205
c4fb06c0
LT
206 stream.next_in = data;
207 stream.avail_in = data_size;
8ee378a0 208 stream.next_out = delta_data;
c4fb06c0 209 stream.avail_out = delta_size;
8ee378a0
JH
210
211 inflateInit(&stream);
c4fb06c0 212 st = inflate(&stream, Z_FINISH);
8ee378a0 213 inflateEnd(&stream);
c4fb06c0
LT
214 if ((st != Z_STREAM_END) || stream.total_out != delta_size)
215 die("delta data unpack failed");
8ee378a0 216
c4fb06c0 217 base = read_sha1_file(base_sha1, type, &base_size);
8ee378a0 218 if (!base)
c4fb06c0 219 die("failed to read delta-pack base object %s", sha1_to_hex(base_sha1));
8ee378a0
JH
220 result = patch_delta(base, base_size,
221 delta_data, delta_size,
222 &result_size);
223 if (!result)
224 die("failed to apply delta");
225 free(delta_data);
226
227 if (write_sha1_file(result, result_size, type, sha1) < 0)
228 die("failed to write %s (%s)",
229 sha1_to_hex(entry->sha1), type);
230 free(result);
231 printf("%s %s\n", sha1_to_hex(sha1), type);
232 if (memcmp(sha1, entry->sha1, 20))
233 die("resulting %s have wrong SHA1", type);
234 return 0;
235}
236
237static void unpack_entry(struct pack_entry *entry)
238{
c4fb06c0 239 unsigned long offset, size, left;
74536958
LT
240 unsigned char *pack;
241
242 /* Have we done this one already due to deltas based on it? */
243 if (lookup_object(entry->sha1))
244 return;
245
246 offset = ntohl(entry->offset);
247 if (offset > pack_size - 5)
248 die("object offset outside of pack file");
249 pack = pack_base + offset;
c4fb06c0
LT
250 size = (pack[1] << 24) + (pack[2] << 16) + (pack[3] << 8) + pack[4];
251 left = pack_size - offset - 5;
74536958 252 switch (*pack) {
a69d0943 253 case 'C': case 'T': case 'B': case 'G':
c4fb06c0 254 unpack_non_delta_entry(entry, *pack, pack+5, size, left);
74536958
LT
255 break;
256 case 'D':
c4fb06c0 257 unpack_delta_entry(entry, pack+5, size, left);
74536958
LT
258 break;
259 default:
260 die("corrupted pack file");
261 }
262}
263
264/*
265 * We unpack from the end, older files first. Now, usually
266 * there are deltas etc, so we'll not actually write the
267 * objects in that order, but we might as well try..
268 */
269static void unpack_all(void)
270{
271 int i = nr_entries;
272
273 while (--i >= 0) {
274 struct pack_entry *entry = pack_list[i];
275 unpack_entry(entry);
276 }
277}
278
bad50dc8
LT
279int main(int argc, char **argv)
280{
281 int i;
bad50dc8
LT
282
283 for (i = 1 ; i < argc; i++) {
284 const char *arg = argv[i];
285
286 if (*arg == '-') {
74536958
LT
287 if (!strcmp(arg, "-n")) {
288 dry_run = 1;
289 continue;
290 }
bad50dc8
LT
291 usage(unpack_usage);
292 }
293 if (base_name)
294 usage(unpack_usage);
295 base_name = arg;
296 }
297 if (!base_name)
298 usage(unpack_usage);
8ee378a0 299 index_base = map_file("idx", &index_size);
74536958 300 pack_base = map_file("pack", &pack_size);
8ee378a0 301 if (check_index() < 0)
bad50dc8 302 die("bad index file");
74536958 303 unpack_all();
bad50dc8
LT
304 return 0;
305}