5 #include "object-store.h"
8 #include "run-command.h"
11 #include "send-pack.h"
13 #include "transport.h"
15 #include "oid-array.h"
16 #include "gpg-interface.h"
20 int option_parse_push_signed(const struct option
*opt
,
21 const char *arg
, int unset
)
24 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_NEVER
;
27 switch (git_parse_maybe_bool(arg
)) {
29 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_ALWAYS
;
32 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_NEVER
;
35 if (!strcasecmp("if-asked", arg
)) {
36 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_IF_ASKED
;
39 die("bad %s argument: %s", opt
->long_name
, arg
);
42 static void feed_object(const struct object_id
*oid
, FILE *fh
, int negative
)
45 !has_object_file_with_flags(oid
,
46 OBJECT_INFO_SKIP_FETCH_OBJECT
|
52 fputs(oid_to_hex(oid
), fh
);
57 * Make a pack stream and spit it out into file descriptor fd
59 static int pack_objects(int fd
, struct ref
*refs
, struct oid_array
*extra
, struct send_pack_args
*args
)
62 * The child becomes pack-objects --revs; we feed
63 * the revision parameters to it via its stdin and
64 * let its stdout go back to the other end.
66 struct child_process po
= CHILD_PROCESS_INIT
;
71 strvec_push(&po
.args
, "pack-objects");
72 strvec_push(&po
.args
, "--all-progress-implied");
73 strvec_push(&po
.args
, "--revs");
74 strvec_push(&po
.args
, "--stdout");
75 if (args
->use_thin_pack
)
76 strvec_push(&po
.args
, "--thin");
77 if (args
->use_ofs_delta
)
78 strvec_push(&po
.args
, "--delta-base-offset");
79 if (args
->quiet
|| !args
->progress
)
80 strvec_push(&po
.args
, "-q");
82 strvec_push(&po
.args
, "--progress");
83 if (is_repository_shallow(the_repository
))
84 strvec_push(&po
.args
, "--shallow");
86 po
.out
= args
->stateless_rpc
? -1 : fd
;
88 if (start_command(&po
))
89 die_errno("git pack-objects failed");
92 * We feed the pack-objects we just spawned with revision
93 * parameters by writing to the pipe.
95 po_in
= xfdopen(po
.in
, "w");
96 for (i
= 0; i
< extra
->nr
; i
++)
97 feed_object(&extra
->oid
[i
], po_in
, 1);
100 if (!is_null_oid(&refs
->old_oid
))
101 feed_object(&refs
->old_oid
, po_in
, 1);
102 if (!is_null_oid(&refs
->new_oid
))
103 feed_object(&refs
->new_oid
, po_in
, 0);
109 die_errno("error writing to pack-objects");
112 if (args
->stateless_rpc
) {
113 char *buf
= xmalloc(LARGE_PACKET_MAX
);
115 ssize_t n
= xread(po
.out
, buf
, LARGE_PACKET_MAX
);
118 send_sideband(fd
, -1, buf
, n
, LARGE_PACKET_MAX
);
125 rc
= finish_command(&po
);
128 * For a normal non-zero exit, we assume pack-objects wrote
129 * something useful to stderr. For death by signal, though,
130 * we should mention it to the user. The exception is SIGPIPE
131 * (141), because that's a normal occurrence if the remote end
132 * hangs up (and we'll report that by trying to read the unpack
135 if (rc
> 128 && rc
!= 141)
136 error("pack-objects died of signal %d", rc
- 128);
142 static int receive_unpack_status(struct packet_reader
*reader
)
144 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
145 return error(_("unexpected flush packet while reading remote unpack status"));
146 if (!skip_prefix(reader
->line
, "unpack ", &reader
->line
))
147 return error(_("unable to parse remote unpack status: %s"), reader
->line
);
148 if (strcmp(reader
->line
, "ok"))
149 return error(_("remote unpack failed: %s"), reader
->line
);
153 static int receive_status(struct packet_reader
*reader
, struct ref
*refs
)
159 ret
= receive_unpack_status(reader
);
163 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
165 if (!starts_with(reader
->line
, "ok ") && !starts_with(reader
->line
, "ng ")) {
166 error("invalid ref status from remote: %s", reader
->line
);
171 refname
= reader
->line
+ 3;
172 msg
= strchr(refname
, ' ');
176 /* first try searching at our hint, falling back to all refs */
178 hint
= find_ref_by_name(hint
, refname
);
180 hint
= find_ref_by_name(refs
, refname
);
182 warning("remote reported status on unknown ref: %s",
186 if (hint
->status
!= REF_STATUS_EXPECTING_REPORT
) {
187 warning("remote reported status on unexpected ref: %s",
192 if (reader
->line
[0] == 'o' && reader
->line
[1] == 'k')
193 hint
->status
= REF_STATUS_OK
;
195 hint
->status
= REF_STATUS_REMOTE_REJECT
;
196 hint
->remote_status
= xstrdup_or_null(msg
);
197 /* start our next search from the next ref */
203 static int sideband_demux(int in
, int out
, void *data
)
206 if (async_with_fork())
208 ret
= recv_sideband("send-pack", fd
[0], out
);
213 static int advertise_shallow_grafts_cb(const struct commit_graft
*graft
, void *cb
)
215 struct strbuf
*sb
= cb
;
216 if (graft
->nr_parent
== -1)
217 packet_buf_write(sb
, "shallow %s\n", oid_to_hex(&graft
->oid
));
221 static void advertise_shallow_grafts_buf(struct strbuf
*sb
)
223 if (!is_repository_shallow(the_repository
))
225 for_each_commit_graft(advertise_shallow_grafts_cb
, sb
);
228 #define CHECK_REF_NO_PUSH -1
229 #define CHECK_REF_STATUS_REJECTED -2
230 #define CHECK_REF_UPTODATE -3
231 static int check_to_send_update(const struct ref
*ref
, const struct send_pack_args
*args
)
233 if (!ref
->peer_ref
&& !args
->send_mirror
)
234 return CHECK_REF_NO_PUSH
;
236 /* Check for statuses set by set_ref_status_for_push() */
237 switch (ref
->status
) {
238 case REF_STATUS_REJECT_NONFASTFORWARD
:
239 case REF_STATUS_REJECT_ALREADY_EXISTS
:
240 case REF_STATUS_REJECT_FETCH_FIRST
:
241 case REF_STATUS_REJECT_NEEDS_FORCE
:
242 case REF_STATUS_REJECT_STALE
:
243 case REF_STATUS_REJECT_NODELETE
:
244 return CHECK_REF_STATUS_REJECTED
;
245 case REF_STATUS_UPTODATE
:
246 return CHECK_REF_UPTODATE
;
249 case REF_STATUS_EXPECTING_REPORT
:
250 /* already passed checks on the local side */
252 /* of course this is OK */
258 * the beginning of the next line, or the end of buffer.
260 * NEEDSWORK: perhaps move this to git-compat-util.h or somewhere and
261 * convert many similar uses found by "git grep -A4 memchr".
263 static const char *next_line(const char *line
, size_t len
)
265 const char *nl
= memchr(line
, '\n', len
);
267 return line
+ len
; /* incomplete line */
271 static int generate_push_cert(struct strbuf
*req_buf
,
272 const struct ref
*remote_refs
,
273 struct send_pack_args
*args
,
274 const char *cap_string
,
275 const char *push_cert_nonce
)
277 const struct ref
*ref
;
278 struct string_list_item
*item
;
279 char *signing_key
= xstrdup(get_signing_key());
281 struct strbuf cert
= STRBUF_INIT
;
284 strbuf_addstr(&cert
, "certificate version 0.1\n");
285 strbuf_addf(&cert
, "pusher %s ", signing_key
);
287 strbuf_addch(&cert
, '\n');
288 if (args
->url
&& *args
->url
) {
289 char *anon_url
= transport_anonymize_url(args
->url
);
290 strbuf_addf(&cert
, "pushee %s\n", anon_url
);
293 if (push_cert_nonce
[0])
294 strbuf_addf(&cert
, "nonce %s\n", push_cert_nonce
);
295 if (args
->push_options
)
296 for_each_string_list_item(item
, args
->push_options
)
297 strbuf_addf(&cert
, "push-option %s\n", item
->string
);
298 strbuf_addstr(&cert
, "\n");
300 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
301 if (check_to_send_update(ref
, args
) < 0)
304 strbuf_addf(&cert
, "%s %s %s\n",
305 oid_to_hex(&ref
->old_oid
),
306 oid_to_hex(&ref
->new_oid
),
312 if (sign_buffer(&cert
, &cert
, signing_key
))
313 die(_("failed to sign the push certificate"));
315 packet_buf_write(req_buf
, "push-cert%c%s", 0, cap_string
);
316 for (cp
= cert
.buf
; cp
< cert
.buf
+ cert
.len
; cp
= np
) {
317 np
= next_line(cp
, cert
.buf
+ cert
.len
- cp
);
318 packet_buf_write(req_buf
,
319 "%.*s", (int)(np
- cp
), cp
);
321 packet_buf_write(req_buf
, "push-cert-end\n");
325 strbuf_release(&cert
);
329 #define NONCE_LEN_LIMIT 256
331 static void reject_invalid_nonce(const char *nonce
, int len
)
335 if (NONCE_LEN_LIMIT
<= len
)
336 die("the receiving end asked to sign an invalid nonce <%.*s>",
339 for (i
= 0; i
< len
; i
++) {
340 int ch
= nonce
[i
] & 0xFF;
342 ch
== '-' || ch
== '.' ||
343 ch
== '/' || ch
== '+' ||
344 ch
== '=' || ch
== '_')
346 die("the receiving end asked to sign an invalid nonce <%.*s>",
351 int send_pack(struct send_pack_args
*args
,
352 int fd
[], struct child_process
*conn
,
353 struct ref
*remote_refs
,
354 struct oid_array
*extra_have
)
358 struct strbuf req_buf
= STRBUF_INIT
;
359 struct strbuf cap_buf
= STRBUF_INIT
;
361 int need_pack_data
= 0;
362 int allow_deleting_refs
= 0;
363 int status_report
= 0;
364 int use_sideband
= 0;
365 int quiet_supported
= 0;
366 int agent_supported
= 0;
368 int atomic_supported
= 0;
369 int use_push_options
= 0;
370 int push_options_supported
= 0;
371 int object_format_supported
= 0;
372 unsigned cmds_sent
= 0;
375 const char *push_cert_nonce
= NULL
;
376 struct packet_reader reader
;
378 /* Does the other end support the reporting? */
379 if (server_supports("report-status"))
381 if (server_supports("delete-refs"))
382 allow_deleting_refs
= 1;
383 if (server_supports("ofs-delta"))
384 args
->use_ofs_delta
= 1;
385 if (server_supports("side-band-64k"))
387 if (server_supports("quiet"))
389 if (server_supports("agent"))
391 if (server_supports("no-thin"))
392 args
->use_thin_pack
= 0;
393 if (server_supports("atomic"))
394 atomic_supported
= 1;
395 if (server_supports("push-options"))
396 push_options_supported
= 1;
398 if (!server_supports_hash(the_hash_algo
->name
, &object_format_supported
))
399 die(_("the receiving end does not support this repository's hash algorithm"));
401 if (args
->push_cert
!= SEND_PACK_PUSH_CERT_NEVER
) {
403 push_cert_nonce
= server_feature_value("push-cert", &len
);
404 if (push_cert_nonce
) {
405 reject_invalid_nonce(push_cert_nonce
, len
);
406 push_cert_nonce
= xmemdupz(push_cert_nonce
, len
);
407 } else if (args
->push_cert
== SEND_PACK_PUSH_CERT_ALWAYS
) {
408 die(_("the receiving end does not support --signed push"));
409 } else if (args
->push_cert
== SEND_PACK_PUSH_CERT_IF_ASKED
) {
410 warning(_("not sending a push certificate since the"
411 " receiving end does not support --signed"
417 fprintf(stderr
, "No refs in common and none specified; doing nothing.\n"
418 "Perhaps you should specify a branch.\n");
421 if (args
->atomic
&& !atomic_supported
)
422 die(_("the receiving end does not support --atomic push"));
424 use_atomic
= atomic_supported
&& args
->atomic
;
426 if (args
->push_options
&& !push_options_supported
)
427 die(_("the receiving end does not support push options"));
429 use_push_options
= push_options_supported
&& args
->push_options
;
432 strbuf_addstr(&cap_buf
, " report-status");
434 strbuf_addstr(&cap_buf
, " side-band-64k");
435 if (quiet_supported
&& (args
->quiet
|| !args
->progress
))
436 strbuf_addstr(&cap_buf
, " quiet");
438 strbuf_addstr(&cap_buf
, " atomic");
439 if (use_push_options
)
440 strbuf_addstr(&cap_buf
, " push-options");
441 if (object_format_supported
)
442 strbuf_addf(&cap_buf
, " object-format=%s", the_hash_algo
->name
);
444 strbuf_addf(&cap_buf
, " agent=%s", git_user_agent_sanitized());
447 * NEEDSWORK: why does delete-refs have to be so specific to
448 * send-pack machinery that set_ref_status_for_push() cannot
449 * set this bit for us???
451 for (ref
= remote_refs
; ref
; ref
= ref
->next
)
452 if (ref
->deletion
&& !allow_deleting_refs
)
453 ref
->status
= REF_STATUS_REJECT_NODELETE
;
456 * Clear the status for each ref and see if we need to send
459 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
460 switch (check_to_send_update(ref
, args
)) {
461 case 0: /* no error */
463 case CHECK_REF_STATUS_REJECTED
:
465 * When we know the server would reject a ref update if
466 * we were to send it and we're trying to send the refs
467 * atomically, abort the whole operation.
470 strbuf_release(&req_buf
);
471 strbuf_release(&cap_buf
);
472 reject_atomic_push(remote_refs
, args
->send_mirror
);
473 error("atomic push failed for ref %s. status: %d\n",
474 ref
->name
, ref
->status
);
475 return args
->porcelain
? 0 : -1;
477 /* else fallthrough */
484 if (args
->dry_run
|| !status_report
)
485 ref
->status
= REF_STATUS_OK
;
487 ref
->status
= REF_STATUS_EXPECTING_REPORT
;
491 advertise_shallow_grafts_buf(&req_buf
);
494 * Finally, tell the other end!
496 if (!args
->dry_run
&& push_cert_nonce
)
497 cmds_sent
= generate_push_cert(&req_buf
, remote_refs
, args
,
498 cap_buf
.buf
, push_cert_nonce
);
499 else if (!args
->dry_run
)
500 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
501 char *old_hex
, *new_hex
;
503 if (check_to_send_update(ref
, args
) < 0)
506 old_hex
= oid_to_hex(&ref
->old_oid
);
507 new_hex
= oid_to_hex(&ref
->new_oid
);
509 packet_buf_write(&req_buf
,
511 old_hex
, new_hex
, ref
->name
, 0,
515 packet_buf_write(&req_buf
, "%s %s %s",
516 old_hex
, new_hex
, ref
->name
);
520 if (use_push_options
) {
521 struct string_list_item
*item
;
523 packet_buf_flush(&req_buf
);
524 for_each_string_list_item(item
, args
->push_options
)
525 packet_buf_write(&req_buf
, "%s", item
->string
);
528 if (args
->stateless_rpc
) {
529 if (!args
->dry_run
&& (cmds_sent
|| is_repository_shallow(the_repository
))) {
530 packet_buf_flush(&req_buf
);
531 send_sideband(out
, -1, req_buf
.buf
, req_buf
.len
, LARGE_PACKET_MAX
);
534 write_or_die(out
, req_buf
.buf
, req_buf
.len
);
537 strbuf_release(&req_buf
);
538 strbuf_release(&cap_buf
);
540 if (use_sideband
&& cmds_sent
) {
541 memset(&demux
, 0, sizeof(demux
));
542 demux
.proc
= sideband_demux
;
545 demux
.isolate_sigpipe
= 1;
546 if (start_async(&demux
))
547 die("send-pack: unable to fork off sideband demultiplexer");
551 packet_reader_init(&reader
, in
, NULL
, 0,
552 PACKET_READ_CHOMP_NEWLINE
|
553 PACKET_READ_DIE_ON_ERR_PACKET
);
555 if (need_pack_data
&& cmds_sent
) {
556 if (pack_objects(out
, remote_refs
, extra_have
, args
) < 0) {
557 if (args
->stateless_rpc
)
559 if (git_connection_is_socket(conn
))
560 shutdown(fd
[0], SHUT_WR
);
563 * Do not even bother with the return value; we know we
564 * are failing, and just want the error() side effects,
565 * as well as marking refs with their remote status (if
569 receive_status(&reader
, remote_refs
);
573 finish_async(&demux
);
578 if (!args
->stateless_rpc
)
579 /* Closed by pack_objects() via start_command() */
582 if (args
->stateless_rpc
&& cmds_sent
)
585 if (status_report
&& cmds_sent
)
586 ret
= receive_status(&reader
, remote_refs
);
589 if (args
->stateless_rpc
)
592 if (use_sideband
&& cmds_sent
) {
594 if (finish_async(&demux
)) {
595 error("error in sideband demultiplexer");
606 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
607 switch (ref
->status
) {
608 case REF_STATUS_NONE
:
609 case REF_STATUS_UPTODATE
: