freshlybakedca.ke
Git fork
1#include "git-compat-util.h"
2#include "config.h"
3#include "commit.h"
4#include "date.h"
5#include "gettext.h"
6#include "hex.h"
7#include "odb.h"
8#include "pkt-line.h"
9#include "sideband.h"
10#include "run-command.h"
11#include "remote.h"
12#include "connect.h"
13#include "send-pack.h"
14#include "transport.h"
15#include "version.h"
16#include "oid-array.h"
17#include "gpg-interface.h"
18#include "shallow.h"
19#include "parse-options.h"
20#include "trace2.h"
21#include "write-or-die.h"
22
23int option_parse_push_signed(const struct option *opt,
24 const char *arg, int unset)
25{
26 if (unset) {
27 *(int *)(opt->value) = SEND_PACK_PUSH_CERT_NEVER;
28 return 0;
29 }
30 switch (git_parse_maybe_bool(arg)) {
31 case 1:
32 *(int *)(opt->value) = SEND_PACK_PUSH_CERT_ALWAYS;
33 return 0;
34 case 0:
35 *(int *)(opt->value) = SEND_PACK_PUSH_CERT_NEVER;
36 return 0;
37 }
38 if (!strcasecmp("if-asked", arg)) {
39 *(int *)(opt->value) = SEND_PACK_PUSH_CERT_IF_ASKED;
40 return 0;
41 }
42 die("bad %s argument: %s", opt->long_name, arg);
43}
44
45static void feed_object(struct repository *r,
46 const struct object_id *oid, FILE *fh, int negative)
47{
48 if (negative && !odb_has_object(r->objects, oid, 0))
49 return;
50
51 if (negative)
52 putc('^', fh);
53 fputs(oid_to_hex(oid), fh);
54 putc('\n', fh);
55}
56
57/*
58 * Make a pack stream and spit it out into file descriptor fd
59 */
60static int pack_objects(struct repository *r,
61 int fd, struct ref *refs, struct oid_array *advertised,
62 struct oid_array *negotiated,
63 struct send_pack_args *args)
64{
65 /*
66 * The child becomes pack-objects --revs; we feed
67 * the revision parameters to it via its stdin and
68 * let its stdout go back to the other end.
69 */
70 struct child_process po = CHILD_PROCESS_INIT;
71 FILE *po_in;
72 int rc;
73
74 trace2_region_enter("send_pack", "pack_objects", r);
75 strvec_push(&po.args, "pack-objects");
76 strvec_push(&po.args, "--all-progress-implied");
77 strvec_push(&po.args, "--revs");
78 strvec_push(&po.args, "--stdout");
79 if (args->use_thin_pack)
80 strvec_push(&po.args, "--thin");
81 if (args->use_ofs_delta)
82 strvec_push(&po.args, "--delta-base-offset");
83 if (args->quiet || !args->progress)
84 strvec_push(&po.args, "-q");
85 if (args->progress)
86 strvec_push(&po.args, "--progress");
87 if (is_repository_shallow(r))
88 strvec_push(&po.args, "--shallow");
89 if (args->disable_bitmaps)
90 strvec_push(&po.args, "--no-use-bitmap-index");
91 po.in = -1;
92 po.out = args->stateless_rpc ? -1 : fd;
93 po.git_cmd = 1;
94 po.clean_on_exit = 1;
95 if (start_command(&po))
96 die_errno("git pack-objects failed");
97
98 /*
99 * We feed the pack-objects we just spawned with revision
100 * parameters by writing to the pipe.
101 */
102 po_in = xfdopen(po.in, "w");
103 for (size_t i = 0; i < advertised->nr; i++)
104 feed_object(r, &advertised->oid[i], po_in, 1);
105 for (size_t i = 0; i < negotiated->nr; i++)
106 feed_object(r, &negotiated->oid[i], po_in, 1);
107
108 while (refs) {
109 if (!is_null_oid(&refs->old_oid))
110 feed_object(r, &refs->old_oid, po_in, 1);
111 if (!is_null_oid(&refs->new_oid))
112 feed_object(r, &refs->new_oid, po_in, 0);
113 refs = refs->next;
114 }
115
116 fflush(po_in);
117 if (ferror(po_in))
118 die_errno("error writing to pack-objects");
119 fclose(po_in);
120
121 if (args->stateless_rpc) {
122 char *buf = xmalloc(LARGE_PACKET_MAX);
123 while (1) {
124 ssize_t n = xread(po.out, buf, LARGE_PACKET_MAX);
125 if (n <= 0)
126 break;
127 send_sideband(fd, -1, buf, n, LARGE_PACKET_MAX);
128 }
129 free(buf);
130 close(po.out);
131 po.out = -1;
132 }
133
134 rc = finish_command(&po);
135 if (rc) {
136 /*
137 * For a normal non-zero exit, we assume pack-objects wrote
138 * something useful to stderr. For death by signal, though,
139 * we should mention it to the user. The exception is SIGPIPE
140 * (141), because that's a normal occurrence if the remote end
141 * hangs up (and we'll report that by trying to read the unpack
142 * status).
143 */
144 if (rc > 128 && rc != 141)
145 error("pack-objects died of signal %d", rc - 128);
146 trace2_region_leave("send_pack", "pack_objects", r);
147 return -1;
148 }
149 trace2_region_leave("send_pack", "pack_objects", r);
150 return 0;
151}
152
153static int receive_unpack_status(struct packet_reader *reader)
154{
155 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
156 return error(_("unexpected flush packet while reading remote unpack status"));
157 if (!skip_prefix(reader->line, "unpack ", &reader->line))
158 return error(_("unable to parse remote unpack status: %s"), reader->line);
159 if (strcmp(reader->line, "ok"))
160 return error(_("remote unpack failed: %s"), reader->line);
161 return 0;
162}
163
164static int receive_status(struct repository *r,
165 struct packet_reader *reader, struct ref *refs)
166{
167 struct ref *hint;
168 int ret;
169 struct ref_push_report *report = NULL;
170 int new_report = 0;
171 int once = 0;
172
173 trace2_region_enter("send_pack", "receive_status", r);
174 hint = NULL;
175 ret = receive_unpack_status(reader);
176 while (1) {
177 struct object_id old_oid, new_oid;
178 const char *head;
179 const char *refname;
180 char *p;
181 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
182 break;
183 head = reader->line;
184 p = strchr(head, ' ');
185 if (!p) {
186 error("invalid status line from remote: %s", reader->line);
187 ret = -1;
188 break;
189 }
190 *p++ = '\0';
191
192 if (!strcmp(head, "option")) {
193 const char *key, *val;
194
195 if (!hint || !(report || new_report)) {
196 if (!once++)
197 error("'option' without a matching 'ok/ng' directive");
198 ret = -1;
199 continue;
200 }
201 if (new_report) {
202 if (!hint->report) {
203 CALLOC_ARRAY(hint->report, 1);
204 report = hint->report;
205 } else {
206 report = hint->report;
207 while (report->next)
208 report = report->next;
209 CALLOC_ARRAY(report->next, 1);
210 report = report->next;
211 }
212 new_report = 0;
213 }
214 key = p;
215 p = strchr(key, ' ');
216 if (p)
217 *p++ = '\0';
218 val = p;
219 if (!strcmp(key, "refname"))
220 report->ref_name = xstrdup_or_null(val);
221 else if (!strcmp(key, "old-oid") && val &&
222 !parse_oid_hex_algop(val, &old_oid, &val, r->hash_algo))
223 report->old_oid = oiddup(&old_oid);
224 else if (!strcmp(key, "new-oid") && val &&
225 !parse_oid_hex_algop(val, &new_oid, &val, r->hash_algo))
226 report->new_oid = oiddup(&new_oid);
227 else if (!strcmp(key, "forced-update"))
228 report->forced_update = 1;
229 continue;
230 }
231
232 report = NULL;
233 new_report = 0;
234 if (strcmp(head, "ok") && strcmp(head, "ng")) {
235 error("invalid ref status from remote: %s", head);
236 ret = -1;
237 break;
238 }
239 refname = p;
240 p = strchr(refname, ' ');
241 if (p)
242 *p++ = '\0';
243 /* first try searching at our hint, falling back to all refs */
244 if (hint)
245 hint = find_ref_by_name(hint, refname);
246 if (!hint)
247 hint = find_ref_by_name(refs, refname);
248 if (!hint) {
249 warning("remote reported status on unknown ref: %s",
250 refname);
251 continue;
252 }
253 if (hint->status != REF_STATUS_EXPECTING_REPORT &&
254 hint->status != REF_STATUS_OK &&
255 hint->status != REF_STATUS_REMOTE_REJECT) {
256 warning("remote reported status on unexpected ref: %s",
257 refname);
258 continue;
259 }
260
261 /*
262 * Clients sending duplicate refs can cause the same value
263 * to be overridden, causing a memory leak.
264 */
265 free(hint->remote_status);
266
267 if (!strcmp(head, "ng")) {
268 hint->status = REF_STATUS_REMOTE_REJECT;
269 if (p)
270 hint->remote_status = xstrdup(p);
271 else
272 hint->remote_status = xstrdup("failed");
273 } else {
274 hint->status = REF_STATUS_OK;
275 hint->remote_status = xstrdup_or_null(p);
276 new_report = 1;
277 }
278 }
279 trace2_region_leave("send_pack", "receive_status", r);
280 return ret;
281}
282
283static int sideband_demux(int in UNUSED, int out, void *data)
284{
285 int *fd = data, ret;
286 if (async_with_fork())
287 close(fd[1]);
288 ret = recv_sideband("send-pack", fd[0], out);
289 close(out);
290 return ret;
291}
292
293static int advertise_shallow_grafts_cb(const struct commit_graft *graft, void *cb)
294{
295 struct strbuf *sb = cb;
296 if (graft->nr_parent == -1)
297 packet_buf_write(sb, "shallow %s\n", oid_to_hex(&graft->oid));
298 return 0;
299}
300
301static void advertise_shallow_grafts_buf(struct repository *r, struct strbuf *sb)
302{
303 if (!is_repository_shallow(r))
304 return;
305 for_each_commit_graft(advertise_shallow_grafts_cb, sb);
306}
307
308#define CHECK_REF_NO_PUSH -1
309#define CHECK_REF_STATUS_REJECTED -2
310#define CHECK_REF_UPTODATE -3
311static int check_to_send_update(const struct ref *ref, const struct send_pack_args *args)
312{
313 if (!ref->peer_ref && !args->send_mirror)
314 return CHECK_REF_NO_PUSH;
315
316 /* Check for statuses set by set_ref_status_for_push() */
317 switch (ref->status) {
318 case REF_STATUS_REJECT_NONFASTFORWARD:
319 case REF_STATUS_REJECT_ALREADY_EXISTS:
320 case REF_STATUS_REJECT_FETCH_FIRST:
321 case REF_STATUS_REJECT_NEEDS_FORCE:
322 case REF_STATUS_REJECT_STALE:
323 case REF_STATUS_REJECT_REMOTE_UPDATED:
324 case REF_STATUS_REJECT_NODELETE:
325 return CHECK_REF_STATUS_REJECTED;
326 case REF_STATUS_UPTODATE:
327 return CHECK_REF_UPTODATE;
328
329 default:
330 case REF_STATUS_EXPECTING_REPORT:
331 /* already passed checks on the local side */
332 case REF_STATUS_OK:
333 /* of course this is OK */
334 return 0;
335 }
336}
337
338/*
339 * the beginning of the next line, or the end of buffer.
340 *
341 * NEEDSWORK: perhaps move this to git-compat-util.h or somewhere and
342 * convert many similar uses found by "git grep -A4 memchr".
343 */
344static const char *next_line(const char *line, size_t len)
345{
346 const char *nl = memchr(line, '\n', len);
347 if (!nl)
348 return line + len; /* incomplete line */
349 return nl + 1;
350}
351
352static int generate_push_cert(struct strbuf *req_buf,
353 const struct ref *remote_refs,
354 struct send_pack_args *args,
355 const char *cap_string,
356 const char *push_cert_nonce)
357{
358 const struct ref *ref;
359 struct string_list_item *item;
360 char *signing_key_id = get_signing_key_id();
361 char *signing_key = get_signing_key();
362 const char *cp, *np;
363 struct strbuf cert = STRBUF_INIT;
364 int update_seen = 0;
365
366 strbuf_addstr(&cert, "certificate version 0.1\n");
367 strbuf_addf(&cert, "pusher %s ", signing_key_id);
368 datestamp(&cert);
369 strbuf_addch(&cert, '\n');
370 if (args->url && *args->url) {
371 char *anon_url = transport_anonymize_url(args->url);
372 strbuf_addf(&cert, "pushee %s\n", anon_url);
373 free(anon_url);
374 }
375 if (push_cert_nonce[0])
376 strbuf_addf(&cert, "nonce %s\n", push_cert_nonce);
377 if (args->push_options)
378 for_each_string_list_item(item, args->push_options)
379 strbuf_addf(&cert, "push-option %s\n", item->string);
380 strbuf_addstr(&cert, "\n");
381
382 for (ref = remote_refs; ref; ref = ref->next) {
383 if (check_to_send_update(ref, args) < 0)
384 continue;
385 update_seen = 1;
386 strbuf_addf(&cert, "%s %s %s\n",
387 oid_to_hex(&ref->old_oid),
388 oid_to_hex(&ref->new_oid),
389 ref->name);
390 }
391 if (!update_seen)
392 goto free_return;
393
394 if (sign_buffer(&cert, &cert, signing_key))
395 die(_("failed to sign the push certificate"));
396
397 packet_buf_write(req_buf, "push-cert%c%s", 0, cap_string);
398 for (cp = cert.buf; cp < cert.buf + cert.len; cp = np) {
399 np = next_line(cp, cert.buf + cert.len - cp);
400 packet_buf_write(req_buf,
401 "%.*s", (int)(np - cp), cp);
402 }
403 packet_buf_write(req_buf, "push-cert-end\n");
404
405free_return:
406 free(signing_key_id);
407 free(signing_key);
408 strbuf_release(&cert);
409 return update_seen;
410}
411
412#define NONCE_LEN_LIMIT 256
413
414static void reject_invalid_nonce(const char *nonce, int len)
415{
416 int i = 0;
417
418 if (NONCE_LEN_LIMIT <= len)
419 die("the receiving end asked to sign an invalid nonce <%.*s>",
420 len, nonce);
421
422 for (i = 0; i < len; i++) {
423 int ch = nonce[i] & 0xFF;
424 if (isalnum(ch) ||
425 ch == '-' || ch == '.' ||
426 ch == '/' || ch == '+' ||
427 ch == '=' || ch == '_')
428 continue;
429 die("the receiving end asked to sign an invalid nonce <%.*s>",
430 len, nonce);
431 }
432}
433
434static void get_commons_through_negotiation(struct repository *r,
435 const char *url,
436 const struct ref *remote_refs,
437 struct oid_array *commons)
438{
439 struct child_process child = CHILD_PROCESS_INIT;
440 const struct ref *ref;
441 int len = r->hash_algo->hexsz + 1; /* hash + NL */
442 int nr_negotiation_tip = 0;
443
444 child.git_cmd = 1;
445 child.no_stdin = 1;
446 child.out = -1;
447 strvec_pushl(&child.args, "fetch", "--negotiate-only", NULL);
448 for (ref = remote_refs; ref; ref = ref->next) {
449 if (!is_null_oid(&ref->new_oid)) {
450 strvec_pushf(&child.args, "--negotiation-tip=%s",
451 oid_to_hex(&ref->new_oid));
452 nr_negotiation_tip++;
453 }
454 }
455 strvec_push(&child.args, url);
456
457 if (!nr_negotiation_tip) {
458 child_process_clear(&child);
459 return;
460 }
461
462 if (start_command(&child))
463 die(_("send-pack: unable to fork off fetch subprocess"));
464
465 do {
466 char hex_hash[GIT_MAX_HEXSZ + 1];
467 int read_len = read_in_full(child.out, hex_hash, len);
468 struct object_id oid;
469 const char *end;
470
471 if (!read_len)
472 break;
473 if (read_len != len)
474 die("invalid length read %d", read_len);
475 if (parse_oid_hex_algop(hex_hash, &oid, &end, r->hash_algo) || *end != '\n')
476 die("invalid hash");
477 oid_array_append(commons, &oid);
478 } while (1);
479
480 if (finish_command(&child)) {
481 /*
482 * The information that push negotiation provides is useful but
483 * not mandatory.
484 */
485 warning(_("push negotiation failed; proceeding anyway with push"));
486 }
487}
488
489int send_pack(struct repository *r,
490 struct send_pack_args *args,
491 int fd[], struct child_process *conn,
492 struct ref *remote_refs,
493 struct oid_array *extra_have)
494{
495 struct oid_array commons = OID_ARRAY_INIT;
496 int in = fd[0];
497 int out = fd[1];
498 struct strbuf req_buf = STRBUF_INIT;
499 struct strbuf cap_buf = STRBUF_INIT;
500 struct ref *ref;
501 int need_pack_data = 0;
502 int allow_deleting_refs = 0;
503 int status_report = 0;
504 int use_sideband = 0;
505 int quiet_supported = 0;
506 int agent_supported = 0;
507 int advertise_sid = 0;
508 int push_negotiate = 0;
509 int use_atomic = 0;
510 int atomic_supported = 0;
511 int use_push_options = 0;
512 int push_options_supported = 0;
513 int object_format_supported = 0;
514 unsigned cmds_sent = 0;
515 int ret;
516 struct async demux;
517 char *push_cert_nonce = NULL;
518 struct packet_reader reader;
519 int use_bitmaps;
520
521 if (!remote_refs) {
522 fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
523 "Perhaps you should specify a branch.\n");
524 ret = 0;
525 goto out;
526 }
527
528 repo_config_get_bool(r, "push.negotiate", &push_negotiate);
529 if (push_negotiate) {
530 trace2_region_enter("send_pack", "push_negotiate", r);
531 get_commons_through_negotiation(r, args->url, remote_refs, &commons);
532 trace2_region_leave("send_pack", "push_negotiate", r);
533 }
534
535 if (!repo_config_get_bool(r, "push.usebitmaps", &use_bitmaps))
536 args->disable_bitmaps = !use_bitmaps;
537
538 repo_config_get_bool(r, "transfer.advertisesid", &advertise_sid);
539
540 /* Does the other end support the reporting? */
541 if (server_supports("report-status-v2"))
542 status_report = 2;
543 else if (server_supports("report-status"))
544 status_report = 1;
545 if (server_supports("delete-refs"))
546 allow_deleting_refs = 1;
547 if (server_supports("ofs-delta"))
548 args->use_ofs_delta = 1;
549 if (server_supports("side-band-64k"))
550 use_sideband = 1;
551 if (server_supports("quiet"))
552 quiet_supported = 1;
553 if (server_supports("agent"))
554 agent_supported = 1;
555 if (!server_supports("session-id"))
556 advertise_sid = 0;
557 if (server_supports("no-thin"))
558 args->use_thin_pack = 0;
559 if (server_supports("atomic"))
560 atomic_supported = 1;
561 if (server_supports("push-options"))
562 push_options_supported = 1;
563
564 if (!server_supports_hash(r->hash_algo->name, &object_format_supported))
565 die(_("the receiving end does not support this repository's hash algorithm"));
566
567 if (args->push_cert != SEND_PACK_PUSH_CERT_NEVER) {
568 size_t len;
569 const char *nonce = server_feature_value("push-cert", &len);
570
571 if (nonce) {
572 reject_invalid_nonce(nonce, len);
573 push_cert_nonce = xmemdupz(nonce, len);
574 } else if (args->push_cert == SEND_PACK_PUSH_CERT_ALWAYS) {
575 die(_("the receiving end does not support --signed push"));
576 } else if (args->push_cert == SEND_PACK_PUSH_CERT_IF_ASKED) {
577 warning(_("not sending a push certificate since the"
578 " receiving end does not support --signed"
579 " push"));
580 }
581 }
582
583 if (args->atomic && !atomic_supported)
584 die(_("the receiving end does not support --atomic push"));
585
586 use_atomic = atomic_supported && args->atomic;
587
588 if (args->push_options && !push_options_supported)
589 die(_("the receiving end does not support push options"));
590
591 use_push_options = push_options_supported && args->push_options;
592
593 if (status_report == 1)
594 strbuf_addstr(&cap_buf, " report-status");
595 else if (status_report == 2)
596 strbuf_addstr(&cap_buf, " report-status-v2");
597 if (use_sideband)
598 strbuf_addstr(&cap_buf, " side-band-64k");
599 if (quiet_supported && (args->quiet || !args->progress))
600 strbuf_addstr(&cap_buf, " quiet");
601 if (use_atomic)
602 strbuf_addstr(&cap_buf, " atomic");
603 if (use_push_options)
604 strbuf_addstr(&cap_buf, " push-options");
605 if (object_format_supported)
606 strbuf_addf(&cap_buf, " object-format=%s", r->hash_algo->name);
607 if (agent_supported)
608 strbuf_addf(&cap_buf, " agent=%s", git_user_agent_sanitized());
609 if (advertise_sid)
610 strbuf_addf(&cap_buf, " session-id=%s", trace2_session_id());
611
612 /*
613 * NEEDSWORK: why does delete-refs have to be so specific to
614 * send-pack machinery that set_ref_status_for_push() cannot
615 * set this bit for us???
616 */
617 for (ref = remote_refs; ref; ref = ref->next)
618 if (ref->deletion && !allow_deleting_refs)
619 ref->status = REF_STATUS_REJECT_NODELETE;
620
621 /*
622 * Clear the status for each ref and see if we need to send
623 * the pack data.
624 */
625 for (ref = remote_refs; ref; ref = ref->next) {
626 switch (check_to_send_update(ref, args)) {
627 case 0: /* no error */
628 break;
629 case CHECK_REF_STATUS_REJECTED:
630 /*
631 * When we know the server would reject a ref update if
632 * we were to send it and we're trying to send the refs
633 * atomically, abort the whole operation.
634 */
635 if (use_atomic) {
636 reject_atomic_push(remote_refs, args->send_mirror);
637 error("atomic push failed for ref %s. status: %d",
638 ref->name, ref->status);
639 ret = ERROR_SEND_PACK_BAD_REF_STATUS;
640 packet_flush(out);
641 goto out;
642 }
643 /* else fallthrough */
644 default:
645 continue;
646 }
647 if (!ref->deletion)
648 need_pack_data = 1;
649
650 if (args->dry_run || !status_report)
651 ref->status = REF_STATUS_OK;
652 else
653 ref->status = REF_STATUS_EXPECTING_REPORT;
654 }
655
656 if (!args->dry_run)
657 advertise_shallow_grafts_buf(r, &req_buf);
658
659 /*
660 * Finally, tell the other end!
661 */
662 if (!args->dry_run && push_cert_nonce) {
663 cmds_sent = generate_push_cert(&req_buf, remote_refs, args,
664 cap_buf.buf, push_cert_nonce);
665 trace2_printf("Generated push certificate");
666 } else if (!args->dry_run) {
667 for (ref = remote_refs; ref; ref = ref->next) {
668 char *old_hex, *new_hex;
669
670 if (check_to_send_update(ref, args) < 0)
671 continue;
672
673 old_hex = oid_to_hex(&ref->old_oid);
674 new_hex = oid_to_hex(&ref->new_oid);
675 if (!cmds_sent) {
676 packet_buf_write(&req_buf,
677 "%s %s %s%c%s",
678 old_hex, new_hex, ref->name, 0,
679 cap_buf.buf);
680 cmds_sent = 1;
681 } else {
682 packet_buf_write(&req_buf, "%s %s %s",
683 old_hex, new_hex, ref->name);
684 }
685 }
686 }
687
688 if (use_push_options) {
689 struct string_list_item *item;
690
691 packet_buf_flush(&req_buf);
692 for_each_string_list_item(item, args->push_options)
693 packet_buf_write(&req_buf, "%s", item->string);
694 }
695
696 if (args->stateless_rpc) {
697 if (!args->dry_run && (cmds_sent || is_repository_shallow(r))) {
698 packet_buf_flush(&req_buf);
699 send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);
700 }
701 } else {
702 write_or_die(out, req_buf.buf, req_buf.len);
703 packet_flush(out);
704 }
705
706 if (use_sideband && cmds_sent) {
707 memset(&demux, 0, sizeof(demux));
708 demux.proc = sideband_demux;
709 demux.data = fd;
710 demux.out = -1;
711 demux.isolate_sigpipe = 1;
712 if (start_async(&demux))
713 die("send-pack: unable to fork off sideband demultiplexer");
714 in = demux.out;
715 }
716
717 packet_reader_init(&reader, in, NULL, 0,
718 PACKET_READ_CHOMP_NEWLINE |
719 PACKET_READ_DIE_ON_ERR_PACKET);
720
721 if (need_pack_data && cmds_sent) {
722 if (pack_objects(r, out, remote_refs, extra_have, &commons, args) < 0) {
723 if (args->stateless_rpc)
724 close(out);
725 if (git_connection_is_socket(conn))
726 shutdown(fd[0], SHUT_WR);
727
728 /*
729 * Do not even bother with the return value; we know we
730 * are failing, and just want the error() side effects,
731 * as well as marking refs with their remote status (if
732 * we get one).
733 */
734 if (status_report)
735 receive_status(r, &reader, remote_refs);
736
737 if (use_sideband) {
738 close(demux.out);
739 finish_async(&demux);
740 }
741 fd[1] = -1;
742
743 ret = -1;
744 goto out;
745 }
746 if (!args->stateless_rpc)
747 /* Closed by pack_objects() via start_command() */
748 fd[1] = -1;
749 }
750 if (args->stateless_rpc && cmds_sent)
751 packet_flush(out);
752
753 if (status_report && cmds_sent)
754 ret = receive_status(r, &reader, remote_refs);
755 else
756 ret = 0;
757 if (args->stateless_rpc)
758 packet_flush(out);
759
760 if (use_sideband && cmds_sent) {
761 close(demux.out);
762 if (finish_async(&demux)) {
763 error("error in sideband demultiplexer");
764 ret = -1;
765 }
766 }
767
768 if (ret < 0)
769 goto out;
770
771 for (ref = remote_refs; ref; ref = ref->next) {
772 switch (ref->status) {
773 case REF_STATUS_NONE:
774 case REF_STATUS_UPTODATE:
775 case REF_STATUS_OK:
776 break;
777 default:
778 ret = ERROR_SEND_PACK_BAD_REF_STATUS;
779 goto out;
780 }
781 }
782
783 ret = 0;
784
785out:
786 oid_array_clear(&commons);
787 strbuf_release(&req_buf);
788 strbuf_release(&cap_buf);
789 free(push_cert_nonce);
790 return ret;
791}