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
)
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
;
38 if (args
.use_thin_pack
)
40 memset(&po
, 0, sizeof(po
));
45 if (start_command(&po
))
46 die("git-pack-objects failed (%s)", strerror(errno
));
49 * We feed the pack-objects we just spawned with revision
50 * parameters by writing to the pipe.
55 if (!is_null_sha1(refs
->old_sha1
) &&
56 has_sha1_file(refs
->old_sha1
)) {
57 memcpy(buf
+ 1, sha1_to_hex(refs
->old_sha1
), 40);
60 if (!write_or_whine(po
.in
, buf
, 42,
61 "send-pack: send refs"))
64 if (!is_null_sha1(refs
->new_sha1
)) {
65 memcpy(buf
, sha1_to_hex(refs
->new_sha1
), 40);
67 if (!write_or_whine(po
.in
, buf
, 41,
68 "send-pack: send refs"))
74 if (finish_command(&po
))
75 return error("pack-objects died with strange error");
79 static void unmark_and_free(struct commit_list
*list
, unsigned int mark
)
82 struct commit_list
*temp
= list
;
83 temp
->item
->object
.flags
&= ~mark
;
89 static int ref_newer(const unsigned char *new_sha1
,
90 const unsigned char *old_sha1
)
93 struct commit
*old
, *new;
94 struct commit_list
*list
, *used
;
97 /* Both new and old must be commit-ish and new is descendant of
98 * old. Otherwise we require --force.
100 o
= deref_tag(parse_object(old_sha1
), NULL
, 0);
101 if (!o
|| o
->type
!= OBJ_COMMIT
)
103 old
= (struct commit
*) o
;
105 o
= deref_tag(parse_object(new_sha1
), NULL
, 0);
106 if (!o
|| o
->type
!= OBJ_COMMIT
)
108 new = (struct commit
*) o
;
110 if (parse_commit(new) < 0)
114 commit_list_insert(new, &list
);
116 new = pop_most_recent_commit(&list
, 1);
117 commit_list_insert(new, &used
);
123 unmark_and_free(list
, 1);
124 unmark_and_free(used
, 1);
128 static struct ref
*local_refs
, **local_tail
;
129 static struct ref
*remote_refs
, **remote_tail
;
131 static int one_local_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
134 int len
= strlen(refname
) + 1;
135 ref
= xcalloc(1, sizeof(*ref
) + len
);
136 hashcpy(ref
->new_sha1
, sha1
);
137 memcpy(ref
->name
, refname
, len
);
139 local_tail
= &ref
->next
;
143 static void get_local_heads(void)
145 local_tail
= &local_refs
;
146 for_each_ref(one_local_ref
, NULL
);
149 static int receive_status(int in
)
153 int len
= packet_read_line(in
, line
, sizeof(line
));
154 if (len
< 10 || memcmp(line
, "unpack ", 7)) {
155 fprintf(stderr
, "did not receive status back\n");
158 if (memcmp(line
, "unpack ok\n", 10)) {
163 len
= packet_read_line(in
, line
, sizeof(line
));
167 (memcmp(line
, "ok", 2) && memcmp(line
, "ng", 2))) {
168 fprintf(stderr
, "protocol error: %s\n", line
);
172 if (!memcmp(line
, "ok", 2))
180 static void update_tracking_ref(struct remote
*remote
, struct ref
*ref
)
191 will_delete_ref
= is_null_sha1(ref
->peer_ref
->new_sha1
);
193 if (!will_delete_ref
&&
194 !hashcmp(ref
->old_sha1
, ref
->peer_ref
->new_sha1
))
197 if (!remote_find_tracking(remote
, &rs
)) {
199 fprintf(stderr
, "updating local tracking ref '%s'\n", rs
.dst
);
200 if (is_null_sha1(ref
->peer_ref
->new_sha1
)) {
201 if (delete_ref(rs
.dst
, NULL
))
202 error("Failed to delete");
204 update_ref("update by push", rs
.dst
,
205 ref
->new_sha1
, NULL
, 0, 0);
210 static const char *prettify_ref(const char *name
)
213 !prefixcmp(name
, "refs/heads/") ? 11 :
214 !prefixcmp(name
, "refs/tags/") ? 10 :
215 !prefixcmp(name
, "refs/remotes/") ? 13 :
219 #define SUMMARY_WIDTH (2 * DEFAULT_ABBREV + 3)
221 static int do_send_pack(int in
, int out
, struct remote
*remote
, const char *dest
, int nr_refspec
, const char **refspec
)
226 int ask_for_status_report
= 0;
227 int allow_deleting_refs
= 0;
228 int expect_status_report
= 0;
230 int flags
= MATCH_REFS_NONE
;
233 flags
|= MATCH_REFS_ALL
;
234 if (args
.send_mirror
)
235 flags
|= MATCH_REFS_MIRROR
;
237 /* No funny business with the matcher */
238 remote_tail
= get_remote_heads(in
, &remote_refs
, 0, NULL
, REF_NORMAL
);
241 /* Does the other end support the reporting? */
242 if (server_supports("report-status"))
243 ask_for_status_report
= 1;
244 if (server_supports("delete-refs"))
245 allow_deleting_refs
= 1;
249 remote_tail
= &remote_refs
;
250 if (match_refs(local_refs
, remote_refs
, &remote_tail
,
251 nr_refspec
, refspec
, flags
))
255 fprintf(stderr
, "No refs in common and none specified; doing nothing.\n"
256 "Perhaps you should specify a branch such as 'master'.\n");
261 * Finally, tell the other end!
264 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
265 char old_hex
[60], *new_hex
;
267 const char *pretty_ref
;
268 const char *pretty_peer
= NULL
; /* only used when not deleting */
269 const unsigned char *new_sha1
;
271 if (!ref
->peer_ref
) {
272 if (!args
.send_mirror
)
274 new_sha1
= null_sha1
;
277 new_sha1
= ref
->peer_ref
->new_sha1
;
280 fprintf(stderr
, "To %s\n", dest
);
284 will_delete_ref
= is_null_sha1(new_sha1
);
286 pretty_ref
= prettify_ref(ref
->name
);
287 if (!will_delete_ref
)
288 pretty_peer
= prettify_ref(ref
->peer_ref
->name
);
290 if (will_delete_ref
&& !allow_deleting_refs
) {
291 fprintf(stderr
, " ! %-*s %s (remote does not support deleting refs)\n",
292 SUMMARY_WIDTH
, "[rejected]", pretty_ref
);
296 if (!will_delete_ref
&&
297 !hashcmp(ref
->old_sha1
, new_sha1
)) {
299 fprintf(stderr
, " = %-*s %s -> %s\n",
300 SUMMARY_WIDTH
, "[up to date]",
301 pretty_peer
, pretty_ref
);
305 /* This part determines what can overwrite what.
308 * (0) you can always use --force or +A:B notation to
309 * selectively force individual ref pairs.
311 * (1) if the old thing does not exist, it is OK.
313 * (2) if you do not have the old thing, you are not allowed
314 * to overwrite it; you would not know what you are losing
317 * (3) if both new and old are commit-ish, and new is a
318 * descendant of old, it is OK.
320 * (4) regardless of all of the above, removing :B is
324 if (!args
.force_update
&&
326 !is_null_sha1(ref
->old_sha1
) &&
328 if (!has_sha1_file(ref
->old_sha1
) ||
329 !ref_newer(new_sha1
, ref
->old_sha1
)) {
330 /* We do not have the remote ref, or
331 * we know that the remote ref is not
332 * an ancestor of what we are trying to
333 * push. Either way this can be losing
334 * commits at the remote end and likely
335 * we were not up to date to begin with.
337 fprintf(stderr
, " ! %-*s %s -> %s (non-fast forward)\n",
338 SUMMARY_WIDTH
, "[rejected]",
339 pretty_peer
, pretty_ref
);
344 hashcpy(ref
->new_sha1
, new_sha1
);
345 if (!will_delete_ref
)
347 strcpy(old_hex
, sha1_to_hex(ref
->old_sha1
));
348 new_hex
= sha1_to_hex(ref
->new_sha1
);
351 if (ask_for_status_report
) {
352 packet_write(out
, "%s %s %s%c%s",
353 old_hex
, new_hex
, ref
->name
, 0,
355 ask_for_status_report
= 0;
356 expect_status_report
= 1;
359 packet_write(out
, "%s %s %s",
360 old_hex
, new_hex
, ref
->name
);
363 fprintf(stderr
, " - %-*s %s\n",
364 SUMMARY_WIDTH
, "[deleting]",
366 else if (is_null_sha1(ref
->old_sha1
)) {
369 if (!prefixcmp(ref
->name
, "refs/tags/"))
372 msg
= "[new branch]";
373 fprintf(stderr
, " * %-*s %s -> %s\n",
375 pretty_peer
, pretty_ref
);
380 const char *msg
= "";
382 old_abb
= find_unique_abbrev(ref
->old_sha1
, DEFAULT_ABBREV
);
383 strcpy(quickref
, old_abb
? old_abb
: old_hex
);
384 if (ref_newer(ref
->peer_ref
->new_sha1
, ref
->old_sha1
))
385 strcat(quickref
, "..");
387 strcat(quickref
, "...");
389 msg
= " (forced update)";
391 strcat(quickref
, find_unique_abbrev(ref
->new_sha1
, DEFAULT_ABBREV
));
393 fprintf(stderr
, " %c %-*s %s -> %s%s\n",
395 SUMMARY_WIDTH
, quickref
,
396 pretty_peer
, pretty_ref
,
402 if (new_refs
&& !args
.dry_run
)
403 ret
= pack_objects(out
, remote_refs
);
406 if (expect_status_report
) {
407 if (receive_status(in
))
411 if (!args
.dry_run
&& remote
&& ret
== 0) {
412 for (ref
= remote_refs
; ref
; ref
= ref
->next
)
413 if (!is_null_sha1(ref
->new_sha1
))
414 update_tracking_ref(remote
, ref
);
417 if (!new_refs
&& ret
== 0)
418 fprintf(stderr
, "Everything up-to-date\n");
422 static void verify_remote_names(int nr_heads
, const char **heads
)
426 for (i
= 0; i
< nr_heads
; i
++) {
427 const char *remote
= strchr(heads
[i
], ':');
429 remote
= remote
? (remote
+ 1) : heads
[i
];
430 switch (check_ref_format(remote
)) {
432 case -2: /* ok but a single level -- that is fine for
435 case -3: /* ok but ends with a pattern-match character */
438 die("remote part of refspec is not a valid name in %s",
443 int cmd_send_pack(int argc
, const char **argv
, const char *prefix
)
446 const char **heads
= NULL
;
447 const char *remote_name
= NULL
;
448 struct remote
*remote
= NULL
;
449 const char *dest
= NULL
;
452 for (i
= 1; i
< argc
; i
++, argv
++) {
453 const char *arg
= *argv
;
456 if (!prefixcmp(arg
, "--receive-pack=")) {
457 args
.receivepack
= arg
+ 15;
460 if (!prefixcmp(arg
, "--exec=")) {
461 args
.receivepack
= arg
+ 7;
464 if (!prefixcmp(arg
, "--remote=")) {
465 remote_name
= arg
+ 9;
468 if (!strcmp(arg
, "--all")) {
472 if (!strcmp(arg
, "--dry-run")) {
476 if (!strcmp(arg
, "--mirror")) {
477 args
.send_mirror
= 1;
480 if (!strcmp(arg
, "--force")) {
481 args
.force_update
= 1;
484 if (!strcmp(arg
, "--verbose")) {
488 if (!strcmp(arg
, "--thin")) {
489 args
.use_thin_pack
= 1;
492 usage(send_pack_usage
);
498 heads
= (const char **) argv
;
503 usage(send_pack_usage
);
505 * --all and --mirror are incompatible; neither makes sense
508 if ((heads
&& (args
.send_all
|| args
.send_mirror
)) ||
509 (args
.send_all
&& args
.send_mirror
))
510 usage(send_pack_usage
);
513 remote
= remote_get(remote_name
);
514 if (!remote_has_url(remote
, dest
)) {
515 die("Destination %s is not a uri for %s",
520 return send_pack(&args
, dest
, remote
, nr_heads
, heads
);
523 int send_pack(struct send_pack_args
*my_args
,
524 const char *dest
, struct remote
*remote
,
525 int nr_heads
, const char **heads
)
528 struct child_process
*conn
;
530 memcpy(&args
, my_args
, sizeof(args
));
532 verify_remote_names(nr_heads
, heads
);
534 conn
= git_connect(fd
, dest
, args
.receivepack
, args
.verbose
? CONNECT_VERBOSE
: 0);
535 ret
= do_send_pack(fd
[0], fd
[1], remote
, dest
, nr_heads
, heads
);
538 ret
|= finish_connect(conn
);