send-pack.c

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