]>
Commit | Line | Data |
---|---|---|
575f4974 | 1 | #include "cache.h" |
8a65ff76 | 2 | #include "refs.h" |
f3a3214e | 3 | #include "pkt-line.h" |
b1bf95bb | 4 | #include "run-command.h" |
575f4974 | 5 | |
d0efc8a7 | 6 | static const char receive_pack_usage[] = "git-receive-pack <git-dir>"; |
575f4974 | 7 | |
9201c707 | 8 | static const char *unpacker[] = { "unpack-objects", NULL }; |
575f4974 | 9 | |
96f1e58f | 10 | static int report_status; |
cfee10a7 JH |
11 | |
12 | static char capabilities[] = "report-status"; | |
96f1e58f | 13 | static int capabilities_sent; |
cfee10a7 | 14 | |
944d8589 | 15 | static int show_ref(const char *path, const unsigned char *sha1) |
575f4974 | 16 | { |
cfee10a7 JH |
17 | if (capabilities_sent) |
18 | packet_write(1, "%s %s\n", sha1_to_hex(sha1), path); | |
19 | else | |
20 | packet_write(1, "%s %s%c%s\n", | |
21 | sha1_to_hex(sha1), path, 0, capabilities); | |
22 | capabilities_sent = 1; | |
8a65ff76 | 23 | return 0; |
575f4974 LT |
24 | } |
25 | ||
8a65ff76 | 26 | static void write_head_info(void) |
575f4974 | 27 | { |
8a65ff76 | 28 | for_each_ref(show_ref); |
cfee10a7 JH |
29 | if (!capabilities_sent) |
30 | show_ref("capabilities^{}", null_sha1); | |
31 | ||
575f4974 LT |
32 | } |
33 | ||
eb1af2df LT |
34 | struct command { |
35 | struct command *next; | |
cfee10a7 | 36 | const char *error_string; |
eb1af2df LT |
37 | unsigned char old_sha1[20]; |
38 | unsigned char new_sha1[20]; | |
8f1d2e6f | 39 | char ref_name[FLEX_ARRAY]; /* more */ |
575f4974 LT |
40 | }; |
41 | ||
96f1e58f | 42 | static struct command *commands; |
575f4974 | 43 | |
f65fdf04 LT |
44 | static int is_all_zeroes(const char *hex) |
45 | { | |
46 | int i; | |
47 | for (i = 0; i < 40; i++) | |
48 | if (*hex++ != '0') | |
49 | return 0; | |
50 | return 1; | |
51 | } | |
52 | ||
2eca23da LT |
53 | static int verify_old_ref(const char *name, char *hex_contents) |
54 | { | |
55 | int fd, ret; | |
56 | char buffer[60]; | |
57 | ||
f65fdf04 LT |
58 | if (is_all_zeroes(hex_contents)) |
59 | return 0; | |
2eca23da LT |
60 | fd = open(name, O_RDONLY); |
61 | if (fd < 0) | |
62 | return -1; | |
63 | ret = read(fd, buffer, 40); | |
64 | close(fd); | |
65 | if (ret != 40) | |
66 | return -1; | |
67 | if (memcmp(buffer, hex_contents, 40)) | |
68 | return -1; | |
69 | return 0; | |
70 | } | |
71 | ||
b1bf95bb JW |
72 | static char update_hook[] = "hooks/update"; |
73 | ||
74 | static int run_update_hook(const char *refname, | |
75 | char *old_hex, char *new_hex) | |
76 | { | |
77 | int code; | |
78 | ||
79 | if (access(update_hook, X_OK) < 0) | |
80 | return 0; | |
81 | code = run_command(update_hook, refname, old_hex, new_hex, NULL); | |
82 | switch (code) { | |
83 | case 0: | |
84 | return 0; | |
85 | case -ERR_RUN_COMMAND_FORK: | |
cfee10a7 | 86 | return error("hook fork failed"); |
b1bf95bb | 87 | case -ERR_RUN_COMMAND_EXEC: |
cfee10a7 | 88 | return error("hook execute failed"); |
b1bf95bb | 89 | case -ERR_RUN_COMMAND_WAITPID: |
cfee10a7 | 90 | return error("waitpid failed"); |
b1bf95bb | 91 | case -ERR_RUN_COMMAND_WAITPID_WRONG_PID: |
cfee10a7 | 92 | return error("waitpid is confused"); |
b1bf95bb | 93 | case -ERR_RUN_COMMAND_WAITPID_SIGNAL: |
bd2afde8 | 94 | return error("%s died of signal", update_hook); |
b1bf95bb | 95 | case -ERR_RUN_COMMAND_WAITPID_NOEXIT: |
cfee10a7 | 96 | return error("%s died strangely", update_hook); |
b1bf95bb JW |
97 | default: |
98 | error("%s exited with error code %d", update_hook, -code); | |
99 | return -code; | |
100 | } | |
101 | } | |
102 | ||
cfee10a7 | 103 | static int update(struct command *cmd) |
2eca23da | 104 | { |
cfee10a7 JH |
105 | const char *name = cmd->ref_name; |
106 | unsigned char *old_sha1 = cmd->old_sha1; | |
107 | unsigned char *new_sha1 = cmd->new_sha1; | |
2eca23da LT |
108 | char new_hex[60], *old_hex, *lock_name; |
109 | int newfd, namelen, written; | |
110 | ||
cfee10a7 JH |
111 | cmd->error_string = NULL; |
112 | if (!strncmp(name, "refs/", 5) && check_ref_format(name + 5)) { | |
113 | cmd->error_string = "funny refname"; | |
d8a1deec JH |
114 | return error("refusing to create funny ref '%s' locally", |
115 | name); | |
cfee10a7 | 116 | } |
d8a1deec | 117 | |
2eca23da LT |
118 | namelen = strlen(name); |
119 | lock_name = xmalloc(namelen + 10); | |
120 | memcpy(lock_name, name, namelen); | |
121 | memcpy(lock_name + namelen, ".lock", 6); | |
122 | ||
123 | strcpy(new_hex, sha1_to_hex(new_sha1)); | |
2eca23da | 124 | old_hex = sha1_to_hex(old_sha1); |
cfee10a7 JH |
125 | if (!has_sha1_file(new_sha1)) { |
126 | cmd->error_string = "bad pack"; | |
19614330 JH |
127 | return error("unpack should have generated %s, " |
128 | "but I can't find it!", new_hex); | |
cfee10a7 | 129 | } |
29f3b3de JH |
130 | safe_create_leading_directories(lock_name); |
131 | ||
f312de01 | 132 | newfd = open(lock_name, O_CREAT | O_EXCL | O_WRONLY, 0666); |
cfee10a7 JH |
133 | if (newfd < 0) { |
134 | cmd->error_string = "can't lock"; | |
19614330 JH |
135 | return error("unable to create %s (%s)", |
136 | lock_name, strerror(errno)); | |
cfee10a7 | 137 | } |
f65fdf04 LT |
138 | |
139 | /* Write the ref with an ending '\n' */ | |
140 | new_hex[40] = '\n'; | |
141 | new_hex[41] = 0; | |
2eca23da | 142 | written = write(newfd, new_hex, 41); |
f65fdf04 LT |
143 | /* Remove the '\n' again */ |
144 | new_hex[40] = 0; | |
145 | ||
2eca23da LT |
146 | close(newfd); |
147 | if (written != 41) { | |
148 | unlink(lock_name); | |
cfee10a7 | 149 | cmd->error_string = "can't write"; |
19614330 | 150 | return error("unable to write %s", lock_name); |
2eca23da LT |
151 | } |
152 | if (verify_old_ref(name, old_hex) < 0) { | |
153 | unlink(lock_name); | |
cfee10a7 | 154 | cmd->error_string = "raced"; |
19614330 | 155 | return error("%s changed during push", name); |
2eca23da | 156 | } |
b1bf95bb JW |
157 | if (run_update_hook(name, old_hex, new_hex)) { |
158 | unlink(lock_name); | |
cfee10a7 | 159 | cmd->error_string = "hook declined"; |
bd2afde8 | 160 | return error("hook declined to update %s", name); |
b1bf95bb JW |
161 | } |
162 | else if (rename(lock_name, name) < 0) { | |
2eca23da | 163 | unlink(lock_name); |
cfee10a7 | 164 | cmd->error_string = "can't rename"; |
19614330 | 165 | return error("unable to replace %s", name); |
2eca23da | 166 | } |
19614330 | 167 | else { |
b1bf95bb | 168 | fprintf(stderr, "%s: %s -> %s\n", name, old_hex, new_hex); |
19614330 JH |
169 | return 0; |
170 | } | |
2eca23da LT |
171 | } |
172 | ||
19614330 JH |
173 | static char update_post_hook[] = "hooks/post-update"; |
174 | ||
175 | static void run_update_post_hook(struct command *cmd) | |
176 | { | |
177 | struct command *cmd_p; | |
178 | int argc; | |
9201c707 | 179 | const char **argv; |
19614330 JH |
180 | |
181 | if (access(update_post_hook, X_OK) < 0) | |
182 | return; | |
183 | for (argc = 1, cmd_p = cmd; cmd_p; cmd_p = cmd_p->next) { | |
cfee10a7 | 184 | if (cmd_p->error_string) |
19614330 JH |
185 | continue; |
186 | argc++; | |
187 | } | |
188 | argv = xmalloc(sizeof(*argv) * (1 + argc)); | |
189 | argv[0] = update_post_hook; | |
190 | ||
191 | for (argc = 1, cmd_p = cmd; cmd_p; cmd_p = cmd_p->next) { | |
9201c707 | 192 | char *p; |
cfee10a7 | 193 | if (cmd_p->error_string) |
19614330 | 194 | continue; |
9201c707 JH |
195 | p = xmalloc(strlen(cmd_p->ref_name) + 1); |
196 | strcpy(p, cmd_p->ref_name); | |
197 | argv[argc] = p; | |
19614330 JH |
198 | argc++; |
199 | } | |
200 | argv[argc] = NULL; | |
128aed68 | 201 | run_command_v_opt(argc, argv, RUN_COMMAND_NO_STDIO); |
19614330 | 202 | } |
2eca23da | 203 | |
575f4974 LT |
204 | /* |
205 | * This gets called after(if) we've successfully | |
206 | * unpacked the data payload. | |
207 | */ | |
208 | static void execute_commands(void) | |
209 | { | |
eb1af2df LT |
210 | struct command *cmd = commands; |
211 | ||
212 | while (cmd) { | |
cfee10a7 | 213 | update(cmd); |
eb1af2df | 214 | cmd = cmd->next; |
575f4974 | 215 | } |
19614330 | 216 | run_update_post_hook(commands); |
575f4974 LT |
217 | } |
218 | ||
219 | static void read_head_info(void) | |
220 | { | |
eb1af2df | 221 | struct command **p = &commands; |
575f4974 LT |
222 | for (;;) { |
223 | static char line[1000]; | |
eb1af2df LT |
224 | unsigned char old_sha1[20], new_sha1[20]; |
225 | struct command *cmd; | |
cfee10a7 JH |
226 | char *refname; |
227 | int len, reflen; | |
eb1af2df LT |
228 | |
229 | len = packet_read_line(0, line, sizeof(line)); | |
575f4974 LT |
230 | if (!len) |
231 | break; | |
eb1af2df LT |
232 | if (line[len-1] == '\n') |
233 | line[--len] = 0; | |
234 | if (len < 83 || | |
235 | line[40] != ' ' || | |
236 | line[81] != ' ' || | |
237 | get_sha1_hex(line, old_sha1) || | |
238 | get_sha1_hex(line + 41, new_sha1)) | |
cfee10a7 JH |
239 | die("protocol error: expected old/new/ref, got '%s'", |
240 | line); | |
241 | ||
242 | refname = line + 82; | |
243 | reflen = strlen(refname); | |
244 | if (reflen + 82 < len) { | |
245 | if (strstr(refname + reflen + 1, "report-status")) | |
246 | report_status = 1; | |
247 | } | |
eb1af2df | 248 | cmd = xmalloc(sizeof(struct command) + len - 80); |
e702496e SP |
249 | hashcpy(cmd->old_sha1, old_sha1); |
250 | hashcpy(cmd->new_sha1, new_sha1); | |
eb1af2df | 251 | memcpy(cmd->ref_name, line + 82, len - 81); |
cfee10a7 | 252 | cmd->error_string = "n/a (unpacker error)"; |
eb1af2df LT |
253 | cmd->next = NULL; |
254 | *p = cmd; | |
255 | p = &cmd->next; | |
575f4974 LT |
256 | } |
257 | } | |
258 | ||
cfee10a7 | 259 | static const char *unpack(int *error_code) |
575f4974 | 260 | { |
77cb17e9 | 261 | int code = run_command_v_opt(1, unpacker, RUN_GIT_CMD); |
cfee10a7 JH |
262 | |
263 | *error_code = 0; | |
b1bf95bb JW |
264 | switch (code) { |
265 | case 0: | |
cfee10a7 | 266 | return NULL; |
b1bf95bb | 267 | case -ERR_RUN_COMMAND_FORK: |
cfee10a7 | 268 | return "unpack fork failed"; |
b1bf95bb | 269 | case -ERR_RUN_COMMAND_EXEC: |
cfee10a7 | 270 | return "unpack execute failed"; |
b1bf95bb | 271 | case -ERR_RUN_COMMAND_WAITPID: |
cfee10a7 | 272 | return "waitpid failed"; |
b1bf95bb | 273 | case -ERR_RUN_COMMAND_WAITPID_WRONG_PID: |
cfee10a7 | 274 | return "waitpid is confused"; |
b1bf95bb | 275 | case -ERR_RUN_COMMAND_WAITPID_SIGNAL: |
cfee10a7 | 276 | return "unpacker died of signal"; |
b1bf95bb | 277 | case -ERR_RUN_COMMAND_WAITPID_NOEXIT: |
cfee10a7 | 278 | return "unpacker died strangely"; |
b1bf95bb | 279 | default: |
cfee10a7 JH |
280 | *error_code = -code; |
281 | return "unpacker exited with error code"; | |
282 | } | |
283 | } | |
284 | ||
285 | static void report(const char *unpack_status) | |
286 | { | |
287 | struct command *cmd; | |
288 | packet_write(1, "unpack %s\n", | |
289 | unpack_status ? unpack_status : "ok"); | |
290 | for (cmd = commands; cmd; cmd = cmd->next) { | |
291 | if (!cmd->error_string) | |
292 | packet_write(1, "ok %s\n", | |
293 | cmd->ref_name); | |
294 | else | |
295 | packet_write(1, "ng %s %s\n", | |
296 | cmd->ref_name, cmd->error_string); | |
575f4974 | 297 | } |
cfee10a7 | 298 | packet_flush(1); |
575f4974 LT |
299 | } |
300 | ||
301 | int main(int argc, char **argv) | |
302 | { | |
d0efc8a7 | 303 | int i; |
8d630132 | 304 | char *dir = NULL; |
575f4974 LT |
305 | |
306 | argv++; | |
307 | for (i = 1; i < argc; i++) { | |
8d630132 | 308 | char *arg = *argv++; |
575f4974 LT |
309 | |
310 | if (*arg == '-') { | |
575f4974 LT |
311 | /* Do flag handling here */ |
312 | usage(receive_pack_usage); | |
313 | } | |
d0efc8a7 LT |
314 | if (dir) |
315 | usage(receive_pack_usage); | |
575f4974 | 316 | dir = arg; |
575f4974 LT |
317 | } |
318 | if (!dir) | |
319 | usage(receive_pack_usage); | |
320 | ||
8d630132 AE |
321 | if(!enter_repo(dir, 0)) |
322 | die("'%s': unable to chdir or not a git archive", dir); | |
575f4974 | 323 | |
8a65ff76 | 324 | write_head_info(); |
575f4974 LT |
325 | |
326 | /* EOF */ | |
f3a3214e | 327 | packet_flush(1); |
575f4974 LT |
328 | |
329 | read_head_info(); | |
7f8e9828 | 330 | if (commands) { |
cfee10a7 JH |
331 | int code; |
332 | const char *unpack_status = unpack(&code); | |
333 | if (!unpack_status) | |
334 | execute_commands(); | |
335 | if (report_status) | |
336 | report(unpack_status); | |
7f8e9828 | 337 | } |
575f4974 LT |
338 | return 0; |
339 | } |