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