6 #include "run-command.h"
11 #include "transport.h"
13 #include "sha1-array.h"
14 #include "gpg-interface.h"
17 int option_parse_push_signed(const struct option
*opt
,
18 const char *arg
, int unset
)
21 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_NEVER
;
24 switch (git_parse_maybe_bool(arg
)) {
26 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_ALWAYS
;
29 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_NEVER
;
32 if (!strcasecmp("if-asked", arg
)) {
33 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_IF_ASKED
;
36 die("bad %s argument: %s", opt
->long_name
, arg
);
39 static void feed_object(const unsigned char *sha1
, FILE *fh
, int negative
)
41 if (negative
&& !has_sha1_file(sha1
))
46 fputs(sha1_to_hex(sha1
), fh
);
51 * Make a pack stream and spit it out into file descriptor fd
53 static int pack_objects(int fd
, struct ref
*refs
, struct sha1_array
*extra
, struct send_pack_args
*args
)
56 * The child becomes pack-objects --revs; we feed
57 * the revision parameters to it via its stdin and
58 * let its stdout go back to the other end.
60 const char *argv
[] = {
62 "--all-progress-implied",
72 struct child_process po
= CHILD_PROCESS_INIT
;
77 if (args
->use_thin_pack
)
79 if (args
->use_ofs_delta
)
80 argv
[i
++] = "--delta-base-offset";
81 if (args
->quiet
|| !args
->progress
)
84 argv
[i
++] = "--progress";
85 if (is_repository_shallow())
86 argv
[i
++] = "--shallow";
89 po
.out
= args
->stateless_rpc
? -1 : fd
;
91 if (start_command(&po
))
92 die_errno("git pack-objects failed");
95 * We feed the pack-objects we just spawned with revision
96 * parameters by writing to the pipe.
98 po_in
= xfdopen(po
.in
, "w");
99 for (i
= 0; i
< extra
->nr
; i
++)
100 feed_object(extra
->sha1
[i
], po_in
, 1);
103 if (!is_null_oid(&refs
->old_oid
))
104 feed_object(refs
->old_oid
.hash
, po_in
, 1);
105 if (!is_null_oid(&refs
->new_oid
))
106 feed_object(refs
->new_oid
.hash
, po_in
, 0);
112 die_errno("error writing to pack-objects");
115 if (args
->stateless_rpc
) {
116 char *buf
= xmalloc(LARGE_PACKET_MAX
);
118 ssize_t n
= xread(po
.out
, buf
, LARGE_PACKET_MAX
);
121 send_sideband(fd
, -1, buf
, n
, LARGE_PACKET_MAX
);
128 if (finish_command(&po
))
133 static int receive_unpack_status(int in
)
135 const char *line
= packet_read_line(in
, NULL
);
136 if (!skip_prefix(line
, "unpack ", &line
))
137 return error("did not receive remote status");
138 if (strcmp(line
, "ok"))
139 return error("unpack failed: %s", line
);
143 static int receive_status(int in
, struct ref
*refs
)
149 ret
= receive_unpack_status(in
);
153 char *line
= packet_read_line(in
, NULL
);
156 if (!starts_with(line
, "ok ") && !starts_with(line
, "ng ")) {
157 error("invalid ref status from remote: %s", line
);
163 msg
= strchr(refname
, ' ');
167 /* first try searching at our hint, falling back to all refs */
169 hint
= find_ref_by_name(hint
, refname
);
171 hint
= find_ref_by_name(refs
, refname
);
173 warning("remote reported status on unknown ref: %s",
177 if (hint
->status
!= REF_STATUS_EXPECTING_REPORT
) {
178 warning("remote reported status on unexpected ref: %s",
183 if (line
[0] == 'o' && line
[1] == 'k')
184 hint
->status
= REF_STATUS_OK
;
186 hint
->status
= REF_STATUS_REMOTE_REJECT
;
189 hint
->remote_status
= xstrdup_or_null(msg
);
190 /* start our next search from the next ref */
196 static int sideband_demux(int in
, int out
, void *data
)
202 ret
= recv_sideband("send-pack", fd
[0], out
);
207 static int advertise_shallow_grafts_cb(const struct commit_graft
*graft
, void *cb
)
209 struct strbuf
*sb
= cb
;
210 if (graft
->nr_parent
== -1)
211 packet_buf_write(sb
, "shallow %s\n", oid_to_hex(&graft
->oid
));
215 static void advertise_shallow_grafts_buf(struct strbuf
*sb
)
217 if (!is_repository_shallow())
219 for_each_commit_graft(advertise_shallow_grafts_cb
, sb
);
222 #define CHECK_REF_NO_PUSH -1
223 #define CHECK_REF_STATUS_REJECTED -2
224 #define CHECK_REF_UPTODATE -3
225 static int check_to_send_update(const struct ref
*ref
, const struct send_pack_args
*args
)
227 if (!ref
->peer_ref
&& !args
->send_mirror
)
228 return CHECK_REF_NO_PUSH
;
230 /* Check for statuses set by set_ref_status_for_push() */
231 switch (ref
->status
) {
232 case REF_STATUS_REJECT_NONFASTFORWARD
:
233 case REF_STATUS_REJECT_ALREADY_EXISTS
:
234 case REF_STATUS_REJECT_FETCH_FIRST
:
235 case REF_STATUS_REJECT_NEEDS_FORCE
:
236 case REF_STATUS_REJECT_STALE
:
237 case REF_STATUS_REJECT_NODELETE
:
238 return CHECK_REF_STATUS_REJECTED
;
239 case REF_STATUS_UPTODATE
:
240 return CHECK_REF_UPTODATE
;
247 * the beginning of the next line, or the end of buffer.
249 * NEEDSWORK: perhaps move this to git-compat-util.h or somewhere and
250 * convert many similar uses found by "git grep -A4 memchr".
252 static const char *next_line(const char *line
, size_t len
)
254 const char *nl
= memchr(line
, '\n', len
);
256 return line
+ len
; /* incomplete line */
260 static int generate_push_cert(struct strbuf
*req_buf
,
261 const struct ref
*remote_refs
,
262 struct send_pack_args
*args
,
263 const char *cap_string
,
264 const char *push_cert_nonce
)
266 const struct ref
*ref
;
267 struct string_list_item
*item
;
268 char *signing_key
= xstrdup(get_signing_key());
270 struct strbuf cert
= STRBUF_INIT
;
273 strbuf_addstr(&cert
, "certificate version 0.1\n");
274 strbuf_addf(&cert
, "pusher %s ", signing_key
);
276 strbuf_addch(&cert
, '\n');
277 if (args
->url
&& *args
->url
) {
278 char *anon_url
= transport_anonymize_url(args
->url
);
279 strbuf_addf(&cert
, "pushee %s\n", anon_url
);
282 if (push_cert_nonce
[0])
283 strbuf_addf(&cert
, "nonce %s\n", push_cert_nonce
);
284 if (args
->push_options
)
285 for_each_string_list_item(item
, args
->push_options
)
286 strbuf_addf(&cert
, "push-option %s\n", item
->string
);
287 strbuf_addstr(&cert
, "\n");
289 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
290 if (check_to_send_update(ref
, args
) < 0)
293 strbuf_addf(&cert
, "%s %s %s\n",
294 oid_to_hex(&ref
->old_oid
),
295 oid_to_hex(&ref
->new_oid
),
301 if (sign_buffer(&cert
, &cert
, signing_key
))
302 die(_("failed to sign the push certificate"));
304 packet_buf_write(req_buf
, "push-cert%c%s", 0, cap_string
);
305 for (cp
= cert
.buf
; cp
< cert
.buf
+ cert
.len
; cp
= np
) {
306 np
= next_line(cp
, cert
.buf
+ cert
.len
- cp
);
307 packet_buf_write(req_buf
,
308 "%.*s", (int)(np
- cp
), cp
);
310 packet_buf_write(req_buf
, "push-cert-end\n");
314 strbuf_release(&cert
);
319 static int atomic_push_failure(struct send_pack_args
*args
,
320 struct ref
*remote_refs
,
321 struct ref
*failing_ref
)
324 /* Mark other refs as failed */
325 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
326 if (!ref
->peer_ref
&& !args
->send_mirror
)
329 switch (ref
->status
) {
330 case REF_STATUS_EXPECTING_REPORT
:
331 ref
->status
= REF_STATUS_ATOMIC_PUSH_FAILED
;
334 break; /* do nothing */
337 return error("atomic push failed for ref %s. status: %d\n",
338 failing_ref
->name
, failing_ref
->status
);
341 #define NONCE_LEN_LIMIT 256
343 static void reject_invalid_nonce(const char *nonce
, int len
)
347 if (NONCE_LEN_LIMIT
<= len
)
348 die("the receiving end asked to sign an invalid nonce <%.*s>",
351 for (i
= 0; i
< len
; i
++) {
352 int ch
= nonce
[i
] & 0xFF;
354 ch
== '-' || ch
== '.' ||
355 ch
== '/' || ch
== '+' ||
356 ch
== '=' || ch
== '_')
358 die("the receiving end asked to sign an invalid nonce <%.*s>",
363 int send_pack(struct send_pack_args
*args
,
364 int fd
[], struct child_process
*conn
,
365 struct ref
*remote_refs
,
366 struct sha1_array
*extra_have
)
370 struct strbuf req_buf
= STRBUF_INIT
;
371 struct strbuf cap_buf
= STRBUF_INIT
;
373 int need_pack_data
= 0;
374 int allow_deleting_refs
= 0;
375 int status_report
= 0;
376 int use_sideband
= 0;
377 int quiet_supported
= 0;
378 int agent_supported
= 0;
380 int atomic_supported
= 0;
381 int use_push_options
= 0;
382 int push_options_supported
= 0;
383 unsigned cmds_sent
= 0;
386 const char *push_cert_nonce
= NULL
;
388 /* Does the other end support the reporting? */
389 if (server_supports("report-status"))
391 if (server_supports("delete-refs"))
392 allow_deleting_refs
= 1;
393 if (server_supports("ofs-delta"))
394 args
->use_ofs_delta
= 1;
395 if (server_supports("side-band-64k"))
397 if (server_supports("quiet"))
399 if (server_supports("agent"))
401 if (server_supports("no-thin"))
402 args
->use_thin_pack
= 0;
403 if (server_supports("atomic"))
404 atomic_supported
= 1;
405 if (server_supports("push-options"))
406 push_options_supported
= 1;
408 if (args
->push_cert
!= SEND_PACK_PUSH_CERT_NEVER
) {
410 push_cert_nonce
= server_feature_value("push-cert", &len
);
411 if (push_cert_nonce
) {
412 reject_invalid_nonce(push_cert_nonce
, len
);
413 push_cert_nonce
= xmemdupz(push_cert_nonce
, len
);
414 } else if (args
->push_cert
== SEND_PACK_PUSH_CERT_ALWAYS
) {
415 die(_("the receiving end does not support --signed push"));
416 } else if (args
->push_cert
== SEND_PACK_PUSH_CERT_IF_ASKED
) {
417 warning(_("not sending a push certificate since the"
418 " receiving end does not support --signed"
424 fprintf(stderr
, "No refs in common and none specified; doing nothing.\n"
425 "Perhaps you should specify a branch such as 'master'.\n");
428 if (args
->atomic
&& !atomic_supported
)
429 die(_("the receiving end does not support --atomic push"));
431 use_atomic
= atomic_supported
&& args
->atomic
;
433 if (args
->push_options
&& !push_options_supported
)
434 die(_("the receiving end does not support push options"));
436 use_push_options
= push_options_supported
&& args
->push_options
;
439 strbuf_addstr(&cap_buf
, " report-status");
441 strbuf_addstr(&cap_buf
, " side-band-64k");
442 if (quiet_supported
&& (args
->quiet
|| !args
->progress
))
443 strbuf_addstr(&cap_buf
, " quiet");
445 strbuf_addstr(&cap_buf
, " atomic");
446 if (use_push_options
)
447 strbuf_addstr(&cap_buf
, " push-options");
449 strbuf_addf(&cap_buf
, " agent=%s", git_user_agent_sanitized());
452 * NEEDSWORK: why does delete-refs have to be so specific to
453 * send-pack machinery that set_ref_status_for_push() cannot
454 * set this bit for us???
456 for (ref
= remote_refs
; ref
; ref
= ref
->next
)
457 if (ref
->deletion
&& !allow_deleting_refs
)
458 ref
->status
= REF_STATUS_REJECT_NODELETE
;
461 advertise_shallow_grafts_buf(&req_buf
);
463 if (!args
->dry_run
&& push_cert_nonce
)
464 cmds_sent
= generate_push_cert(&req_buf
, remote_refs
, args
,
465 cap_buf
.buf
, push_cert_nonce
);
468 * Clear the status for each ref and see if we need to send
471 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
472 switch (check_to_send_update(ref
, args
)) {
473 case 0: /* no error */
475 case CHECK_REF_STATUS_REJECTED
:
477 * When we know the server would reject a ref update if
478 * we were to send it and we're trying to send the refs
479 * atomically, abort the whole operation.
482 return atomic_push_failure(args
, remote_refs
, ref
);
483 /* Fallthrough for non atomic case. */
490 if (args
->dry_run
|| !status_report
)
491 ref
->status
= REF_STATUS_OK
;
493 ref
->status
= REF_STATUS_EXPECTING_REPORT
;
497 * Finally, tell the other end!
499 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
500 char *old_hex
, *new_hex
;
502 if (args
->dry_run
|| push_cert_nonce
)
505 if (check_to_send_update(ref
, args
) < 0)
508 old_hex
= oid_to_hex(&ref
->old_oid
);
509 new_hex
= oid_to_hex(&ref
->new_oid
);
511 packet_buf_write(&req_buf
,
513 old_hex
, new_hex
, ref
->name
, 0,
517 packet_buf_write(&req_buf
, "%s %s %s",
518 old_hex
, new_hex
, ref
->name
);
522 if (args
->stateless_rpc
) {
523 if (!args
->dry_run
&& (cmds_sent
|| is_repository_shallow())) {
524 packet_buf_flush(&req_buf
);
525 send_sideband(out
, -1, req_buf
.buf
, req_buf
.len
, LARGE_PACKET_MAX
);
528 write_or_die(out
, req_buf
.buf
, req_buf
.len
);
531 strbuf_release(&req_buf
);
532 strbuf_release(&cap_buf
);
534 if (use_push_options
) {
535 struct string_list_item
*item
;
536 struct strbuf sb
= STRBUF_INIT
;
538 for_each_string_list_item(item
, args
->push_options
)
539 packet_buf_write(&sb
, "%s", item
->string
);
541 write_or_die(out
, sb
.buf
, sb
.len
);
546 if (use_sideband
&& cmds_sent
) {
547 memset(&demux
, 0, sizeof(demux
));
548 demux
.proc
= sideband_demux
;
551 demux
.isolate_sigpipe
= 1;
552 if (start_async(&demux
))
553 die("send-pack: unable to fork off sideband demultiplexer");
557 if (need_pack_data
&& cmds_sent
) {
558 if (pack_objects(out
, remote_refs
, extra_have
, args
) < 0) {
559 for (ref
= remote_refs
; ref
; ref
= ref
->next
)
560 ref
->status
= REF_STATUS_NONE
;
561 if (args
->stateless_rpc
)
563 if (git_connection_is_socket(conn
))
564 shutdown(fd
[0], SHUT_WR
);
567 finish_async(&demux
);
572 if (!args
->stateless_rpc
)
573 /* Closed by pack_objects() via start_command() */
576 if (args
->stateless_rpc
&& cmds_sent
)
579 if (status_report
&& cmds_sent
)
580 ret
= receive_status(in
, remote_refs
);
583 if (args
->stateless_rpc
)
586 if (use_sideband
&& cmds_sent
) {
588 if (finish_async(&demux
)) {
589 error("error in sideband demultiplexer");
600 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
601 switch (ref
->status
) {
602 case REF_STATUS_NONE
:
603 case REF_STATUS_UPTODATE
: