5 #include "object-store.h"
8 #include "run-command.h"
11 #include "send-pack.h"
13 #include "transport.h"
15 #include "sha1-array.h"
16 #include "gpg-interface.h"
19 int option_parse_push_signed(const struct option
*opt
,
20 const char *arg
, int unset
)
23 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_NEVER
;
26 switch (git_parse_maybe_bool(arg
)) {
28 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_ALWAYS
;
31 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_NEVER
;
34 if (!strcasecmp("if-asked", arg
)) {
35 *(int *)(opt
->value
) = SEND_PACK_PUSH_CERT_IF_ASKED
;
38 die("bad %s argument: %s", opt
->long_name
, arg
);
41 static void feed_object(const struct object_id
*oid
, FILE *fh
, int negative
)
43 if (negative
&& !has_object_file(oid
))
48 fputs(oid_to_hex(oid
), fh
);
53 * Make a pack stream and spit it out into file descriptor fd
55 static int pack_objects(int fd
, struct ref
*refs
, struct oid_array
*extra
, struct send_pack_args
*args
)
58 * The child becomes pack-objects --revs; we feed
59 * the revision parameters to it via its stdin and
60 * let its stdout go back to the other end.
62 struct child_process po
= CHILD_PROCESS_INIT
;
67 argv_array_push(&po
.args
, "pack-objects");
68 argv_array_push(&po
.args
, "--all-progress-implied");
69 argv_array_push(&po
.args
, "--revs");
70 argv_array_push(&po
.args
, "--stdout");
71 if (args
->use_thin_pack
)
72 argv_array_push(&po
.args
, "--thin");
73 if (args
->use_ofs_delta
)
74 argv_array_push(&po
.args
, "--delta-base-offset");
75 if (args
->quiet
|| !args
->progress
)
76 argv_array_push(&po
.args
, "-q");
78 argv_array_push(&po
.args
, "--progress");
79 if (is_repository_shallow(the_repository
))
80 argv_array_push(&po
.args
, "--shallow");
82 po
.out
= args
->stateless_rpc
? -1 : fd
;
84 if (start_command(&po
))
85 die_errno("git pack-objects failed");
88 * We feed the pack-objects we just spawned with revision
89 * parameters by writing to the pipe.
91 po_in
= xfdopen(po
.in
, "w");
92 for (i
= 0; i
< extra
->nr
; i
++)
93 feed_object(&extra
->oid
[i
], po_in
, 1);
96 if (!is_null_oid(&refs
->old_oid
))
97 feed_object(&refs
->old_oid
, po_in
, 1);
98 if (!is_null_oid(&refs
->new_oid
))
99 feed_object(&refs
->new_oid
, po_in
, 0);
105 die_errno("error writing to pack-objects");
108 if (args
->stateless_rpc
) {
109 char *buf
= xmalloc(LARGE_PACKET_MAX
);
111 ssize_t n
= xread(po
.out
, buf
, LARGE_PACKET_MAX
);
114 send_sideband(fd
, -1, buf
, n
, LARGE_PACKET_MAX
);
121 rc
= finish_command(&po
);
124 * For a normal non-zero exit, we assume pack-objects wrote
125 * something useful to stderr. For death by signal, though,
126 * we should mention it to the user. The exception is SIGPIPE
127 * (141), because that's a normal occurrence if the remote end
128 * hangs up (and we'll report that by trying to read the unpack
131 if (rc
> 128 && rc
!= 141)
132 error("pack-objects died of signal %d", rc
- 128);
138 static int receive_unpack_status(struct packet_reader
*reader
)
140 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
141 return error(_("unexpected flush packet while reading remote unpack status"));
142 if (!skip_prefix(reader
->line
, "unpack ", &reader
->line
))
143 return error(_("unable to parse remote unpack status: %s"), reader
->line
);
144 if (strcmp(reader
->line
, "ok"))
145 return error(_("remote unpack failed: %s"), reader
->line
);
149 static int receive_status(struct packet_reader
*reader
, struct ref
*refs
)
155 ret
= receive_unpack_status(reader
);
159 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
161 if (!starts_with(reader
->line
, "ok ") && !starts_with(reader
->line
, "ng ")) {
162 error("invalid ref status from remote: %s", reader
->line
);
167 refname
= reader
->line
+ 3;
168 msg
= strchr(refname
, ' ');
172 /* first try searching at our hint, falling back to all refs */
174 hint
= find_ref_by_name(hint
, refname
);
176 hint
= find_ref_by_name(refs
, refname
);
178 warning("remote reported status on unknown ref: %s",
182 if (hint
->status
!= REF_STATUS_EXPECTING_REPORT
) {
183 warning("remote reported status on unexpected ref: %s",
188 if (reader
->line
[0] == 'o' && reader
->line
[1] == 'k')
189 hint
->status
= REF_STATUS_OK
;
191 hint
->status
= REF_STATUS_REMOTE_REJECT
;
194 hint
->remote_status
= xstrdup_or_null(msg
);
195 /* start our next search from the next ref */
201 static int sideband_demux(int in
, int out
, void *data
)
204 if (async_with_fork())
206 ret
= recv_sideband("send-pack", fd
[0], out
);
211 static int advertise_shallow_grafts_cb(const struct commit_graft
*graft
, void *cb
)
213 struct strbuf
*sb
= cb
;
214 if (graft
->nr_parent
== -1)
215 packet_buf_write(sb
, "shallow %s\n", oid_to_hex(&graft
->oid
));
219 static void advertise_shallow_grafts_buf(struct strbuf
*sb
)
221 if (!is_repository_shallow(the_repository
))
223 for_each_commit_graft(advertise_shallow_grafts_cb
, sb
);
226 #define CHECK_REF_NO_PUSH -1
227 #define CHECK_REF_STATUS_REJECTED -2
228 #define CHECK_REF_UPTODATE -3
229 static int check_to_send_update(const struct ref
*ref
, const struct send_pack_args
*args
)
231 if (!ref
->peer_ref
&& !args
->send_mirror
)
232 return CHECK_REF_NO_PUSH
;
234 /* Check for statuses set by set_ref_status_for_push() */
235 switch (ref
->status
) {
236 case REF_STATUS_REJECT_NONFASTFORWARD
:
237 case REF_STATUS_REJECT_ALREADY_EXISTS
:
238 case REF_STATUS_REJECT_FETCH_FIRST
:
239 case REF_STATUS_REJECT_NEEDS_FORCE
:
240 case REF_STATUS_REJECT_STALE
:
241 case REF_STATUS_REJECT_NODELETE
:
242 return CHECK_REF_STATUS_REJECTED
;
243 case REF_STATUS_UPTODATE
:
244 return CHECK_REF_UPTODATE
;
251 * the beginning of the next line, or the end of buffer.
253 * NEEDSWORK: perhaps move this to git-compat-util.h or somewhere and
254 * convert many similar uses found by "git grep -A4 memchr".
256 static const char *next_line(const char *line
, size_t len
)
258 const char *nl
= memchr(line
, '\n', len
);
260 return line
+ len
; /* incomplete line */
264 static int generate_push_cert(struct strbuf
*req_buf
,
265 const struct ref
*remote_refs
,
266 struct send_pack_args
*args
,
267 const char *cap_string
,
268 const char *push_cert_nonce
)
270 const struct ref
*ref
;
271 struct string_list_item
*item
;
272 char *signing_key
= xstrdup(get_signing_key());
274 struct strbuf cert
= STRBUF_INIT
;
277 strbuf_addstr(&cert
, "certificate version 0.1\n");
278 strbuf_addf(&cert
, "pusher %s ", signing_key
);
280 strbuf_addch(&cert
, '\n');
281 if (args
->url
&& *args
->url
) {
282 char *anon_url
= transport_anonymize_url(args
->url
);
283 strbuf_addf(&cert
, "pushee %s\n", anon_url
);
286 if (push_cert_nonce
[0])
287 strbuf_addf(&cert
, "nonce %s\n", push_cert_nonce
);
288 if (args
->push_options
)
289 for_each_string_list_item(item
, args
->push_options
)
290 strbuf_addf(&cert
, "push-option %s\n", item
->string
);
291 strbuf_addstr(&cert
, "\n");
293 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
294 if (check_to_send_update(ref
, args
) < 0)
297 strbuf_addf(&cert
, "%s %s %s\n",
298 oid_to_hex(&ref
->old_oid
),
299 oid_to_hex(&ref
->new_oid
),
305 if (sign_buffer(&cert
, &cert
, signing_key
))
306 die(_("failed to sign the push certificate"));
308 packet_buf_write(req_buf
, "push-cert%c%s", 0, cap_string
);
309 for (cp
= cert
.buf
; cp
< cert
.buf
+ cert
.len
; cp
= np
) {
310 np
= next_line(cp
, cert
.buf
+ cert
.len
- cp
);
311 packet_buf_write(req_buf
,
312 "%.*s", (int)(np
- cp
), cp
);
314 packet_buf_write(req_buf
, "push-cert-end\n");
318 strbuf_release(&cert
);
323 static int atomic_push_failure(struct send_pack_args
*args
,
324 struct ref
*remote_refs
,
325 struct ref
*failing_ref
)
328 /* Mark other refs as failed */
329 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
330 if (!ref
->peer_ref
&& !args
->send_mirror
)
333 switch (ref
->status
) {
334 case REF_STATUS_EXPECTING_REPORT
:
335 ref
->status
= REF_STATUS_ATOMIC_PUSH_FAILED
;
338 break; /* do nothing */
341 return error("atomic push failed for ref %s. status: %d\n",
342 failing_ref
->name
, failing_ref
->status
);
345 #define NONCE_LEN_LIMIT 256
347 static void reject_invalid_nonce(const char *nonce
, int len
)
351 if (NONCE_LEN_LIMIT
<= len
)
352 die("the receiving end asked to sign an invalid nonce <%.*s>",
355 for (i
= 0; i
< len
; i
++) {
356 int ch
= nonce
[i
] & 0xFF;
358 ch
== '-' || ch
== '.' ||
359 ch
== '/' || ch
== '+' ||
360 ch
== '=' || ch
== '_')
362 die("the receiving end asked to sign an invalid nonce <%.*s>",
367 int send_pack(struct send_pack_args
*args
,
368 int fd
[], struct child_process
*conn
,
369 struct ref
*remote_refs
,
370 struct oid_array
*extra_have
)
374 struct strbuf req_buf
= STRBUF_INIT
;
375 struct strbuf cap_buf
= STRBUF_INIT
;
377 int need_pack_data
= 0;
378 int allow_deleting_refs
= 0;
379 int status_report
= 0;
380 int use_sideband
= 0;
381 int quiet_supported
= 0;
382 int agent_supported
= 0;
384 int atomic_supported
= 0;
385 int use_push_options
= 0;
386 int push_options_supported
= 0;
387 unsigned cmds_sent
= 0;
390 const char *push_cert_nonce
= NULL
;
391 struct packet_reader reader
;
393 /* Does the other end support the reporting? */
394 if (server_supports("report-status"))
396 if (server_supports("delete-refs"))
397 allow_deleting_refs
= 1;
398 if (server_supports("ofs-delta"))
399 args
->use_ofs_delta
= 1;
400 if (server_supports("side-band-64k"))
402 if (server_supports("quiet"))
404 if (server_supports("agent"))
406 if (server_supports("no-thin"))
407 args
->use_thin_pack
= 0;
408 if (server_supports("atomic"))
409 atomic_supported
= 1;
410 if (server_supports("push-options"))
411 push_options_supported
= 1;
413 if (args
->push_cert
!= SEND_PACK_PUSH_CERT_NEVER
) {
415 push_cert_nonce
= server_feature_value("push-cert", &len
);
416 if (push_cert_nonce
) {
417 reject_invalid_nonce(push_cert_nonce
, len
);
418 push_cert_nonce
= xmemdupz(push_cert_nonce
, len
);
419 } else if (args
->push_cert
== SEND_PACK_PUSH_CERT_ALWAYS
) {
420 die(_("the receiving end does not support --signed push"));
421 } else if (args
->push_cert
== SEND_PACK_PUSH_CERT_IF_ASKED
) {
422 warning(_("not sending a push certificate since the"
423 " receiving end does not support --signed"
429 fprintf(stderr
, "No refs in common and none specified; doing nothing.\n"
430 "Perhaps you should specify a branch such as 'master'.\n");
433 if (args
->atomic
&& !atomic_supported
)
434 die(_("the receiving end does not support --atomic push"));
436 use_atomic
= atomic_supported
&& args
->atomic
;
438 if (args
->push_options
&& !push_options_supported
)
439 die(_("the receiving end does not support push options"));
441 use_push_options
= push_options_supported
&& args
->push_options
;
444 strbuf_addstr(&cap_buf
, " report-status");
446 strbuf_addstr(&cap_buf
, " side-band-64k");
447 if (quiet_supported
&& (args
->quiet
|| !args
->progress
))
448 strbuf_addstr(&cap_buf
, " quiet");
450 strbuf_addstr(&cap_buf
, " atomic");
451 if (use_push_options
)
452 strbuf_addstr(&cap_buf
, " push-options");
454 strbuf_addf(&cap_buf
, " agent=%s", git_user_agent_sanitized());
457 * NEEDSWORK: why does delete-refs have to be so specific to
458 * send-pack machinery that set_ref_status_for_push() cannot
459 * set this bit for us???
461 for (ref
= remote_refs
; ref
; ref
= ref
->next
)
462 if (ref
->deletion
&& !allow_deleting_refs
)
463 ref
->status
= REF_STATUS_REJECT_NODELETE
;
466 advertise_shallow_grafts_buf(&req_buf
);
468 if (!args
->dry_run
&& push_cert_nonce
)
469 cmds_sent
= generate_push_cert(&req_buf
, remote_refs
, args
,
470 cap_buf
.buf
, push_cert_nonce
);
473 * Clear the status for each ref and see if we need to send
476 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
477 switch (check_to_send_update(ref
, args
)) {
478 case 0: /* no error */
480 case CHECK_REF_STATUS_REJECTED
:
482 * When we know the server would reject a ref update if
483 * we were to send it and we're trying to send the refs
484 * atomically, abort the whole operation.
487 strbuf_release(&req_buf
);
488 strbuf_release(&cap_buf
);
489 return atomic_push_failure(args
, remote_refs
, ref
);
491 /* else fallthrough */
498 if (args
->dry_run
|| !status_report
)
499 ref
->status
= REF_STATUS_OK
;
501 ref
->status
= REF_STATUS_EXPECTING_REPORT
;
505 * Finally, tell the other end!
507 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
508 char *old_hex
, *new_hex
;
510 if (args
->dry_run
|| push_cert_nonce
)
513 if (check_to_send_update(ref
, args
) < 0)
516 old_hex
= oid_to_hex(&ref
->old_oid
);
517 new_hex
= oid_to_hex(&ref
->new_oid
);
519 packet_buf_write(&req_buf
,
521 old_hex
, new_hex
, ref
->name
, 0,
525 packet_buf_write(&req_buf
, "%s %s %s",
526 old_hex
, new_hex
, ref
->name
);
530 if (use_push_options
) {
531 struct string_list_item
*item
;
533 packet_buf_flush(&req_buf
);
534 for_each_string_list_item(item
, args
->push_options
)
535 packet_buf_write(&req_buf
, "%s", item
->string
);
538 if (args
->stateless_rpc
) {
539 if (!args
->dry_run
&& (cmds_sent
|| is_repository_shallow(the_repository
))) {
540 packet_buf_flush(&req_buf
);
541 send_sideband(out
, -1, req_buf
.buf
, req_buf
.len
, LARGE_PACKET_MAX
);
544 write_or_die(out
, req_buf
.buf
, req_buf
.len
);
547 strbuf_release(&req_buf
);
548 strbuf_release(&cap_buf
);
550 if (use_sideband
&& cmds_sent
) {
551 memset(&demux
, 0, sizeof(demux
));
552 demux
.proc
= sideband_demux
;
555 demux
.isolate_sigpipe
= 1;
556 if (start_async(&demux
))
557 die("send-pack: unable to fork off sideband demultiplexer");
561 packet_reader_init(&reader
, in
, NULL
, 0,
562 PACKET_READ_CHOMP_NEWLINE
|
563 PACKET_READ_DIE_ON_ERR_PACKET
);
565 if (need_pack_data
&& cmds_sent
) {
566 if (pack_objects(out
, remote_refs
, extra_have
, args
) < 0) {
567 for (ref
= remote_refs
; ref
; ref
= ref
->next
)
568 ref
->status
= REF_STATUS_NONE
;
569 if (args
->stateless_rpc
)
571 if (git_connection_is_socket(conn
))
572 shutdown(fd
[0], SHUT_WR
);
575 * Do not even bother with the return value; we know we
576 * are failing, and just want the error() side effects.
579 receive_unpack_status(&reader
);
583 finish_async(&demux
);
588 if (!args
->stateless_rpc
)
589 /* Closed by pack_objects() via start_command() */
592 if (args
->stateless_rpc
&& cmds_sent
)
595 if (status_report
&& cmds_sent
)
596 ret
= receive_status(&reader
, remote_refs
);
599 if (args
->stateless_rpc
)
602 if (use_sideband
&& cmds_sent
) {
604 if (finish_async(&demux
)) {
605 error("error in sideband demultiplexer");
616 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
617 switch (ref
->status
) {
618 case REF_STATUS_NONE
:
619 case REF_STATUS_UPTODATE
: