1#include "cache.h"
2#include "commit.h"
3#include "tag.h"
4#include "refs.h"
5#include "pkt-line.h"
6#include "exec_cmd.h"
7static const char send_pack_usage[] =
9"git-send-pack [--all] [--exec=git-receive-pack] <remote> [<head>...]\n"
10" --all and explicit <head> specification are mutually exclusive.";
11static const char *exec = "git-receive-pack";
12static int verbose;
13static int send_all;
14static int force_update;
15static int use_thin_pack;
16/*
18 * Make a pack stream and spit it out into file descriptor fd
19 */
20static int pack_objects(int fd, struct ref *refs)
21{
22 int pipe_fd[2];
23 pid_t pid;
24 if (pipe(pipe_fd) < 0)
26 return error("send-pack: pipe failed");
27 pid = fork();
28 if (!pid) {
29 /*
30 * The child becomes pack-objects --revs; we feed
31 * the revision parameters to it via its stdin and
32 * let its stdout go back to the other end.
33 */
34 static const char *args[] = {
35 "pack-objects",
36 "--all-progress",
37 "--revs",
38 "--stdout",
39 NULL,
40 NULL,
41 };
42 if (use_thin_pack)
43 args[4] = "--thin";
44 dup2(pipe_fd[0], 0);
45 dup2(fd, 1);
46 close(pipe_fd[0]);
47 close(pipe_fd[1]);
48 close(fd);
49 execv_git_cmd(args);
50 die("git-pack-objects exec failed (%s)", strerror(errno));
51 }
52 /*
54 * We feed the pack-objects we just spawned with revision
55 * parameters by writing to the pipe.
56 */
57 close(pipe_fd[0]);
58 close(fd);
59 while (refs) {
61 char buf[42];
62 if (!is_null_sha1(refs->old_sha1) &&
64 has_sha1_file(refs->old_sha1)) {
65 memcpy(buf + 1, sha1_to_hex(refs->old_sha1), 40);
66 buf[0] = '^';
67 buf[41] = '\n';
68 if (!write_or_whine(pipe_fd[1], buf, 42,
69 "send-pack: send refs"))
70 break;
71 }
72 if (!is_null_sha1(refs->new_sha1)) {
73 memcpy(buf, sha1_to_hex(refs->new_sha1), 40);
74 buf[40] = '\n';
75 if (!write_or_whine(pipe_fd[1], buf, 41,
76 "send-pack: send refs"))
77 break;
78 }
79 refs = refs->next;
80 }
81 close(pipe_fd[1]);
82 for (;;) {
84 int status, code;
85 pid_t waiting = waitpid(pid, &status, 0);
86 if (waiting < 0) {
88 if (errno == EINTR)
89 continue;
90 return error("waitpid failed (%s)", strerror(errno));
91 }
92 if ((waiting != pid) || WIFSIGNALED(status) ||
93 !WIFEXITED(status))
94 return error("pack-objects died with strange error");
95 code = WEXITSTATUS(status);
96 if (code)
97 return -code;
98 return 0;
99 }
100}
101static void unmark_and_free(struct commit_list *list, unsigned int mark)
103{
104 while (list) {
105 struct commit_list *temp = list;
106 temp->item->object.flags &= ~mark;
107 list = temp->next;
108 free(temp);
109 }
110}
111static int ref_newer(const unsigned char *new_sha1,
113 const unsigned char *old_sha1)
114{
115 struct object *o;
116 struct commit *old, *new;
117 struct commit_list *list, *used;
118 int found = 0;
119 /* Both new and old must be commit-ish and new is descendant of
121 * old. Otherwise we require --force.
122 */
123 o = deref_tag(parse_object(old_sha1), NULL, 0);
124 if (!o || o->type != OBJ_COMMIT)
125 return 0;
126 old = (struct commit *) o;
127 o = deref_tag(parse_object(new_sha1), NULL, 0);
129 if (!o || o->type != OBJ_COMMIT)
130 return 0;
131 new = (struct commit *) o;
132 if (parse_commit(new) < 0)
134 return 0;
135 used = list = NULL;
137 commit_list_insert(new, &list);
138 while (list) {
139 new = pop_most_recent_commit(&list, 1);
140 commit_list_insert(new, &used);
141 if (new == old) {
142 found = 1;
143 break;
144 }
145 }
146 unmark_and_free(list, 1);
147 unmark_and_free(used, 1);
148 return found;
149}
150static struct ref *local_refs, **local_tail;
152static struct ref *remote_refs, **remote_tail;
153static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
155{
156 struct ref *ref;
157 int len = strlen(refname) + 1;
158 ref = xcalloc(1, sizeof(*ref) + len);
159 hashcpy(ref->new_sha1, sha1);
160 memcpy(ref->name, refname, len);
161 *local_tail = ref;
162 local_tail = &ref->next;
163 return 0;
164}
165static void get_local_heads(void)
167{
168 local_tail = &local_refs;
169 for_each_ref(one_local_ref, NULL);
170}
171static int receive_status(int in)
173{
174 char line[1000];
175 int ret = 0;
176 int len = packet_read_line(in, line, sizeof(line));
177 if (len < 10 || memcmp(line, "unpack ", 7)) {
178 fprintf(stderr, "did not receive status back\n");
179 return -1;
180 }
181 if (memcmp(line, "unpack ok\n", 10)) {
182 fputs(line, stderr);
183 ret = -1;
184 }
185 while (1) {
186 len = packet_read_line(in, line, sizeof(line));
187 if (!len)
188 break;
189 if (len < 3 ||
190 (memcmp(line, "ok", 2) && memcmp(line, "ng", 2))) {
191 fprintf(stderr, "protocol error: %s\n", line);
192 ret = -1;
193 break;
194 }
195 if (!memcmp(line, "ok", 2))
196 continue;
197 fputs(line, stderr);
198 ret = -1;
199 }
200 return ret;
201}
202static int send_pack(int in, int out, int nr_refspec, char **refspec)
204{
205 struct ref *ref;
206 int new_refs;
207 int ret = 0;
208 int ask_for_status_report = 0;
209 int allow_deleting_refs = 0;
210 int expect_status_report = 0;
211 /* No funny business with the matcher */
213 remote_tail = get_remote_heads(in, &remote_refs, 0, NULL, REF_NORMAL);
214 get_local_heads();
215 /* Does the other end support the reporting? */
217 if (server_supports("report-status"))
218 ask_for_status_report = 1;
219 if (server_supports("delete-refs"))
220 allow_deleting_refs = 1;
221 /* match them up */
223 if (!remote_tail)
224 remote_tail = &remote_refs;
225 if (match_refs(local_refs, remote_refs, &remote_tail,
226 nr_refspec, refspec, send_all))
227 return -1;
228 if (!remote_refs) {
230 fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
231 return 0;
232 }
233 /*
235 * Finally, tell the other end!
236 */
237 new_refs = 0;
238 for (ref = remote_refs; ref; ref = ref->next) {
239 char old_hex[60], *new_hex;
240 int delete_ref;
241 if (!ref->peer_ref)
243 continue;
244 delete_ref = is_null_sha1(ref->peer_ref->new_sha1);
246 if (delete_ref && !allow_deleting_refs) {
247 error("remote does not support deleting refs");
248 ret = -2;
249 continue;
250 }
251 if (!delete_ref &&
252 !hashcmp(ref->old_sha1, ref->peer_ref->new_sha1)) {
253 if (verbose)
254 fprintf(stderr, "'%s': up-to-date\n", ref->name);
255 continue;
256 }
257 /* This part determines what can overwrite what.
259 * The rules are:
260 *
261 * (0) you can always use --force or +A:B notation to
262 * selectively force individual ref pairs.
263 *
264 * (1) if the old thing does not exist, it is OK.
265 *
266 * (2) if you do not have the old thing, you are not allowed
267 * to overwrite it; you would not know what you are losing
268 * otherwise.
269 *
270 * (3) if both new and old are commit-ish, and new is a
271 * descendant of old, it is OK.
272 *
273 * (4) regardless of all of the above, removing :B is
274 * always allowed.
275 */
276 if (!force_update &&
278 !delete_ref &&
279 !is_null_sha1(ref->old_sha1) &&
280 !ref->force) {
281 if (!has_sha1_file(ref->old_sha1) ||
282 !ref_newer(ref->peer_ref->new_sha1,
283 ref->old_sha1)) {
284 /* We do not have the remote ref, or
285 * we know that the remote ref is not
286 * an ancestor of what we are trying to
287 * push. Either way this can be losing
288 * commits at the remote end and likely
289 * we were not up to date to begin with.
290 */
291 error("remote '%s' is not a strict "
292 "subset of local ref '%s'. "
293 "maybe you are not up-to-date and "
294 "need to pull first?",
295 ref->name,
296 ref->peer_ref->name);
297 ret = -2;
298 continue;
299 }
300 }
301 hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
302 if (!delete_ref)
303 new_refs++;
304 strcpy(old_hex, sha1_to_hex(ref->old_sha1));
305 new_hex = sha1_to_hex(ref->new_sha1);
306 if (ask_for_status_report) {
308 packet_write(out, "%s %s %s%c%s",
309 old_hex, new_hex, ref->name, 0,
310 "report-status");
311 ask_for_status_report = 0;
312 expect_status_report = 1;
313 }
314 else
315 packet_write(out, "%s %s %s",
316 old_hex, new_hex, ref->name);
317 if (delete_ref)
318 fprintf(stderr, "deleting '%s'\n", ref->name);
319 else {
320 fprintf(stderr, "updating '%s'", ref->name);
321 if (strcmp(ref->name, ref->peer_ref->name))
322 fprintf(stderr, " using '%s'",
323 ref->peer_ref->name);
324 fprintf(stderr, "\n from %s\n to %s\n",
325 old_hex, new_hex);
326 }
327 }
328 packet_flush(out);
330 if (new_refs)
331 ret = pack_objects(out, remote_refs);
332 close(out);
333 if (expect_status_report) {
335 if (receive_status(in))
336 ret = -4;
337 }
338 if (!new_refs && ret == 0)
340 fprintf(stderr, "Everything up-to-date\n");
341 return ret;
342}
343static void verify_remote_names(int nr_heads, char **heads)
345{
346 int i;
347 for (i = 0; i < nr_heads; i++) {
349 const char *remote = strchr(heads[i], ':');
350 remote = remote ? (remote + 1) : heads[i];
352 switch (check_ref_format(remote)) {
353 case 0: /* ok */
354 case -2: /* ok but a single level -- that is fine for
355 * a match pattern.
356 */
357 continue;
358 }
359 die("remote part of refspec is not a valid name in %s",
360 heads[i]);
361 }
362}
363int main(int argc, char **argv)
365{
366 int i, nr_heads = 0;
367 char *dest = NULL;
368 char **heads = NULL;
369 int fd[2], ret;
370 pid_t pid;
371 setup_git_directory();
373 git_config(git_default_config);
374 argv++;
376 for (i = 1; i < argc; i++, argv++) {
377 char *arg = *argv;
378 if (*arg == '-') {
380 if (!strncmp(arg, "--exec=", 7)) {
381 exec = arg + 7;
382 continue;
383 }
384 if (!strcmp(arg, "--all")) {
385 send_all = 1;
386 continue;
387 }
388 if (!strcmp(arg, "--force")) {
389 force_update = 1;
390 continue;
391 }
392 if (!strcmp(arg, "--verbose")) {
393 verbose = 1;
394 continue;
395 }
396 if (!strcmp(arg, "--thin")) {
397 use_thin_pack = 1;
398 continue;
399 }
400 usage(send_pack_usage);
401 }
402 if (!dest) {
403 dest = arg;
404 continue;
405 }
406 heads = argv;
407 nr_heads = argc - i;
408 break;
409 }
410 if (!dest)
411 usage(send_pack_usage);
412 if (heads && send_all)
413 usage(send_pack_usage);
414 verify_remote_names(nr_heads, heads);
415 pid = git_connect(fd, dest, exec);
417 if (pid < 0)
418 return 1;
419 ret = send_pack(fd[0], fd[1], nr_heads, heads);
420 close(fd[0]);
421 close(fd[1]);
422 ret |= finish_connect(pid);
423 return !!ret;
424}