6 #include "run-command.h"
10 static const char send_pack_usage
[] =
11 "git send-pack [--all | --mirror] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]\n"
12 " --all and explicit <ref> specification are mutually exclusive.";
14 static struct send_pack_args args
= {
15 /* .receivepack = */ "git-receive-pack",
19 * Make a pack stream and spit it out into file descriptor fd
21 static int pack_objects(int fd
, struct ref
*refs
, struct extra_have_objects
*extra
)
24 * The child becomes pack-objects --revs; we feed
25 * the revision parameters to it via its stdin and
26 * let its stdout go back to the other end.
28 const char *argv
[] = {
36 struct child_process po
;
40 if (args
.use_thin_pack
)
42 memset(&po
, 0, sizeof(po
));
47 if (start_command(&po
))
48 die("git pack-objects failed (%s)", strerror(errno
));
51 * We feed the pack-objects we just spawned with revision
52 * parameters by writing to the pipe.
54 for (i
= 0; i
< extra
->nr
; i
++) {
55 memcpy(buf
+ 1, sha1_to_hex(&extra
->array
[i
][0]), 40);
58 if (!write_or_whine(po
.in
, buf
, 42, "send-pack: send refs"))
63 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);
68 if (!write_or_whine(po
.in
, buf
, 42,
69 "send-pack: send refs"))
72 if (!is_null_sha1(refs
->new_sha1
)) {
73 memcpy(buf
, sha1_to_hex(refs
->new_sha1
), 40);
75 if (!write_or_whine(po
.in
, buf
, 41,
76 "send-pack: send refs"))
83 if (finish_command(&po
))
84 return error("pack-objects died with strange error");
88 static void unmark_and_free(struct commit_list
*list
, unsigned int mark
)
91 struct commit_list
*temp
= list
;
92 temp
->item
->object
.flags
&= ~mark
;
98 static int ref_newer(const unsigned char *new_sha1
,
99 const unsigned char *old_sha1
)
102 struct commit
*old
, *new;
103 struct commit_list
*list
, *used
;
106 /* Both new and old must be commit-ish and new is descendant of
107 * old. Otherwise we require --force.
109 o
= deref_tag(parse_object(old_sha1
), NULL
, 0);
110 if (!o
|| o
->type
!= OBJ_COMMIT
)
112 old
= (struct commit
*) o
;
114 o
= deref_tag(parse_object(new_sha1
), NULL
, 0);
115 if (!o
|| o
->type
!= OBJ_COMMIT
)
117 new = (struct commit
*) o
;
119 if (parse_commit(new) < 0)
123 commit_list_insert(new, &list
);
125 new = pop_most_recent_commit(&list
, 1);
126 commit_list_insert(new, &used
);
132 unmark_and_free(list
, 1);
133 unmark_and_free(used
, 1);
137 static struct ref
*local_refs
, **local_tail
;
138 static struct ref
*remote_refs
, **remote_tail
;
140 static int one_local_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
143 int len
= strlen(refname
) + 1;
144 ref
= xcalloc(1, sizeof(*ref
) + len
);
145 hashcpy(ref
->new_sha1
, sha1
);
146 memcpy(ref
->name
, refname
, len
);
148 local_tail
= &ref
->next
;
152 static void get_local_heads(void)
154 local_tail
= &local_refs
;
155 for_each_ref(one_local_ref
, NULL
);
158 static int receive_status(int in
, struct ref
*refs
)
163 int len
= packet_read_line(in
, line
, sizeof(line
));
164 if (len
< 10 || memcmp(line
, "unpack ", 7))
165 return error("did not receive remote status");
166 if (memcmp(line
, "unpack ok\n", 10)) {
167 char *p
= line
+ strlen(line
) - 1;
170 error("unpack failed: %s", line
+ 7);
177 len
= packet_read_line(in
, line
, sizeof(line
));
181 (memcmp(line
, "ok ", 3) && memcmp(line
, "ng ", 3))) {
182 fprintf(stderr
, "protocol error: %s\n", line
);
187 line
[strlen(line
)-1] = '\0';
189 msg
= strchr(refname
, ' ');
193 /* first try searching at our hint, falling back to all refs */
195 hint
= find_ref_by_name(hint
, refname
);
197 hint
= find_ref_by_name(refs
, refname
);
199 warning("remote reported status on unknown ref: %s",
203 if (hint
->status
!= REF_STATUS_EXPECTING_REPORT
) {
204 warning("remote reported status on unexpected ref: %s",
209 if (line
[0] == 'o' && line
[1] == 'k')
210 hint
->status
= REF_STATUS_OK
;
212 hint
->status
= REF_STATUS_REMOTE_REJECT
;
216 hint
->remote_status
= xstrdup(msg
);
217 /* start our next search from the next ref */
223 static void update_tracking_ref(struct remote
*remote
, struct ref
*ref
)
227 if (ref
->status
!= REF_STATUS_OK
)
233 if (!remote_find_tracking(remote
, &rs
)) {
235 fprintf(stderr
, "updating local tracking ref '%s'\n", rs
.dst
);
237 delete_ref(rs
.dst
, NULL
);
239 update_ref("update by push", rs
.dst
,
240 ref
->new_sha1
, NULL
, 0, 0);
245 static const char *prettify_ref(const struct ref
*ref
)
247 const char *name
= ref
->name
;
249 !prefixcmp(name
, "refs/heads/") ? 11 :
250 !prefixcmp(name
, "refs/tags/") ? 10 :
251 !prefixcmp(name
, "refs/remotes/") ? 13 :
255 #define SUMMARY_WIDTH (2 * DEFAULT_ABBREV + 3)
257 static void print_ref_status(char flag
, const char *summary
, struct ref
*to
, struct ref
*from
, const char *msg
)
259 fprintf(stderr
, " %c %-*s ", flag
, SUMMARY_WIDTH
, summary
);
261 fprintf(stderr
, "%s -> %s", prettify_ref(from
), prettify_ref(to
));
263 fputs(prettify_ref(to
), stderr
);
272 static const char *status_abbrev(unsigned char sha1
[20])
274 return find_unique_abbrev(sha1
, DEFAULT_ABBREV
);
277 static void print_ok_ref_status(struct ref
*ref
)
280 print_ref_status('-', "[deleted]", ref
, NULL
, NULL
);
281 else if (is_null_sha1(ref
->old_sha1
))
282 print_ref_status('*',
283 (!prefixcmp(ref
->name
, "refs/tags/") ? "[new tag]" :
285 ref
, ref
->peer_ref
, NULL
);
291 strcpy(quickref
, status_abbrev(ref
->old_sha1
));
292 if (ref
->nonfastforward
) {
293 strcat(quickref
, "...");
295 msg
= "forced update";
297 strcat(quickref
, "..");
301 strcat(quickref
, status_abbrev(ref
->new_sha1
));
303 print_ref_status(type
, quickref
, ref
, ref
->peer_ref
, msg
);
307 static int print_one_push_status(struct ref
*ref
, const char *dest
, int count
)
310 fprintf(stderr
, "To %s\n", dest
);
312 switch(ref
->status
) {
313 case REF_STATUS_NONE
:
314 print_ref_status('X', "[no match]", ref
, NULL
, NULL
);
316 case REF_STATUS_REJECT_NODELETE
:
317 print_ref_status('!', "[rejected]", ref
, NULL
,
318 "remote does not support deleting refs");
320 case REF_STATUS_UPTODATE
:
321 print_ref_status('=', "[up to date]", ref
,
322 ref
->peer_ref
, NULL
);
324 case REF_STATUS_REJECT_NONFASTFORWARD
:
325 print_ref_status('!', "[rejected]", ref
, ref
->peer_ref
,
328 case REF_STATUS_REMOTE_REJECT
:
329 print_ref_status('!', "[remote rejected]", ref
,
330 ref
->deletion
? NULL
: ref
->peer_ref
,
333 case REF_STATUS_EXPECTING_REPORT
:
334 print_ref_status('!', "[remote failure]", ref
,
335 ref
->deletion
? NULL
: ref
->peer_ref
,
336 "remote failed to report status");
339 print_ok_ref_status(ref
);
346 static void print_push_status(const char *dest
, struct ref
*refs
)
352 for (ref
= refs
; ref
; ref
= ref
->next
)
353 if (ref
->status
== REF_STATUS_UPTODATE
)
354 n
+= print_one_push_status(ref
, dest
, n
);
357 for (ref
= refs
; ref
; ref
= ref
->next
)
358 if (ref
->status
== REF_STATUS_OK
)
359 n
+= print_one_push_status(ref
, dest
, n
);
361 for (ref
= refs
; ref
; ref
= ref
->next
) {
362 if (ref
->status
!= REF_STATUS_NONE
&&
363 ref
->status
!= REF_STATUS_UPTODATE
&&
364 ref
->status
!= REF_STATUS_OK
)
365 n
+= print_one_push_status(ref
, dest
, n
);
369 static int refs_pushed(struct ref
*ref
)
371 for (; ref
; ref
= ref
->next
) {
372 switch(ref
->status
) {
373 case REF_STATUS_NONE
:
374 case REF_STATUS_UPTODATE
:
383 static int do_send_pack(int in
, int out
, struct remote
*remote
, const char *dest
, int nr_refspec
, const char **refspec
)
387 int ask_for_status_report
= 0;
388 int allow_deleting_refs
= 0;
389 int expect_status_report
= 0;
390 int flags
= MATCH_REFS_NONE
;
392 struct extra_have_objects extra_have
;
394 memset(&extra_have
, 0, sizeof(extra_have
));
396 flags
|= MATCH_REFS_ALL
;
397 if (args
.send_mirror
)
398 flags
|= MATCH_REFS_MIRROR
;
400 /* No funny business with the matcher */
401 remote_tail
= get_remote_heads(in
, &remote_refs
, 0, NULL
, REF_NORMAL
,
405 /* Does the other end support the reporting? */
406 if (server_supports("report-status"))
407 ask_for_status_report
= 1;
408 if (server_supports("delete-refs"))
409 allow_deleting_refs
= 1;
413 remote_tail
= &remote_refs
;
414 if (match_refs(local_refs
, remote_refs
, &remote_tail
,
415 nr_refspec
, refspec
, flags
)) {
421 fprintf(stderr
, "No refs in common and none specified; doing nothing.\n"
422 "Perhaps you should specify a branch such as 'master'.\n");
428 * Finally, tell the other end!
431 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
432 const unsigned char *new_sha1
;
434 if (!ref
->peer_ref
) {
435 if (!args
.send_mirror
)
437 new_sha1
= null_sha1
;
440 new_sha1
= ref
->peer_ref
->new_sha1
;
443 ref
->deletion
= is_null_sha1(new_sha1
);
444 if (ref
->deletion
&& !allow_deleting_refs
) {
445 ref
->status
= REF_STATUS_REJECT_NODELETE
;
448 if (!ref
->deletion
&&
449 !hashcmp(ref
->old_sha1
, new_sha1
)) {
450 ref
->status
= REF_STATUS_UPTODATE
;
454 /* This part determines what can overwrite what.
457 * (0) you can always use --force or +A:B notation to
458 * selectively force individual ref pairs.
460 * (1) if the old thing does not exist, it is OK.
462 * (2) if you do not have the old thing, you are not allowed
463 * to overwrite it; you would not know what you are losing
466 * (3) if both new and old are commit-ish, and new is a
467 * descendant of old, it is OK.
469 * (4) regardless of all of the above, removing :B is
473 ref
->nonfastforward
=
475 !is_null_sha1(ref
->old_sha1
) &&
476 (!has_sha1_file(ref
->old_sha1
)
477 || !ref_newer(new_sha1
, ref
->old_sha1
));
479 if (ref
->nonfastforward
&& !ref
->force
&& !args
.force_update
) {
480 ref
->status
= REF_STATUS_REJECT_NONFASTFORWARD
;
484 hashcpy(ref
->new_sha1
, new_sha1
);
489 char *old_hex
= sha1_to_hex(ref
->old_sha1
);
490 char *new_hex
= sha1_to_hex(ref
->new_sha1
);
492 if (ask_for_status_report
) {
493 packet_write(out
, "%s %s %s%c%s",
494 old_hex
, new_hex
, ref
->name
, 0,
496 ask_for_status_report
= 0;
497 expect_status_report
= 1;
500 packet_write(out
, "%s %s %s",
501 old_hex
, new_hex
, ref
->name
);
503 ref
->status
= expect_status_report
?
504 REF_STATUS_EXPECTING_REPORT
:
509 if (new_refs
&& !args
.dry_run
) {
510 if (pack_objects(out
, remote_refs
, &extra_have
) < 0)
516 if (expect_status_report
)
517 ret
= receive_status(in
, remote_refs
);
521 print_push_status(dest
, remote_refs
);
523 if (!args
.dry_run
&& remote
) {
524 for (ref
= remote_refs
; ref
; ref
= ref
->next
)
525 update_tracking_ref(remote
, ref
);
528 if (!refs_pushed(remote_refs
))
529 fprintf(stderr
, "Everything up-to-date\n");
532 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
533 switch (ref
->status
) {
534 case REF_STATUS_NONE
:
535 case REF_STATUS_UPTODATE
:
545 static void verify_remote_names(int nr_heads
, const char **heads
)
549 for (i
= 0; i
< nr_heads
; i
++) {
550 const char *local
= heads
[i
];
551 const char *remote
= strrchr(heads
[i
], ':');
556 /* A matching refspec is okay. */
557 if (remote
== local
&& remote
[1] == '\0')
560 remote
= remote
? (remote
+ 1) : local
;
561 switch (check_ref_format(remote
)) {
563 case CHECK_REF_FORMAT_ONELEVEL
:
564 /* ok but a single level -- that is fine for
567 case CHECK_REF_FORMAT_WILDCARD
:
568 /* ok but ends with a pattern-match character */
571 die("remote part of refspec is not a valid name in %s",
576 int cmd_send_pack(int argc
, const char **argv
, const char *prefix
)
579 const char **heads
= NULL
;
580 const char *remote_name
= NULL
;
581 struct remote
*remote
= NULL
;
582 const char *dest
= NULL
;
585 for (i
= 1; i
< argc
; i
++, argv
++) {
586 const char *arg
= *argv
;
589 if (!prefixcmp(arg
, "--receive-pack=")) {
590 args
.receivepack
= arg
+ 15;
593 if (!prefixcmp(arg
, "--exec=")) {
594 args
.receivepack
= arg
+ 7;
597 if (!prefixcmp(arg
, "--remote=")) {
598 remote_name
= arg
+ 9;
601 if (!strcmp(arg
, "--all")) {
605 if (!strcmp(arg
, "--dry-run")) {
609 if (!strcmp(arg
, "--mirror")) {
610 args
.send_mirror
= 1;
613 if (!strcmp(arg
, "--force")) {
614 args
.force_update
= 1;
617 if (!strcmp(arg
, "--verbose")) {
621 if (!strcmp(arg
, "--thin")) {
622 args
.use_thin_pack
= 1;
625 usage(send_pack_usage
);
631 heads
= (const char **) argv
;
636 usage(send_pack_usage
);
638 * --all and --mirror are incompatible; neither makes sense
641 if ((heads
&& (args
.send_all
|| args
.send_mirror
)) ||
642 (args
.send_all
&& args
.send_mirror
))
643 usage(send_pack_usage
);
646 remote
= remote_get(remote_name
);
647 if (!remote_has_url(remote
, dest
)) {
648 die("Destination %s is not a uri for %s",
653 return send_pack(&args
, dest
, remote
, nr_heads
, heads
);
656 int send_pack(struct send_pack_args
*my_args
,
657 const char *dest
, struct remote
*remote
,
658 int nr_heads
, const char **heads
)
661 struct child_process
*conn
;
663 memcpy(&args
, my_args
, sizeof(args
));
665 verify_remote_names(nr_heads
, heads
);
667 conn
= git_connect(fd
, dest
, args
.receivepack
, args
.verbose
? CONNECT_VERBOSE
: 0);
668 ret
= do_send_pack(fd
[0], fd
[1], remote
, dest
, nr_heads
, heads
);
670 /* do_send_pack always closes fd[1] */
671 ret
|= finish_connect(conn
);