builtin/receive-pack.c

   1 #include "builtin.h"
   2 #include "repository.h"
   3 #include "config.h"
   4 #include "lockfile.h"
   5 #include "pack.h"
   6 #include "refs.h"
   7 #include "pkt-line.h"
   8 #include "sideband.h"
   9 #include "run-command.h"
  10 #include "exec-cmd.h"
  11 #include "commit.h"
  12 #include "object.h"
  13 #include "remote.h"
  14 #include "connect.h"
  15 #include "transport.h"
  16 #include "string-list.h"
  17 #include "sha1-array.h"
  18 #include "connected.h"
  19 #include "argv-array.h"
  20 #include "version.h"
  21 #include "tag.h"
  22 #include "gpg-interface.h"
  23 #include "sigchain.h"
  24 #include "fsck.h"
  25 #include "tmp-objdir.h"
  26 #include "oidset.h"
  27 #include "packfile.h"
  28 #include "protocol.h"
  29
  30 static const char * const receive_pack_usage[] = {
  31         N_("git receive-pack <git-dir>"),
  32         NULL
  33 };
  34
  35 enum deny_action {
  36         DENY_UNCONFIGURED,
  37         DENY_IGNORE,
  38         DENY_WARN,
  39         DENY_REFUSE,
  40         DENY_UPDATE_INSTEAD
  41 };
  42
  43 static int deny_deletes;
  44 static int deny_non_fast_forwards;
  45 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
  46 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
  47 static int receive_fsck_objects = -1;
  48 static int transfer_fsck_objects = -1;
  49 static struct strbuf fsck_msg_types = STRBUF_INIT;
  50 static int receive_unpack_limit = -1;
  51 static int transfer_unpack_limit = -1;
  52 static int advertise_atomic_push = 1;
  53 static int advertise_push_options;
  54 static int unpack_limit = 100;
  55 static off_t max_input_size;
  56 static int report_status;
  57 static int use_sideband;
  58 static int use_atomic;
  59 static int use_push_options;
  60 static int quiet;
  61 static int prefer_ofs_delta = 1;
  62 static int auto_update_server_info;
  63 static int auto_gc = 1;
  64 static int reject_thin;
  65 static int stateless_rpc;
  66 static const char *service_dir;
  67 static const char *head_name;
  68 static void *head_name_to_free;
  69 static int sent_capabilities;
  70 static int shallow_update;
  71 static const char *alt_shallow_file;
  72 static struct strbuf push_cert = STRBUF_INIT;
  73 static struct object_id push_cert_oid;
  74 static struct signature_check sigcheck;
  75 static const char *push_cert_nonce;
  76 static const char *cert_nonce_seed;
  77
  78 static const char *NONCE_UNSOLICITED = "UNSOLICITED";
  79 static const char *NONCE_BAD = "BAD";
  80 static const char *NONCE_MISSING = "MISSING";
  81 static const char *NONCE_OK = "OK";
  82 static const char *NONCE_SLOP = "SLOP";
  83 static const char *nonce_status;
  84 static long nonce_stamp_slop;
  85 static timestamp_t nonce_stamp_slop_limit;
  86 static struct ref_transaction *transaction;
  87
  88 static enum {
  89         KEEPALIVE_NEVER = 0,
  90         KEEPALIVE_AFTER_NUL,
  91         KEEPALIVE_ALWAYS
  92 } use_keepalive;
  93 static int keepalive_in_sec = 5;
  94
  95 static struct tmp_objdir *tmp_objdir;
  96
  97 static enum deny_action parse_deny_action(const char *var, const char *value)
  98 {
  99         if (value) {
 100                 if (!strcasecmp(value, "ignore"))
 101                         return DENY_IGNORE;
 102                 if (!strcasecmp(value, "warn"))
 103                         return DENY_WARN;
 104                 if (!strcasecmp(value, "refuse"))
 105                         return DENY_REFUSE;
 106                 if (!strcasecmp(value, "updateinstead"))
 107                         return DENY_UPDATE_INSTEAD;
 108         }
 109         if (git_config_bool(var, value))
 110                 return DENY_REFUSE;
 111         return DENY_IGNORE;
 112 }
 113
 114 static int receive_pack_config(const char *var, const char *value, void *cb)
 115 {
 116         int status = parse_hide_refs_config(var, value, "receive");
 117
 118         if (status)
 119                 return status;
 120
 121         if (strcmp(var, "receive.denydeletes") == 0) {
 122                 deny_deletes = git_config_bool(var, value);
 123                 return 0;
 124         }
 125
 126         if (strcmp(var, "receive.denynonfastforwards") == 0) {
 127                 deny_non_fast_forwards = git_config_bool(var, value);
 128                 return 0;
 129         }
 130
 131         if (strcmp(var, "receive.unpacklimit") == 0) {
 132                 receive_unpack_limit = git_config_int(var, value);
 133                 return 0;
 134         }
 135
 136         if (strcmp(var, "transfer.unpacklimit") == 0) {
 137                 transfer_unpack_limit = git_config_int(var, value);
 138                 return 0;
 139         }
 140
 141         if (strcmp(var, "receive.fsck.skiplist") == 0) {
 142                 const char *path;
 143
 144                 if (git_config_pathname(&path, var, value))
 145                         return 1;
 146                 strbuf_addf(&fsck_msg_types, "%cskiplist=%s",
 147                         fsck_msg_types.len ? ',' : '=', path);
 148                 free((char *)path);
 149                 return 0;
 150         }
 151
 152         if (skip_prefix(var, "receive.fsck.", &var)) {
 153                 if (is_valid_msg_type(var, value))
 154                         strbuf_addf(&fsck_msg_types, "%c%s=%s",
 155                                 fsck_msg_types.len ? ',' : '=', var, value);
 156                 else
 157                         warning("Skipping unknown msg id '%s'", var);
 158                 return 0;
 159         }
 160
 161         if (strcmp(var, "receive.fsckobjects") == 0) {
 162                 receive_fsck_objects = git_config_bool(var, value);
 163                 return 0;
 164         }
 165
 166         if (strcmp(var, "transfer.fsckobjects") == 0) {
 167                 transfer_fsck_objects = git_config_bool(var, value);
 168                 return 0;
 169         }
 170
 171         if (!strcmp(var, "receive.denycurrentbranch")) {
 172                 deny_current_branch = parse_deny_action(var, value);
 173                 return 0;
 174         }
 175
 176         if (strcmp(var, "receive.denydeletecurrent") == 0) {
 177                 deny_delete_current = parse_deny_action(var, value);
 178                 return 0;
 179         }
 180
 181         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 182                 prefer_ofs_delta = git_config_bool(var, value);
 183                 return 0;
 184         }
 185
 186         if (strcmp(var, "receive.updateserverinfo") == 0) {
 187                 auto_update_server_info = git_config_bool(var, value);
 188                 return 0;
 189         }
 190
 191         if (strcmp(var, "receive.autogc") == 0) {
 192                 auto_gc = git_config_bool(var, value);
 193                 return 0;
 194         }
 195
 196         if (strcmp(var, "receive.shallowupdate") == 0) {
 197                 shallow_update = git_config_bool(var, value);
 198                 return 0;
 199         }
 200
 201         if (strcmp(var, "receive.certnonceseed") == 0)
 202                 return git_config_string(&cert_nonce_seed, var, value);
 203
 204         if (strcmp(var, "receive.certnonceslop") == 0) {
 205                 nonce_stamp_slop_limit = git_config_ulong(var, value);
 206                 return 0;
 207         }
 208
 209         if (strcmp(var, "receive.advertiseatomic") == 0) {
 210                 advertise_atomic_push = git_config_bool(var, value);
 211                 return 0;
 212         }
 213
 214         if (strcmp(var, "receive.advertisepushoptions") == 0) {
 215                 advertise_push_options = git_config_bool(var, value);
 216                 return 0;
 217         }
 218
 219         if (strcmp(var, "receive.keepalive") == 0) {
 220                 keepalive_in_sec = git_config_int(var, value);
 221                 return 0;
 222         }
 223
 224         if (strcmp(var, "receive.maxinputsize") == 0) {
 225                 max_input_size = git_config_int64(var, value);
 226                 return 0;
 227         }
 228
 229         return git_default_config(var, value, cb);
 230 }
 231
 232 static void show_ref(const char *path, const struct object_id *oid)
 233 {
 234         if (sent_capabilities) {
 235                 packet_write_fmt(1, "%s %s\n", oid_to_hex(oid), path);
 236         } else {
 237                 struct strbuf cap = STRBUF_INIT;
 238
 239                 strbuf_addstr(&cap,
 240                               "report-status delete-refs side-band-64k quiet");
 241                 if (advertise_atomic_push)
 242                         strbuf_addstr(&cap, " atomic");
 243                 if (prefer_ofs_delta)
 244                         strbuf_addstr(&cap, " ofs-delta");
 245                 if (push_cert_nonce)
 246                         strbuf_addf(&cap, " push-cert=%s", push_cert_nonce);
 247                 if (advertise_push_options)
 248                         strbuf_addstr(&cap, " push-options");
 249                 strbuf_addf(&cap, " agent=%s", git_user_agent_sanitized());
 250                 packet_write_fmt(1, "%s %s%c%s\n",
 251                              oid_to_hex(oid), path, 0, cap.buf);
 252                 strbuf_release(&cap);
 253                 sent_capabilities = 1;
 254         }
 255 }
 256
 257 static int show_ref_cb(const char *path_full, const struct object_id *oid,
 258                        int flag, void *data)
 259 {
 260         struct oidset *seen = data;
 261         const char *path = strip_namespace(path_full);
 262
 263         if (ref_is_hidden(path, path_full))
 264                 return 0;
 265
 266         /*
 267          * Advertise refs outside our current namespace as ".have"
 268          * refs, so that the client can use them to minimize data
 269          * transfer but will otherwise ignore them.
 270          */
 271         if (!path) {
 272                 if (oidset_insert(seen, oid))
 273                         return 0;
 274                 path = ".have";
 275         } else {
 276                 oidset_insert(seen, oid);
 277         }
 278         show_ref(path, oid);
 279         return 0;
 280 }
 281
 282 static void show_one_alternate_ref(const char *refname,
 283                                    const struct object_id *oid,
 284                                    void *data)
 285 {
 286         struct oidset *seen = data;
 287
 288         if (oidset_insert(seen, oid))
 289                 return;
 290
 291         show_ref(".have", oid);
 292 }
 293
 294 static void write_head_info(void)
 295 {
 296         static struct oidset seen = OIDSET_INIT;
 297
 298         for_each_ref(show_ref_cb, &seen);
 299         for_each_alternate_ref(show_one_alternate_ref, &seen);
 300         oidset_clear(&seen);
 301         if (!sent_capabilities)
 302                 show_ref("capabilities^{}", &null_oid);
 303
 304         advertise_shallow_grafts(1);
 305
 306         /* EOF */
 307         packet_flush(1);
 308 }
 309
 310 struct command {
 311         struct command *next;
 312         const char *error_string;
 313         unsigned int skip_update:1,
 314                      did_not_exist:1;
 315         int index;
 316         struct object_id old_oid;
 317         struct object_id new_oid;
 318         char ref_name[FLEX_ARRAY]; /* more */
 319 };
 320
 321 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 322 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 323
 324 static void report_message(const char *prefix, const char *err, va_list params)
 325 {
 326         int sz;
 327         char msg[4096];
 328
 329         sz = xsnprintf(msg, sizeof(msg), "%s", prefix);
 330         sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 331         if (sz > (sizeof(msg) - 1))
 332                 sz = sizeof(msg) - 1;
 333         msg[sz++] = '\n';
 334
 335         if (use_sideband)
 336                 send_sideband(1, 2, msg, sz, use_sideband);
 337         else
 338                 xwrite(2, msg, sz);
 339 }
 340
 341 static void rp_warning(const char *err, ...)
 342 {
 343         va_list params;
 344         va_start(params, err);
 345         report_message("warning: ", err, params);
 346         va_end(params);
 347 }
 348
 349 static void rp_error(const char *err, ...)
 350 {
 351         va_list params;
 352         va_start(params, err);
 353         report_message("error: ", err, params);
 354         va_end(params);
 355 }
 356
 357 static int copy_to_sideband(int in, int out, void *arg)
 358 {
 359         char data[128];
 360         int keepalive_active = 0;
 361
 362         if (keepalive_in_sec <= 0)
 363                 use_keepalive = KEEPALIVE_NEVER;
 364         if (use_keepalive == KEEPALIVE_ALWAYS)
 365                 keepalive_active = 1;
 366
 367         while (1) {
 368                 ssize_t sz;
 369
 370                 if (keepalive_active) {
 371                         struct pollfd pfd;
 372                         int ret;
 373
 374                         pfd.fd = in;
 375                         pfd.events = POLLIN;
 376                         ret = poll(&pfd, 1, 1000 * keepalive_in_sec);
 377
 378                         if (ret < 0) {
 379                                 if (errno == EINTR)
 380                                         continue;
 381                                 else
 382                                         break;
 383                         } else if (ret == 0) {
 384                                 /* no data; send a keepalive packet */
 385                                 static const char buf[] = "0005\1";
 386                                 write_or_die(1, buf, sizeof(buf) - 1);
 387                                 continue;
 388                         } /* else there is actual data to read */
 389                 }
 390
 391                 sz = xread(in, data, sizeof(data));
 392                 if (sz <= 0)
 393                         break;
 394
 395                 if (use_keepalive == KEEPALIVE_AFTER_NUL && !keepalive_active) {
 396                         const char *p = memchr(data, '\0', sz);
 397                         if (p) {
 398                                 /*
 399                                  * The NUL tells us to start sending keepalives. Make
 400                                  * sure we send any other data we read along
 401                                  * with it.
 402                                  */
 403                                 keepalive_active = 1;
 404                                 send_sideband(1, 2, data, p - data, use_sideband);
 405                                 send_sideband(1, 2, p + 1, sz - (p - data + 1), use_sideband);
 406                                 continue;
 407                         }
 408                 }
 409
 410                 /*
 411                  * Either we're not looking for a NUL signal, or we didn't see
 412                  * it yet; just pass along the data.
 413                  */
 414                 send_sideband(1, 2, data, sz, use_sideband);
 415         }
 416         close(in);
 417         return 0;
 418 }
 419
 420 #define HMAC_BLOCK_SIZE 64
 421
 422 static void hmac_sha1(unsigned char *out,
 423                       const char *key_in, size_t key_len,
 424                       const char *text, size_t text_len)
 425 {
 426         unsigned char key[HMAC_BLOCK_SIZE];
 427         unsigned char k_ipad[HMAC_BLOCK_SIZE];
 428         unsigned char k_opad[HMAC_BLOCK_SIZE];
 429         int i;
 430         git_SHA_CTX ctx;
 431
 432         /* RFC 2104 2. (1) */
 433         memset(key, '\0', HMAC_BLOCK_SIZE);
 434         if (HMAC_BLOCK_SIZE < key_len) {
 435                 git_SHA1_Init(&ctx);
 436                 git_SHA1_Update(&ctx, key_in, key_len);
 437                 git_SHA1_Final(key, &ctx);
 438         } else {
 439                 memcpy(key, key_in, key_len);
 440         }
 441
 442         /* RFC 2104 2. (2) & (5) */
 443         for (i = 0; i < sizeof(key); i++) {
 444                 k_ipad[i] = key[i] ^ 0x36;
 445                 k_opad[i] = key[i] ^ 0x5c;
 446         }
 447
 448         /* RFC 2104 2. (3) & (4) */
 449         git_SHA1_Init(&ctx);
 450         git_SHA1_Update(&ctx, k_ipad, sizeof(k_ipad));
 451         git_SHA1_Update(&ctx, text, text_len);
 452         git_SHA1_Final(out, &ctx);
 453
 454         /* RFC 2104 2. (6) & (7) */
 455         git_SHA1_Init(&ctx);
 456         git_SHA1_Update(&ctx, k_opad, sizeof(k_opad));
 457         git_SHA1_Update(&ctx, out, GIT_SHA1_RAWSZ);
 458         git_SHA1_Final(out, &ctx);
 459 }
 460
 461 static char *prepare_push_cert_nonce(const char *path, timestamp_t stamp)
 462 {
 463         struct strbuf buf = STRBUF_INIT;
 464         unsigned char sha1[GIT_SHA1_RAWSZ];
 465
 466         strbuf_addf(&buf, "%s:%"PRItime, path, stamp);
 467         hmac_sha1(sha1, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));;
 468         strbuf_release(&buf);
 469
 470         /* RFC 2104 5. HMAC-SHA1-80 */
 471         strbuf_addf(&buf, "%"PRItime"-%.*s", stamp, GIT_SHA1_HEXSZ, sha1_to_hex(sha1));
 472         return strbuf_detach(&buf, NULL);
 473 }
 474
 475 /*
 476  * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
 477  * after dropping "_commit" from its name and possibly moving it out
 478  * of commit.c
 479  */
 480 static char *find_header(const char *msg, size_t len, const char *key,
 481                          const char **next_line)
 482 {
 483         int key_len = strlen(key);
 484         const char *line = msg;
 485
 486         while (line && line < msg + len) {
 487                 const char *eol = strchrnul(line, '\n');
 488
 489                 if ((msg + len <= eol) || line == eol)
 490                         return NULL;
 491                 if (line + key_len < eol &&
 492                     !memcmp(line, key, key_len) && line[key_len] == ' ') {
 493                         int offset = key_len + 1;
 494                         if (next_line)
 495                                 *next_line = *eol ? eol + 1 : eol;
 496                         return xmemdupz(line + offset, (eol - line) - offset);
 497                 }
 498                 line = *eol ? eol + 1 : NULL;
 499         }
 500         return NULL;
 501 }
 502
 503 static const char *check_nonce(const char *buf, size_t len)
 504 {
 505         char *nonce = find_header(buf, len, "nonce", NULL);
 506         timestamp_t stamp, ostamp;
 507         char *bohmac, *expect = NULL;
 508         const char *retval = NONCE_BAD;
 509
 510         if (!nonce) {
 511                 retval = NONCE_MISSING;
 512                 goto leave;
 513         } else if (!push_cert_nonce) {
 514                 retval = NONCE_UNSOLICITED;
 515                 goto leave;
 516         } else if (!strcmp(push_cert_nonce, nonce)) {
 517                 retval = NONCE_OK;
 518                 goto leave;
 519         }
 520
 521         if (!stateless_rpc) {
 522                 /* returned nonce MUST match what we gave out earlier */
 523                 retval = NONCE_BAD;
 524                 goto leave;
 525         }
 526
 527         /*
 528          * In stateless mode, we may be receiving a nonce issued by
 529          * another instance of the server that serving the same
 530          * repository, and the timestamps may not match, but the
 531          * nonce-seed and dir should match, so we can recompute and
 532          * report the time slop.
 533          *
 534          * In addition, when a nonce issued by another instance has
 535          * timestamp within receive.certnonceslop seconds, we pretend
 536          * as if we issued that nonce when reporting to the hook.
 537          */
 538
 539         /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
 540         if (*nonce <= '0' || '9' < *nonce) {
 541                 retval = NONCE_BAD;
 542                 goto leave;
 543         }
 544         stamp = parse_timestamp(nonce, &bohmac, 10);
 545         if (bohmac == nonce || bohmac[0] != '-') {
 546                 retval = NONCE_BAD;
 547                 goto leave;
 548         }
 549
 550         expect = prepare_push_cert_nonce(service_dir, stamp);
 551         if (strcmp(expect, nonce)) {
 552                 /* Not what we would have signed earlier */
 553                 retval = NONCE_BAD;
 554                 goto leave;
 555         }
 556
 557         /*
 558          * By how many seconds is this nonce stale?  Negative value
 559          * would mean it was issued by another server with its clock
 560          * skewed in the future.
 561          */
 562         ostamp = parse_timestamp(push_cert_nonce, NULL, 10);
 563         nonce_stamp_slop = (long)ostamp - (long)stamp;
 564
 565         if (nonce_stamp_slop_limit &&
 566             labs(nonce_stamp_slop) <= nonce_stamp_slop_limit) {
 567                 /*
 568                  * Pretend as if the received nonce (which passes the
 569                  * HMAC check, so it is not a forged by third-party)
 570                  * is what we issued.
 571                  */
 572                 free((void *)push_cert_nonce);
 573                 push_cert_nonce = xstrdup(nonce);
 574                 retval = NONCE_OK;
 575         } else {
 576                 retval = NONCE_SLOP;
 577         }
 578
 579 leave:
 580         free(nonce);
 581         free(expect);
 582         return retval;
 583 }
 584
 585 /*
 586  * Return 1 if there is no push_cert or if the push options in push_cert are
 587  * the same as those in the argument; 0 otherwise.
 588  */
 589 static int check_cert_push_options(const struct string_list *push_options)
 590 {
 591         const char *buf = push_cert.buf;
 592         int len = push_cert.len;
 593
 594         char *option;
 595         const char *next_line;
 596         int options_seen = 0;
 597
 598         int retval = 1;
 599
 600         if (!len)
 601                 return 1;
 602
 603         while ((option = find_header(buf, len, "push-option", &next_line))) {
 604                 len -= (next_line - buf);
 605                 buf = next_line;
 606                 options_seen++;
 607                 if (options_seen > push_options->nr
 608                     || strcmp(option,
 609                               push_options->items[options_seen - 1].string)) {
 610                         retval = 0;
 611                         goto leave;
 612                 }
 613                 free(option);
 614         }
 615
 616         if (options_seen != push_options->nr)
 617                 retval = 0;
 618
 619 leave:
 620         free(option);
 621         return retval;
 622 }
 623
 624 static void prepare_push_cert_sha1(struct child_process *proc)
 625 {
 626         static int already_done;
 627
 628         if (!push_cert.len)
 629                 return;
 630
 631         if (!already_done) {
 632                 struct strbuf gpg_output = STRBUF_INIT;
 633                 struct strbuf gpg_status = STRBUF_INIT;
 634                 int bogs /* beginning_of_gpg_sig */;
 635
 636                 already_done = 1;
 637                 if (write_object_file(push_cert.buf, push_cert.len, "blob",
 638                                       &push_cert_oid))
 639                         oidclr(&push_cert_oid);
 640
 641                 memset(&sigcheck, '\0', sizeof(sigcheck));
 642                 sigcheck.result = 'N';
 643
 644                 bogs = parse_signature(push_cert.buf, push_cert.len);
 645                 if (verify_signed_buffer(push_cert.buf, bogs,
 646                                          push_cert.buf + bogs, push_cert.len - bogs,
 647                                          &gpg_output, &gpg_status) < 0) {
 648                         ; /* error running gpg */
 649                 } else {
 650                         sigcheck.payload = push_cert.buf;
 651                         sigcheck.gpg_output = gpg_output.buf;
 652                         sigcheck.gpg_status = gpg_status.buf;
 653                         parse_gpg_output(&sigcheck);
 654                 }
 655
 656                 strbuf_release(&gpg_output);
 657                 strbuf_release(&gpg_status);
 658                 nonce_status = check_nonce(push_cert.buf, bogs);
 659         }
 660         if (!is_null_oid(&push_cert_oid)) {
 661                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT=%s",
 662                                  oid_to_hex(&push_cert_oid));
 663                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_SIGNER=%s",
 664                                  sigcheck.signer ? sigcheck.signer : "");
 665                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_KEY=%s",
 666                                  sigcheck.key ? sigcheck.key : "");
 667                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_STATUS=%c",
 668                                  sigcheck.result);
 669                 if (push_cert_nonce) {
 670                         argv_array_pushf(&proc->env_array,
 671                                          "GIT_PUSH_CERT_NONCE=%s",
 672                                          push_cert_nonce);
 673                         argv_array_pushf(&proc->env_array,
 674                                          "GIT_PUSH_CERT_NONCE_STATUS=%s",
 675                                          nonce_status);
 676                         if (nonce_status == NONCE_SLOP)
 677                                 argv_array_pushf(&proc->env_array,
 678                                                  "GIT_PUSH_CERT_NONCE_SLOP=%ld",
 679                                                  nonce_stamp_slop);
 680                 }
 681         }
 682 }
 683
 684 struct receive_hook_feed_state {
 685         struct command *cmd;
 686         int skip_broken;
 687         struct strbuf buf;
 688         const struct string_list *push_options;
 689 };
 690
 691 typedef int (*feed_fn)(void *, const char **, size_t *);
 692 static int run_and_feed_hook(const char *hook_name, feed_fn feed,
 693                              struct receive_hook_feed_state *feed_state)
 694 {
 695         struct child_process proc = CHILD_PROCESS_INIT;
 696         struct async muxer;
 697         const char *argv[2];
 698         int code;
 699
 700         argv[0] = find_hook(hook_name);
 701         if (!argv[0])
 702                 return 0;
 703
 704         argv[1] = NULL;
 705
 706         proc.argv = argv;
 707         proc.in = -1;
 708         proc.stdout_to_stderr = 1;
 709         if (feed_state->push_options) {
 710                 int i;
 711                 for (i = 0; i < feed_state->push_options->nr; i++)
 712                         argv_array_pushf(&proc.env_array,
 713                                 "GIT_PUSH_OPTION_%d=%s", i,
 714                                 feed_state->push_options->items[i].string);
 715                 argv_array_pushf(&proc.env_array, "GIT_PUSH_OPTION_COUNT=%d",
 716                                  feed_state->push_options->nr);
 717         } else
 718                 argv_array_pushf(&proc.env_array, "GIT_PUSH_OPTION_COUNT");
 719
 720         if (tmp_objdir)
 721                 argv_array_pushv(&proc.env_array, tmp_objdir_env(tmp_objdir));
 722
 723         if (use_sideband) {
 724                 memset(&muxer, 0, sizeof(muxer));
 725                 muxer.proc = copy_to_sideband;
 726                 muxer.in = -1;
 727                 code = start_async(&muxer);
 728                 if (code)
 729                         return code;
 730                 proc.err = muxer.in;
 731         }
 732
 733         prepare_push_cert_sha1(&proc);
 734
 735         code = start_command(&proc);
 736         if (code) {
 737                 if (use_sideband)
 738                         finish_async(&muxer);
 739                 return code;
 740         }
 741
 742         sigchain_push(SIGPIPE, SIG_IGN);
 743
 744         while (1) {
 745                 const char *buf;
 746                 size_t n;
 747                 if (feed(feed_state, &buf, &n))
 748                         break;
 749                 if (write_in_full(proc.in, buf, n) < 0)
 750                         break;
 751         }
 752         close(proc.in);
 753         if (use_sideband)
 754                 finish_async(&muxer);
 755
 756         sigchain_pop(SIGPIPE);
 757
 758         return finish_command(&proc);
 759 }
 760
 761 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 762 {
 763         struct receive_hook_feed_state *state = state_;
 764         struct command *cmd = state->cmd;
 765
 766         while (cmd &&
 767                state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 768                 cmd = cmd->next;
 769         if (!cmd)
 770                 return -1; /* EOF */
 771         strbuf_reset(&state->buf);
 772         strbuf_addf(&state->buf, "%s %s %s\n",
 773                     oid_to_hex(&cmd->old_oid), oid_to_hex(&cmd->new_oid),
 774                     cmd->ref_name);
 775         state->cmd = cmd->next;
 776         if (bufp) {
 777                 *bufp = state->buf.buf;
 778                 *sizep = state->buf.len;
 779         }
 780         return 0;
 781 }
 782
 783 static int run_receive_hook(struct command *commands,
 784                             const char *hook_name,
 785                             int skip_broken,
 786                             const struct string_list *push_options)
 787 {
 788         struct receive_hook_feed_state state;
 789         int status;
 790
 791         strbuf_init(&state.buf, 0);
 792         state.cmd = commands;
 793         state.skip_broken = skip_broken;
 794         if (feed_receive_hook(&state, NULL, NULL))
 795                 return 0;
 796         state.cmd = commands;
 797         state.push_options = push_options;
 798         status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 799         strbuf_release(&state.buf);
 800         return status;
 801 }
 802
 803 static int run_update_hook(struct command *cmd)
 804 {
 805         const char *argv[5];
 806         struct child_process proc = CHILD_PROCESS_INIT;
 807         int code;
 808
 809         argv[0] = find_hook("update");
 810         if (!argv[0])
 811                 return 0;
 812
 813         argv[1] = cmd->ref_name;
 814         argv[2] = oid_to_hex(&cmd->old_oid);
 815         argv[3] = oid_to_hex(&cmd->new_oid);
 816         argv[4] = NULL;
 817
 818         proc.no_stdin = 1;
 819         proc.stdout_to_stderr = 1;
 820         proc.err = use_sideband ? -1 : 0;
 821         proc.argv = argv;
 822
 823         code = start_command(&proc);
 824         if (code)
 825                 return code;
 826         if (use_sideband)
 827                 copy_to_sideband(proc.err, -1, NULL);
 828         return finish_command(&proc);
 829 }
 830
 831 static int is_ref_checked_out(const char *ref)
 832 {
 833         if (is_bare_repository())
 834                 return 0;
 835
 836         if (!head_name)
 837                 return 0;
 838         return !strcmp(head_name, ref);
 839 }
 840
 841 static char *refuse_unconfigured_deny_msg =
 842         N_("By default, updating the current branch in a non-bare repository\n"
 843            "is denied, because it will make the index and work tree inconsistent\n"
 844            "with what you pushed, and will require 'git reset --hard' to match\n"
 845            "the work tree to HEAD.\n"
 846            "\n"
 847            "You can set the 'receive.denyCurrentBranch' configuration variable\n"
 848            "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
 849            "its current branch; however, this is not recommended unless you\n"
 850            "arranged to update its work tree to match what you pushed in some\n"
 851            "other way.\n"
 852            "\n"
 853            "To squelch this message and still keep the default behaviour, set\n"
 854            "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
 855
 856 static void refuse_unconfigured_deny(void)
 857 {
 858         rp_error("%s", _(refuse_unconfigured_deny_msg));
 859 }
 860
 861 static char *refuse_unconfigured_deny_delete_current_msg =
 862         N_("By default, deleting the current branch is denied, because the next\n"
 863            "'git clone' won't result in any file checked out, causing confusion.\n"
 864            "\n"
 865            "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
 866            "'warn' or 'ignore' in the remote repository to allow deleting the\n"
 867            "current branch, with or without a warning message.\n"
 868            "\n"
 869            "To squelch this message, you can set it to 'refuse'.");
 870
 871 static void refuse_unconfigured_deny_delete_current(void)
 872 {
 873         rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg));
 874 }
 875
 876 static int command_singleton_iterator(void *cb_data, struct object_id *oid);
 877 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
 878 {
 879         struct lock_file shallow_lock = LOCK_INIT;
 880         struct oid_array extra = OID_ARRAY_INIT;
 881         struct check_connected_options opt = CHECK_CONNECTED_INIT;
 882         uint32_t mask = 1 << (cmd->index % 32);
 883         int i;
 884
 885         trace_printf_key(&trace_shallow,
 886                          "shallow: update_shallow_ref %s\n", cmd->ref_name);
 887         for (i = 0; i < si->shallow->nr; i++)
 888                 if (si->used_shallow[i] &&
 889                     (si->used_shallow[i][cmd->index / 32] & mask) &&
 890                     !delayed_reachability_test(si, i))
 891                         oid_array_append(&extra, &si->shallow->oid[i]);
 892
 893         opt.env = tmp_objdir_env(tmp_objdir);
 894         setup_alternate_shallow(&shallow_lock, &opt.shallow_file, &extra);
 895         if (check_connected(command_singleton_iterator, cmd, &opt)) {
 896                 rollback_lock_file(&shallow_lock);
 897                 oid_array_clear(&extra);
 898                 return -1;
 899         }
 900
 901         commit_lock_file(&shallow_lock);
 902
 903         /*
 904          * Make sure setup_alternate_shallow() for the next ref does
 905          * not lose these new roots..
 906          */
 907         for (i = 0; i < extra.nr; i++)
 908                 register_shallow(&extra.oid[i]);
 909
 910         si->shallow_ref[cmd->index] = 0;
 911         oid_array_clear(&extra);
 912         return 0;
 913 }
 914
 915 /*
 916  * NEEDSWORK: we should consolidate various implementions of "are we
 917  * on an unborn branch?" test into one, and make the unified one more
 918  * robust. !get_sha1() based check used here and elsewhere would not
 919  * allow us to tell an unborn branch from corrupt ref, for example.
 920  * For the purpose of fixing "deploy-to-update does not work when
 921  * pushing into an empty repository" issue, this should suffice for
 922  * now.
 923  */
 924 static int head_has_history(void)
 925 {
 926         struct object_id oid;
 927
 928         return !get_oid("HEAD", &oid);
 929 }
 930
 931 static const char *push_to_deploy(unsigned char *sha1,
 932                                   struct argv_array *env,
 933                                   const char *work_tree)
 934 {
 935         const char *update_refresh[] = {
 936                 "update-index", "-q", "--ignore-submodules", "--refresh", NULL
 937         };
 938         const char *diff_files[] = {
 939                 "diff-files", "--quiet", "--ignore-submodules", "--", NULL
 940         };
 941         const char *diff_index[] = {
 942                 "diff-index", "--quiet", "--cached", "--ignore-submodules",
 943                 NULL, "--", NULL
 944         };
 945         const char *read_tree[] = {
 946                 "read-tree", "-u", "-m", NULL, NULL
 947         };
 948         struct child_process child = CHILD_PROCESS_INIT;
 949
 950         child.argv = update_refresh;
 951         child.env = env->argv;
 952         child.dir = work_tree;
 953         child.no_stdin = 1;
 954         child.stdout_to_stderr = 1;
 955         child.git_cmd = 1;
 956         if (run_command(&child))
 957                 return "Up-to-date check failed";
 958
 959         /* run_command() does not clean up completely; reinitialize */
 960         child_process_init(&child);
 961         child.argv = diff_files;
 962         child.env = env->argv;
 963         child.dir = work_tree;
 964         child.no_stdin = 1;
 965         child.stdout_to_stderr = 1;
 966         child.git_cmd = 1;
 967         if (run_command(&child))
 968                 return "Working directory has unstaged changes";
 969
 970         /* diff-index with either HEAD or an empty tree */
 971         diff_index[4] = head_has_history() ? "HEAD" : empty_tree_oid_hex();
 972
 973         child_process_init(&child);
 974         child.argv = diff_index;
 975         child.env = env->argv;
 976         child.no_stdin = 1;
 977         child.no_stdout = 1;
 978         child.stdout_to_stderr = 0;
 979         child.git_cmd = 1;
 980         if (run_command(&child))
 981                 return "Working directory has staged changes";
 982
 983         read_tree[3] = sha1_to_hex(sha1);
 984         child_process_init(&child);
 985         child.argv = read_tree;
 986         child.env = env->argv;
 987         child.dir = work_tree;
 988         child.no_stdin = 1;
 989         child.no_stdout = 1;
 990         child.stdout_to_stderr = 0;
 991         child.git_cmd = 1;
 992         if (run_command(&child))
 993                 return "Could not update working tree to new HEAD";
 994
 995         return NULL;
 996 }
 997
 998 static const char *push_to_checkout_hook = "push-to-checkout";
 999
1000 static const char *push_to_checkout(unsigned char *sha1,
1001                                     struct argv_array *env,
1002                                     const char *work_tree)
1003 {
1004         argv_array_pushf(env, "GIT_WORK_TREE=%s", absolute_path(work_tree));
1005         if (run_hook_le(env->argv, push_to_checkout_hook,
1006                         sha1_to_hex(sha1), NULL))
1007                 return "push-to-checkout hook declined";
1008         else
1009                 return NULL;
1010 }
1011
1012 static const char *update_worktree(unsigned char *sha1)
1013 {
1014         const char *retval;
1015         const char *work_tree = git_work_tree_cfg ? git_work_tree_cfg : "..";
1016         struct argv_array env = ARGV_ARRAY_INIT;
1017
1018         if (is_bare_repository())
1019                 return "denyCurrentBranch = updateInstead needs a worktree";
1020
1021         argv_array_pushf(&env, "GIT_DIR=%s", absolute_path(get_git_dir()));
1022
1023         if (!find_hook(push_to_checkout_hook))
1024                 retval = push_to_deploy(sha1, &env, work_tree);
1025         else
1026                 retval = push_to_checkout(sha1, &env, work_tree);
1027
1028         argv_array_clear(&env);
1029         return retval;
1030 }
1031
1032 static const char *update(struct command *cmd, struct shallow_info *si)
1033 {
1034         const char *name = cmd->ref_name;
1035         struct strbuf namespaced_name_buf = STRBUF_INIT;
1036         static char *namespaced_name;
1037         const char *ret;
1038         struct object_id *old_oid = &cmd->old_oid;
1039         struct object_id *new_oid = &cmd->new_oid;
1040
1041         /* only refs/... are allowed */
1042         if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
1043                 rp_error("refusing to create funny ref '%s' remotely", name);
1044                 return "funny refname";
1045         }
1046
1047         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
1048         free(namespaced_name);
1049         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
1050
1051         if (is_ref_checked_out(namespaced_name)) {
1052                 switch (deny_current_branch) {
1053                 case DENY_IGNORE:
1054                         break;
1055                 case DENY_WARN:
1056                         rp_warning("updating the current branch");
1057                         break;
1058                 case DENY_REFUSE:
1059                 case DENY_UNCONFIGURED:
1060                         rp_error("refusing to update checked out branch: %s", name);
1061                         if (deny_current_branch == DENY_UNCONFIGURED)
1062                                 refuse_unconfigured_deny();
1063                         return "branch is currently checked out";
1064                 case DENY_UPDATE_INSTEAD:
1065                         ret = update_worktree(new_oid->hash);
1066                         if (ret)
1067                                 return ret;
1068                         break;
1069                 }
1070         }
1071
1072         if (!is_null_oid(new_oid) && !has_object_file(new_oid)) {
1073                 error("unpack should have generated %s, "
1074                       "but I can't find it!", oid_to_hex(new_oid));
1075                 return "bad pack";
1076         }
1077
1078         if (!is_null_oid(old_oid) && is_null_oid(new_oid)) {
1079                 if (deny_deletes && starts_with(name, "refs/heads/")) {
1080                         rp_error("denying ref deletion for %s", name);
1081                         return "deletion prohibited";
1082                 }
1083
1084                 if (head_name && !strcmp(namespaced_name, head_name)) {
1085                         switch (deny_delete_current) {
1086                         case DENY_IGNORE:
1087                                 break;
1088                         case DENY_WARN:
1089                                 rp_warning("deleting the current branch");
1090                                 break;
1091                         case DENY_REFUSE:
1092                         case DENY_UNCONFIGURED:
1093                         case DENY_UPDATE_INSTEAD:
1094                                 if (deny_delete_current == DENY_UNCONFIGURED)
1095                                         refuse_unconfigured_deny_delete_current();
1096                                 rp_error("refusing to delete the current branch: %s", name);
1097                                 return "deletion of the current branch prohibited";
1098                         default:
1099                                 return "Invalid denyDeleteCurrent setting";
1100                         }
1101                 }
1102         }
1103
1104         if (deny_non_fast_forwards && !is_null_oid(new_oid) &&
1105             !is_null_oid(old_oid) &&
1106             starts_with(name, "refs/heads/")) {
1107                 struct object *old_object, *new_object;
1108                 struct commit *old_commit, *new_commit;
1109
1110                 old_object = parse_object(old_oid);
1111                 new_object = parse_object(new_oid);
1112
1113                 if (!old_object || !new_object ||
1114                     old_object->type != OBJ_COMMIT ||
1115                     new_object->type != OBJ_COMMIT) {
1116                         error("bad sha1 objects for %s", name);
1117                         return "bad ref";
1118                 }
1119                 old_commit = (struct commit *)old_object;
1120                 new_commit = (struct commit *)new_object;
1121                 if (!in_merge_bases(old_commit, new_commit)) {
1122                         rp_error("denying non-fast-forward %s"
1123                                  " (you should pull first)", name);
1124                         return "non-fast-forward";
1125                 }
1126         }
1127         if (run_update_hook(cmd)) {
1128                 rp_error("hook declined to update %s", name);
1129                 return "hook declined";
1130         }
1131
1132         if (is_null_oid(new_oid)) {
1133                 struct strbuf err = STRBUF_INIT;
1134                 if (!parse_object(old_oid)) {
1135                         old_oid = NULL;
1136                         if (ref_exists(name)) {
1137                                 rp_warning("Allowing deletion of corrupt ref.");
1138                         } else {
1139                                 rp_warning("Deleting a non-existent ref.");
1140                                 cmd->did_not_exist = 1;
1141                         }
1142                 }
1143                 if (ref_transaction_delete(transaction,
1144                                            namespaced_name,
1145                                            old_oid,
1146                                            0, "push", &err)) {
1147                         rp_error("%s", err.buf);
1148                         strbuf_release(&err);
1149                         return "failed to delete";
1150                 }
1151                 strbuf_release(&err);
1152                 return NULL; /* good */
1153         }
1154         else {
1155                 struct strbuf err = STRBUF_INIT;
1156                 if (shallow_update && si->shallow_ref[cmd->index] &&
1157                     update_shallow_ref(cmd, si))
1158                         return "shallow error";
1159
1160                 if (ref_transaction_update(transaction,
1161                                            namespaced_name,
1162                                            new_oid, old_oid,
1163                                            0, "push",
1164                                            &err)) {
1165                         rp_error("%s", err.buf);
1166                         strbuf_release(&err);
1167
1168                         return "failed to update ref";
1169                 }
1170                 strbuf_release(&err);
1171
1172                 return NULL; /* good */
1173         }
1174 }
1175
1176 static void run_update_post_hook(struct command *commands)
1177 {
1178         struct command *cmd;
1179         struct child_process proc = CHILD_PROCESS_INIT;
1180         const char *hook;
1181
1182         hook = find_hook("post-update");
1183         if (!hook)
1184                 return;
1185
1186         for (cmd = commands; cmd; cmd = cmd->next) {
1187                 if (cmd->error_string || cmd->did_not_exist)
1188                         continue;
1189                 if (!proc.args.argc)
1190                         argv_array_push(&proc.args, hook);
1191                 argv_array_push(&proc.args, cmd->ref_name);
1192         }
1193         if (!proc.args.argc)
1194                 return;
1195
1196         proc.no_stdin = 1;
1197         proc.stdout_to_stderr = 1;
1198         proc.err = use_sideband ? -1 : 0;
1199
1200         if (!start_command(&proc)) {
1201                 if (use_sideband)
1202                         copy_to_sideband(proc.err, -1, NULL);
1203                 finish_command(&proc);
1204         }
1205 }
1206
1207 static void check_aliased_update(struct command *cmd, struct string_list *list)
1208 {
1209         struct strbuf buf = STRBUF_INIT;
1210         const char *dst_name;
1211         struct string_list_item *item;
1212         struct command *dst_cmd;
1213         int flag;
1214
1215         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
1216         dst_name = resolve_ref_unsafe(buf.buf, 0, NULL, &flag);
1217         strbuf_release(&buf);
1218
1219         if (!(flag & REF_ISSYMREF))
1220                 return;
1221
1222         if (!dst_name) {
1223                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
1224                 cmd->skip_update = 1;
1225                 cmd->error_string = "broken symref";
1226                 return;
1227         }
1228         dst_name = strip_namespace(dst_name);
1229
1230         if ((item = string_list_lookup(list, dst_name)) == NULL)
1231                 return;
1232
1233         cmd->skip_update = 1;
1234
1235         dst_cmd = (struct command *) item->util;
1236
1237         if (!oidcmp(&cmd->old_oid, &dst_cmd->old_oid) &&
1238             !oidcmp(&cmd->new_oid, &dst_cmd->new_oid))
1239                 return;
1240
1241         dst_cmd->skip_update = 1;
1242
1243         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1244                  " its target '%s' (%s..%s)",
1245                  cmd->ref_name,
1246                  find_unique_abbrev(&cmd->old_oid, DEFAULT_ABBREV),
1247                  find_unique_abbrev(&cmd->new_oid, DEFAULT_ABBREV),
1248                  dst_cmd->ref_name,
1249                  find_unique_abbrev(&dst_cmd->old_oid, DEFAULT_ABBREV),
1250                  find_unique_abbrev(&dst_cmd->new_oid, DEFAULT_ABBREV));
1251
1252         cmd->error_string = dst_cmd->error_string =
1253                 "inconsistent aliased update";
1254 }
1255
1256 static void check_aliased_updates(struct command *commands)
1257 {
1258         struct command *cmd;
1259         struct string_list ref_list = STRING_LIST_INIT_NODUP;
1260
1261         for (cmd = commands; cmd; cmd = cmd->next) {
1262                 struct string_list_item *item =
1263                         string_list_append(&ref_list, cmd->ref_name);
1264                 item->util = (void *)cmd;
1265         }
1266         string_list_sort(&ref_list);
1267
1268         for (cmd = commands; cmd; cmd = cmd->next) {
1269                 if (!cmd->error_string)
1270                         check_aliased_update(cmd, &ref_list);
1271         }
1272
1273         string_list_clear(&ref_list, 0);
1274 }
1275
1276 static int command_singleton_iterator(void *cb_data, struct object_id *oid)
1277 {
1278         struct command **cmd_list = cb_data;
1279         struct command *cmd = *cmd_list;
1280
1281         if (!cmd || is_null_oid(&cmd->new_oid))
1282                 return -1; /* end of list */
1283         *cmd_list = NULL; /* this returns only one */
1284         oidcpy(oid, &cmd->new_oid);
1285         return 0;
1286 }
1287
1288 static void set_connectivity_errors(struct command *commands,
1289                                     struct shallow_info *si)
1290 {
1291         struct command *cmd;
1292
1293         for (cmd = commands; cmd; cmd = cmd->next) {
1294                 struct command *singleton = cmd;
1295                 struct check_connected_options opt = CHECK_CONNECTED_INIT;
1296
1297                 if (shallow_update && si->shallow_ref[cmd->index])
1298                         /* to be checked in update_shallow_ref() */
1299                         continue;
1300
1301                 opt.env = tmp_objdir_env(tmp_objdir);
1302                 if (!check_connected(command_singleton_iterator, &singleton,
1303                                      &opt))
1304                         continue;
1305
1306                 cmd->error_string = "missing necessary objects";
1307         }
1308 }
1309
1310 struct iterate_data {
1311         struct command *cmds;
1312         struct shallow_info *si;
1313 };
1314
1315 static int iterate_receive_command_list(void *cb_data, struct object_id *oid)
1316 {
1317         struct iterate_data *data = cb_data;
1318         struct command **cmd_list = &data->cmds;
1319         struct command *cmd = *cmd_list;
1320
1321         for (; cmd; cmd = cmd->next) {
1322                 if (shallow_update && data->si->shallow_ref[cmd->index])
1323                         /* to be checked in update_shallow_ref() */
1324                         continue;
1325                 if (!is_null_oid(&cmd->new_oid) && !cmd->skip_update) {
1326                         oidcpy(oid, &cmd->new_oid);
1327                         *cmd_list = cmd->next;
1328                         return 0;
1329                 }
1330         }
1331         *cmd_list = NULL;
1332         return -1; /* end of list */
1333 }
1334
1335 static void reject_updates_to_hidden(struct command *commands)
1336 {
1337         struct strbuf refname_full = STRBUF_INIT;
1338         size_t prefix_len;
1339         struct command *cmd;
1340
1341         strbuf_addstr(&refname_full, get_git_namespace());
1342         prefix_len = refname_full.len;
1343
1344         for (cmd = commands; cmd; cmd = cmd->next) {
1345                 if (cmd->error_string)
1346                         continue;
1347
1348                 strbuf_setlen(&refname_full, prefix_len);
1349                 strbuf_addstr(&refname_full, cmd->ref_name);
1350
1351                 if (!ref_is_hidden(cmd->ref_name, refname_full.buf))
1352                         continue;
1353                 if (is_null_oid(&cmd->new_oid))
1354                         cmd->error_string = "deny deleting a hidden ref";
1355                 else
1356                         cmd->error_string = "deny updating a hidden ref";
1357         }
1358
1359         strbuf_release(&refname_full);
1360 }
1361
1362 static int should_process_cmd(struct command *cmd)
1363 {
1364         return !cmd->error_string && !cmd->skip_update;
1365 }
1366
1367 static void warn_if_skipped_connectivity_check(struct command *commands,
1368                                                struct shallow_info *si)
1369 {
1370         struct command *cmd;
1371         int checked_connectivity = 1;
1372
1373         for (cmd = commands; cmd; cmd = cmd->next) {
1374                 if (should_process_cmd(cmd) && si->shallow_ref[cmd->index]) {
1375                         error("BUG: connectivity check has not been run on ref %s",
1376                               cmd->ref_name);
1377                         checked_connectivity = 0;
1378                 }
1379         }
1380         if (!checked_connectivity)
1381                 BUG("connectivity check skipped???");
1382 }
1383
1384 static void execute_commands_non_atomic(struct command *commands,
1385                                         struct shallow_info *si)
1386 {
1387         struct command *cmd;
1388         struct strbuf err = STRBUF_INIT;
1389
1390         for (cmd = commands; cmd; cmd = cmd->next) {
1391                 if (!should_process_cmd(cmd))
1392                         continue;
1393
1394                 transaction = ref_transaction_begin(&err);
1395                 if (!transaction) {
1396                         rp_error("%s", err.buf);
1397                         strbuf_reset(&err);
1398                         cmd->error_string = "transaction failed to start";
1399                         continue;
1400                 }
1401
1402                 cmd->error_string = update(cmd, si);
1403
1404                 if (!cmd->error_string
1405                     && ref_transaction_commit(transaction, &err)) {
1406                         rp_error("%s", err.buf);
1407                         strbuf_reset(&err);
1408                         cmd->error_string = "failed to update ref";
1409                 }
1410                 ref_transaction_free(transaction);
1411         }
1412         strbuf_release(&err);
1413 }
1414
1415 static void execute_commands_atomic(struct command *commands,
1416                                         struct shallow_info *si)
1417 {
1418         struct command *cmd;
1419         struct strbuf err = STRBUF_INIT;
1420         const char *reported_error = "atomic push failure";
1421
1422         transaction = ref_transaction_begin(&err);
1423         if (!transaction) {
1424                 rp_error("%s", err.buf);
1425                 strbuf_reset(&err);
1426                 reported_error = "transaction failed to start";
1427                 goto failure;
1428         }
1429
1430         for (cmd = commands; cmd; cmd = cmd->next) {
1431                 if (!should_process_cmd(cmd))
1432                         continue;
1433
1434                 cmd->error_string = update(cmd, si);
1435
1436                 if (cmd->error_string)
1437                         goto failure;
1438         }
1439
1440         if (ref_transaction_commit(transaction, &err)) {
1441                 rp_error("%s", err.buf);
1442                 reported_error = "atomic transaction failed";
1443                 goto failure;
1444         }
1445         goto cleanup;
1446
1447 failure:
1448         for (cmd = commands; cmd; cmd = cmd->next)
1449                 if (!cmd->error_string)
1450                         cmd->error_string = reported_error;
1451
1452 cleanup:
1453         ref_transaction_free(transaction);
1454         strbuf_release(&err);
1455 }
1456
1457 static void execute_commands(struct command *commands,
1458                              const char *unpacker_error,
1459                              struct shallow_info *si,
1460                              const struct string_list *push_options)
1461 {
1462         struct check_connected_options opt = CHECK_CONNECTED_INIT;
1463         struct command *cmd;
1464         struct iterate_data data;
1465         struct async muxer;
1466         int err_fd = 0;
1467
1468         if (unpacker_error) {
1469                 for (cmd = commands; cmd; cmd = cmd->next)
1470                         cmd->error_string = "unpacker error";
1471                 return;
1472         }
1473
1474         if (use_sideband) {
1475                 memset(&muxer, 0, sizeof(muxer));
1476                 muxer.proc = copy_to_sideband;
1477                 muxer.in = -1;
1478                 if (!start_async(&muxer))
1479                         err_fd = muxer.in;
1480                 /* ...else, continue without relaying sideband */
1481         }
1482
1483         data.cmds = commands;
1484         data.si = si;
1485         opt.err_fd = err_fd;
1486         opt.progress = err_fd && !quiet;
1487         opt.env = tmp_objdir_env(tmp_objdir);
1488         if (check_connected(iterate_receive_command_list, &data, &opt))
1489                 set_connectivity_errors(commands, si);
1490
1491         if (use_sideband)
1492                 finish_async(&muxer);
1493
1494         reject_updates_to_hidden(commands);
1495
1496         if (run_receive_hook(commands, "pre-receive", 0, push_options)) {
1497                 for (cmd = commands; cmd; cmd = cmd->next) {
1498                         if (!cmd->error_string)
1499                                 cmd->error_string = "pre-receive hook declined";
1500                 }
1501                 return;
1502         }
1503
1504         /*
1505          * Now we'll start writing out refs, which means the objects need
1506          * to be in their final positions so that other processes can see them.
1507          */
1508         if (tmp_objdir_migrate(tmp_objdir) < 0) {
1509                 for (cmd = commands; cmd; cmd = cmd->next) {
1510                         if (!cmd->error_string)
1511                                 cmd->error_string = "unable to migrate objects to permanent storage";
1512                 }
1513                 return;
1514         }
1515         tmp_objdir = NULL;
1516
1517         check_aliased_updates(commands);
1518
1519         free(head_name_to_free);
1520         head_name = head_name_to_free = resolve_refdup("HEAD", 0, NULL, NULL);
1521
1522         if (use_atomic)
1523                 execute_commands_atomic(commands, si);
1524         else
1525                 execute_commands_non_atomic(commands, si);
1526
1527         if (shallow_update)
1528                 warn_if_skipped_connectivity_check(commands, si);
1529 }
1530
1531 static struct command **queue_command(struct command **tail,
1532                                       const char *line,
1533                                       int linelen)
1534 {
1535         struct object_id old_oid, new_oid;
1536         struct command *cmd;
1537         const char *refname;
1538         int reflen;
1539         const char *p;
1540
1541         if (parse_oid_hex(line, &old_oid, &p) ||
1542             *p++ != ' ' ||
1543             parse_oid_hex(p, &new_oid, &p) ||
1544             *p++ != ' ')
1545                 die("protocol error: expected old/new/ref, got '%s'", line);
1546
1547         refname = p;
1548         reflen = linelen - (p - line);
1549         FLEX_ALLOC_MEM(cmd, ref_name, refname, reflen);
1550         oidcpy(&cmd->old_oid, &old_oid);
1551         oidcpy(&cmd->new_oid, &new_oid);
1552         *tail = cmd;
1553         return &cmd->next;
1554 }
1555
1556 static void queue_commands_from_cert(struct command **tail,
1557                                      struct strbuf *push_cert)
1558 {
1559         const char *boc, *eoc;
1560
1561         if (*tail)
1562                 die("protocol error: got both push certificate and unsigned commands");
1563
1564         boc = strstr(push_cert->buf, "\n\n");
1565         if (!boc)
1566                 die("malformed push certificate %.*s", 100, push_cert->buf);
1567         else
1568                 boc += 2;
1569         eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1570
1571         while (boc < eoc) {
1572                 const char *eol = memchr(boc, '\n', eoc - boc);
1573                 tail = queue_command(tail, boc, eol ? eol - boc : eoc - boc);
1574                 boc = eol ? eol + 1 : eoc;
1575         }
1576 }
1577
1578 static struct command *read_head_info(struct oid_array *shallow)
1579 {
1580         struct command *commands = NULL;
1581         struct command **p = &commands;
1582         for (;;) {
1583                 char *line;
1584                 int len, linelen;
1585
1586                 line = packet_read_line(0, &len);
1587                 if (!line)
1588                         break;
1589
1590                 if (len > 8 && starts_with(line, "shallow ")) {
1591                         struct object_id oid;
1592                         if (get_oid_hex(line + 8, &oid))
1593                                 die("protocol error: expected shallow sha, got '%s'",
1594                                     line + 8);
1595                         oid_array_append(shallow, &oid);
1596                         continue;
1597                 }
1598
1599                 linelen = strlen(line);
1600                 if (linelen < len) {
1601                         const char *feature_list = line + linelen + 1;
1602                         if (parse_feature_request(feature_list, "report-status"))
1603                                 report_status = 1;
1604                         if (parse_feature_request(feature_list, "side-band-64k"))
1605                                 use_sideband = LARGE_PACKET_MAX;
1606                         if (parse_feature_request(feature_list, "quiet"))
1607                                 quiet = 1;
1608                         if (advertise_atomic_push
1609                             && parse_feature_request(feature_list, "atomic"))
1610                                 use_atomic = 1;
1611                         if (advertise_push_options
1612                             && parse_feature_request(feature_list, "push-options"))
1613                                 use_push_options = 1;
1614                 }
1615
1616                 if (!strcmp(line, "push-cert")) {
1617                         int true_flush = 0;
1618                         char certbuf[1024];
1619
1620                         for (;;) {
1621                                 len = packet_read(0, NULL, NULL,
1622                                                   certbuf, sizeof(certbuf), 0);
1623                                 if (!len) {
1624                                         true_flush = 1;
1625                                         break;
1626                                 }
1627                                 if (!strcmp(certbuf, "push-cert-end\n"))
1628                                         break; /* end of cert */
1629                                 strbuf_addstr(&push_cert, certbuf);
1630                         }
1631
1632                         if (true_flush)
1633                                 break;
1634                         continue;
1635                 }
1636
1637                 p = queue_command(p, line, linelen);
1638         }
1639
1640         if (push_cert.len)
1641                 queue_commands_from_cert(p, &push_cert);
1642
1643         return commands;
1644 }
1645
1646 static void read_push_options(struct string_list *options)
1647 {
1648         while (1) {
1649                 char *line;
1650                 int len;
1651
1652                 line = packet_read_line(0, &len);
1653
1654                 if (!line)
1655                         break;
1656
1657                 string_list_append(options, line);
1658         }
1659 }
1660
1661 static const char *parse_pack_header(struct pack_header *hdr)
1662 {
1663         switch (read_pack_header(0, hdr)) {
1664         case PH_ERROR_EOF:
1665                 return "eof before pack header was fully read";
1666
1667         case PH_ERROR_PACK_SIGNATURE:
1668                 return "protocol error (pack signature mismatch detected)";
1669
1670         case PH_ERROR_PROTOCOL:
1671                 return "protocol error (pack version unsupported)";
1672
1673         default:
1674                 return "unknown error in parse_pack_header";
1675
1676         case 0:
1677                 return NULL;
1678         }
1679 }
1680
1681 static const char *pack_lockfile;
1682
1683 static void push_header_arg(struct argv_array *args, struct pack_header *hdr)
1684 {
1685         argv_array_pushf(args, "--pack_header=%"PRIu32",%"PRIu32,
1686                         ntohl(hdr->hdr_version), ntohl(hdr->hdr_entries));
1687 }
1688
1689 static const char *unpack(int err_fd, struct shallow_info *si)
1690 {
1691         struct pack_header hdr;
1692         const char *hdr_err;
1693         int status;
1694         struct child_process child = CHILD_PROCESS_INIT;
1695         int fsck_objects = (receive_fsck_objects >= 0
1696                             ? receive_fsck_objects
1697                             : transfer_fsck_objects >= 0
1698                             ? transfer_fsck_objects
1699                             : 0);
1700
1701         hdr_err = parse_pack_header(&hdr);
1702         if (hdr_err) {
1703                 if (err_fd > 0)
1704                         close(err_fd);
1705                 return hdr_err;
1706         }
1707
1708         if (si->nr_ours || si->nr_theirs) {
1709                 alt_shallow_file = setup_temporary_shallow(si->shallow);
1710                 argv_array_push(&child.args, "--shallow-file");
1711                 argv_array_push(&child.args, alt_shallow_file);
1712         }
1713
1714         tmp_objdir = tmp_objdir_create();
1715         if (!tmp_objdir) {
1716                 if (err_fd > 0)
1717                         close(err_fd);
1718                 return "unable to create temporary object directory";
1719         }
1720         child.env = tmp_objdir_env(tmp_objdir);
1721
1722         /*
1723          * Normally we just pass the tmp_objdir environment to the child
1724          * processes that do the heavy lifting, but we may need to see these
1725          * objects ourselves to set up shallow information.
1726          */
1727         tmp_objdir_add_as_alternate(tmp_objdir);
1728
1729         if (ntohl(hdr.hdr_entries) < unpack_limit) {
1730                 argv_array_push(&child.args, "unpack-objects");
1731                 push_header_arg(&child.args, &hdr);
1732                 if (quiet)
1733                         argv_array_push(&child.args, "-q");
1734                 if (fsck_objects)
1735                         argv_array_pushf(&child.args, "--strict%s",
1736                                 fsck_msg_types.buf);
1737                 if (max_input_size)
1738                         argv_array_pushf(&child.args, "--max-input-size=%"PRIuMAX,
1739                                 (uintmax_t)max_input_size);
1740                 child.no_stdout = 1;
1741                 child.err = err_fd;
1742                 child.git_cmd = 1;
1743                 status = run_command(&child);
1744                 if (status)
1745                         return "unpack-objects abnormal exit";
1746         } else {
1747                 char hostname[HOST_NAME_MAX + 1];
1748
1749                 argv_array_pushl(&child.args, "index-pack", "--stdin", NULL);
1750                 push_header_arg(&child.args, &hdr);
1751
1752                 if (xgethostname(hostname, sizeof(hostname)))
1753                         xsnprintf(hostname, sizeof(hostname), "localhost");
1754                 argv_array_pushf(&child.args,
1755                                  "--keep=receive-pack %"PRIuMAX" on %s",
1756                                  (uintmax_t)getpid(),
1757                                  hostname);
1758
1759                 if (!quiet && err_fd)
1760                         argv_array_push(&child.args, "--show-resolving-progress");
1761                 if (use_sideband)
1762                         argv_array_push(&child.args, "--report-end-of-input");
1763                 if (fsck_objects)
1764                         argv_array_pushf(&child.args, "--strict%s",
1765                                 fsck_msg_types.buf);
1766                 if (!reject_thin)
1767                         argv_array_push(&child.args, "--fix-thin");
1768                 if (max_input_size)
1769                         argv_array_pushf(&child.args, "--max-input-size=%"PRIuMAX,
1770                                 (uintmax_t)max_input_size);
1771                 child.out = -1;
1772                 child.err = err_fd;
1773                 child.git_cmd = 1;
1774                 status = start_command(&child);
1775                 if (status)
1776                         return "index-pack fork failed";
1777                 pack_lockfile = index_pack_lockfile(child.out);
1778                 close(child.out);
1779                 status = finish_command(&child);
1780                 if (status)
1781                         return "index-pack abnormal exit";
1782                 reprepare_packed_git(the_repository);
1783         }
1784         return NULL;
1785 }
1786
1787 static const char *unpack_with_sideband(struct shallow_info *si)
1788 {
1789         struct async muxer;
1790         const char *ret;
1791
1792         if (!use_sideband)
1793                 return unpack(0, si);
1794
1795         use_keepalive = KEEPALIVE_AFTER_NUL;
1796         memset(&muxer, 0, sizeof(muxer));
1797         muxer.proc = copy_to_sideband;
1798         muxer.in = -1;
1799         if (start_async(&muxer))
1800                 return NULL;
1801
1802         ret = unpack(muxer.in, si);
1803
1804         finish_async(&muxer);
1805         return ret;
1806 }
1807
1808 static void prepare_shallow_update(struct command *commands,
1809                                    struct shallow_info *si)
1810 {
1811         int i, j, k, bitmap_size = DIV_ROUND_UP(si->ref->nr, 32);
1812
1813         ALLOC_ARRAY(si->used_shallow, si->shallow->nr);
1814         assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1815
1816         si->need_reachability_test =
1817                 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1818         si->reachable =
1819                 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1820         si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1821
1822         for (i = 0; i < si->nr_ours; i++)
1823                 si->need_reachability_test[si->ours[i]] = 1;
1824
1825         for (i = 0; i < si->shallow->nr; i++) {
1826                 if (!si->used_shallow[i])
1827                         continue;
1828                 for (j = 0; j < bitmap_size; j++) {
1829                         if (!si->used_shallow[i][j])
1830                                 continue;
1831                         si->need_reachability_test[i]++;
1832                         for (k = 0; k < 32; k++)
1833                                 if (si->used_shallow[i][j] & (1U << k))
1834                                         si->shallow_ref[j * 32 + k]++;
1835                 }
1836
1837                 /*
1838                  * true for those associated with some refs and belong
1839                  * in "ours" list aka "step 7 not done yet"
1840                  */
1841                 si->need_reachability_test[i] =
1842                         si->need_reachability_test[i] > 1;
1843         }
1844
1845         /*
1846          * keep hooks happy by forcing a temporary shallow file via
1847          * env variable because we can't add --shallow-file to every
1848          * command. check_everything_connected() will be done with
1849          * true .git/shallow though.
1850          */
1851         setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1852 }
1853
1854 static void update_shallow_info(struct command *commands,
1855                                 struct shallow_info *si,
1856                                 struct oid_array *ref)
1857 {
1858         struct command *cmd;
1859         int *ref_status;
1860         remove_nonexistent_theirs_shallow(si);
1861         if (!si->nr_ours && !si->nr_theirs) {
1862                 shallow_update = 0;
1863                 return;
1864         }
1865
1866         for (cmd = commands; cmd; cmd = cmd->next) {
1867                 if (is_null_oid(&cmd->new_oid))
1868                         continue;
1869                 oid_array_append(ref, &cmd->new_oid);
1870                 cmd->index = ref->nr - 1;
1871         }
1872         si->ref = ref;
1873
1874         if (shallow_update) {
1875                 prepare_shallow_update(commands, si);
1876                 return;
1877         }
1878
1879         ALLOC_ARRAY(ref_status, ref->nr);
1880         assign_shallow_commits_to_refs(si, NULL, ref_status);
1881         for (cmd = commands; cmd; cmd = cmd->next) {
1882                 if (is_null_oid(&cmd->new_oid))
1883                         continue;
1884                 if (ref_status[cmd->index]) {
1885                         cmd->error_string = "shallow update not allowed";
1886                         cmd->skip_update = 1;
1887                 }
1888         }
1889         free(ref_status);
1890 }
1891
1892 static void report(struct command *commands, const char *unpack_status)
1893 {
1894         struct command *cmd;
1895         struct strbuf buf = STRBUF_INIT;
1896
1897         packet_buf_write(&buf, "unpack %s\n",
1898                          unpack_status ? unpack_status : "ok");
1899         for (cmd = commands; cmd; cmd = cmd->next) {
1900                 if (!cmd->error_string)
1901                         packet_buf_write(&buf, "ok %s\n",
1902                                          cmd->ref_name);
1903                 else
1904                         packet_buf_write(&buf, "ng %s %s\n",
1905                                          cmd->ref_name, cmd->error_string);
1906         }
1907         packet_buf_flush(&buf);
1908
1909         if (use_sideband)
1910                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1911         else
1912                 write_or_die(1, buf.buf, buf.len);
1913         strbuf_release(&buf);
1914 }
1915
1916 static int delete_only(struct command *commands)
1917 {
1918         struct command *cmd;
1919         for (cmd = commands; cmd; cmd = cmd->next) {
1920                 if (!is_null_oid(&cmd->new_oid))
1921                         return 0;
1922         }
1923         return 1;
1924 }
1925
1926 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1927 {
1928         int advertise_refs = 0;
1929         struct command *commands;
1930         struct oid_array shallow = OID_ARRAY_INIT;
1931         struct oid_array ref = OID_ARRAY_INIT;
1932         struct shallow_info si;
1933
1934         struct option options[] = {
1935                 OPT__QUIET(&quiet, N_("quiet")),
1936                 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc, NULL),
1937                 OPT_HIDDEN_BOOL(0, "advertise-refs", &advertise_refs, NULL),
1938                 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin, NULL),
1939                 OPT_END()
1940         };
1941
1942         packet_trace_identity("receive-pack");
1943
1944         argc = parse_options(argc, argv, prefix, options, receive_pack_usage, 0);
1945
1946         if (argc > 1)
1947                 usage_msg_opt(_("Too many arguments."), receive_pack_usage, options);
1948         if (argc == 0)
1949                 usage_msg_opt(_("You must specify a directory."), receive_pack_usage, options);
1950
1951         service_dir = argv[0];
1952
1953         setup_path();
1954
1955         if (!enter_repo(service_dir, 0))
1956                 die("'%s' does not appear to be a git repository", service_dir);
1957
1958         git_config(receive_pack_config, NULL);
1959         if (cert_nonce_seed)
1960                 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1961
1962         if (0 <= transfer_unpack_limit)
1963                 unpack_limit = transfer_unpack_limit;
1964         else if (0 <= receive_unpack_limit)
1965                 unpack_limit = receive_unpack_limit;
1966
1967         switch (determine_protocol_version_server()) {
1968         case protocol_v2:
1969                 /*
1970                  * push support for protocol v2 has not been implemented yet,
1971                  * so ignore the request to use v2 and fallback to using v0.
1972                  */
1973                 break;
1974         case protocol_v1:
1975                 /*
1976                  * v1 is just the original protocol with a version string,
1977                  * so just fall through after writing the version string.
1978                  */
1979                 if (advertise_refs || !stateless_rpc)
1980                         packet_write_fmt(1, "version 1\n");
1981
1982                 /* fallthrough */
1983         case protocol_v0:
1984                 break;
1985         case protocol_unknown_version:
1986                 BUG("unknown protocol version");
1987         }
1988
1989         if (advertise_refs || !stateless_rpc) {
1990                 write_head_info();
1991         }
1992         if (advertise_refs)
1993                 return 0;
1994
1995         if ((commands = read_head_info(&shallow)) != NULL) {
1996                 const char *unpack_status = NULL;
1997                 struct string_list push_options = STRING_LIST_INIT_DUP;
1998
1999                 if (use_push_options)
2000                         read_push_options(&push_options);
2001                 if (!check_cert_push_options(&push_options)) {
2002                         struct command *cmd;
2003                         for (cmd = commands; cmd; cmd = cmd->next)
2004                                 cmd->error_string = "inconsistent push options";
2005                 }
2006
2007                 prepare_shallow_info(&si, &shallow);
2008                 if (!si.nr_ours && !si.nr_theirs)
2009                         shallow_update = 0;
2010                 if (!delete_only(commands)) {
2011                         unpack_status = unpack_with_sideband(&si);
2012                         update_shallow_info(commands, &si, &ref);
2013                 }
2014                 use_keepalive = KEEPALIVE_ALWAYS;
2015                 execute_commands(commands, unpack_status, &si,
2016                                  &push_options);
2017                 if (pack_lockfile)
2018                         unlink_or_warn(pack_lockfile);
2019                 if (report_status)
2020                         report(commands, unpack_status);
2021                 run_receive_hook(commands, "post-receive", 1,
2022                                  &push_options);
2023                 run_update_post_hook(commands);
2024                 string_list_clear(&push_options, 0);
2025                 if (auto_gc) {
2026                         const char *argv_gc_auto[] = {
2027                                 "gc", "--auto", "--quiet", NULL,
2028                         };
2029                         struct child_process proc = CHILD_PROCESS_INIT;
2030
2031                         proc.no_stdin = 1;
2032                         proc.stdout_to_stderr = 1;
2033                         proc.err = use_sideband ? -1 : 0;
2034                         proc.git_cmd = 1;
2035                         proc.argv = argv_gc_auto;
2036
2037                         close_all_packs(the_repository->objects);
2038                         if (!start_command(&proc)) {
2039                                 if (use_sideband)
2040                                         copy_to_sideband(proc.err, -1, NULL);
2041                                 finish_command(&proc);
2042                         }
2043                 }
2044                 if (auto_update_server_info)
2045                         update_server_info(0);
2046                 clear_shallow_info(&si);
2047         }
2048         if (use_sideband)
2049                 packet_flush(1);
2050         oid_array_clear(&shallow);
2051         oid_array_clear(&ref);
2052         free((void *)push_cert_nonce);
2053         return 0;
2054 }