git.oblomov.eu Git - git/blob - 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 "sha1-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(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, 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, (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 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                 int bogs /* beginning_of_gpg_sig */;
 633
 634                 already_done = 1;
 635                 if (write_object_file(push_cert.buf, push_cert.len, "blob",
 636                                       &push_cert_oid))
 637                         oidclr(&push_cert_oid);
 638
 639                 memset(&sigcheck, '\0', sizeof(sigcheck));
 640
 641                 bogs = parse_signature(push_cert.buf, push_cert.len);
 642                 check_signature(push_cert.buf, bogs, push_cert.buf + bogs,
 643                                 push_cert.len - bogs, &sigcheck);
 644
 645                 nonce_status = check_nonce(push_cert.buf, bogs);
 646         }
 647         if (!is_null_oid(&push_cert_oid)) {
 648                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT=%s",
 649                                  oid_to_hex(&push_cert_oid));
 650                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_SIGNER=%s",
 651                                  sigcheck.signer ? sigcheck.signer : "");
 652                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_KEY=%s",
 653                                  sigcheck.key ? sigcheck.key : "");
 654                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_STATUS=%c",
 655                                  sigcheck.result);
 656                 if (push_cert_nonce) {
 657                         argv_array_pushf(&proc->env_array,
 658                                          "GIT_PUSH_CERT_NONCE=%s",
 659                                          push_cert_nonce);
 660                         argv_array_pushf(&proc->env_array,
 661                                          "GIT_PUSH_CERT_NONCE_STATUS=%s",
 662                                          nonce_status);
 663                         if (nonce_status == NONCE_SLOP)
 664                                 argv_array_pushf(&proc->env_array,
 665                                                  "GIT_PUSH_CERT_NONCE_SLOP=%ld",
 666                                                  nonce_stamp_slop);
 667                 }
 668         }
 669 }
 670
 671 struct receive_hook_feed_state {
 672         struct command *cmd;
 673         int skip_broken;
 674         struct strbuf buf;
 675         const struct string_list *push_options;
 676 };
 677
 678 typedef int (*feed_fn)(void *, const char **, size_t *);
 679 static int run_and_feed_hook(const char *hook_name, feed_fn feed,
 680                              struct receive_hook_feed_state *feed_state)
 681 {
 682         struct child_process proc = CHILD_PROCESS_INIT;
 683         struct async muxer;
 684         const char *argv[2];
 685         int code;
 686
 687         argv[0] = find_hook(hook_name);
 688         if (!argv[0])
 689                 return 0;
 690
 691         argv[1] = NULL;
 692
 693         proc.argv = argv;
 694         proc.in = -1;
 695         proc.stdout_to_stderr = 1;
 696         proc.trace2_hook_name = hook_name;
 697
 698         if (feed_state->push_options) {
 699                 int i;
 700                 for (i = 0; i < feed_state->push_options->nr; i++)
 701                         argv_array_pushf(&proc.env_array,
 702                                 "GIT_PUSH_OPTION_%d=%s", i,
 703                                 feed_state->push_options->items[i].string);
 704                 argv_array_pushf(&proc.env_array, "GIT_PUSH_OPTION_COUNT=%d",
 705                                  feed_state->push_options->nr);
 706         } else
 707                 argv_array_pushf(&proc.env_array, "GIT_PUSH_OPTION_COUNT");
 708
 709         if (tmp_objdir)
 710                 argv_array_pushv(&proc.env_array, tmp_objdir_env(tmp_objdir));
 711
 712         if (use_sideband) {
 713                 memset(&muxer, 0, sizeof(muxer));
 714                 muxer.proc = copy_to_sideband;
 715                 muxer.in = -1;
 716                 code = start_async(&muxer);
 717                 if (code)
 718                         return code;
 719                 proc.err = muxer.in;
 720         }
 721
 722         prepare_push_cert_sha1(&proc);
 723
 724         code = start_command(&proc);
 725         if (code) {
 726                 if (use_sideband)
 727                         finish_async(&muxer);
 728                 return code;
 729         }
 730
 731         sigchain_push(SIGPIPE, SIG_IGN);
 732
 733         while (1) {
 734                 const char *buf;
 735                 size_t n;
 736                 if (feed(feed_state, &buf, &n))
 737                         break;
 738                 if (write_in_full(proc.in, buf, n) < 0)
 739                         break;
 740         }
 741         close(proc.in);
 742         if (use_sideband)
 743                 finish_async(&muxer);
 744
 745         sigchain_pop(SIGPIPE);
 746
 747         return finish_command(&proc);
 748 }
 749
 750 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 751 {
 752         struct receive_hook_feed_state *state = state_;
 753         struct command *cmd = state->cmd;
 754
 755         while (cmd &&
 756                state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 757                 cmd = cmd->next;
 758         if (!cmd)
 759                 return -1; /* EOF */
 760         strbuf_reset(&state->buf);
 761         strbuf_addf(&state->buf, "%s %s %s\n",
 762                     oid_to_hex(&cmd->old_oid), oid_to_hex(&cmd->new_oid),
 763                     cmd->ref_name);
 764         state->cmd = cmd->next;
 765         if (bufp) {
 766                 *bufp = state->buf.buf;
 767                 *sizep = state->buf.len;
 768         }
 769         return 0;
 770 }
 771
 772 static int run_receive_hook(struct command *commands,
 773                             const char *hook_name,
 774                             int skip_broken,
 775                             const struct string_list *push_options)
 776 {
 777         struct receive_hook_feed_state state;
 778         int status;
 779
 780         strbuf_init(&state.buf, 0);
 781         state.cmd = commands;
 782         state.skip_broken = skip_broken;
 783         if (feed_receive_hook(&state, NULL, NULL))
 784                 return 0;
 785         state.cmd = commands;
 786         state.push_options = push_options;
 787         status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 788         strbuf_release(&state.buf);
 789         return status;
 790 }
 791
 792 static int run_update_hook(struct command *cmd)
 793 {
 794         const char *argv[5];
 795         struct child_process proc = CHILD_PROCESS_INIT;
 796         int code;
 797
 798         argv[0] = find_hook("update");
 799         if (!argv[0])
 800                 return 0;
 801
 802         argv[1] = cmd->ref_name;
 803         argv[2] = oid_to_hex(&cmd->old_oid);
 804         argv[3] = oid_to_hex(&cmd->new_oid);
 805         argv[4] = NULL;
 806
 807         proc.no_stdin = 1;
 808         proc.stdout_to_stderr = 1;
 809         proc.err = use_sideband ? -1 : 0;
 810         proc.argv = argv;
 811         proc.trace2_hook_name = "update";
 812
 813         code = start_command(&proc);
 814         if (code)
 815                 return code;
 816         if (use_sideband)
 817                 copy_to_sideband(proc.err, -1, NULL);
 818         return finish_command(&proc);
 819 }
 820
 821 static char *refuse_unconfigured_deny_msg =
 822         N_("By default, updating the current branch in a non-bare repository\n"
 823            "is denied, because it will make the index and work tree inconsistent\n"
 824            "with what you pushed, and will require 'git reset --hard' to match\n"
 825            "the work tree to HEAD.\n"
 826            "\n"
 827            "You can set the 'receive.denyCurrentBranch' configuration variable\n"
 828            "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
 829            "its current branch; however, this is not recommended unless you\n"
 830            "arranged to update its work tree to match what you pushed in some\n"
 831            "other way.\n"
 832            "\n"
 833            "To squelch this message and still keep the default behaviour, set\n"
 834            "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
 835
 836 static void refuse_unconfigured_deny(void)
 837 {
 838         rp_error("%s", _(refuse_unconfigured_deny_msg));
 839 }
 840
 841 static char *refuse_unconfigured_deny_delete_current_msg =
 842         N_("By default, deleting the current branch is denied, because the next\n"
 843            "'git clone' won't result in any file checked out, causing confusion.\n"
 844            "\n"
 845            "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
 846            "'warn' or 'ignore' in the remote repository to allow deleting the\n"
 847            "current branch, with or without a warning message.\n"
 848            "\n"
 849            "To squelch this message, you can set it to 'refuse'.");
 850
 851 static void refuse_unconfigured_deny_delete_current(void)
 852 {
 853         rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg));
 854 }
 855
 856 static int command_singleton_iterator(void *cb_data, struct object_id *oid);
 857 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
 858 {
 859         struct lock_file shallow_lock = LOCK_INIT;
 860         struct oid_array extra = OID_ARRAY_INIT;
 861         struct check_connected_options opt = CHECK_CONNECTED_INIT;
 862         uint32_t mask = 1 << (cmd->index % 32);
 863         int i;
 864
 865         trace_printf_key(&trace_shallow,
 866                          "shallow: update_shallow_ref %s\n", cmd->ref_name);
 867         for (i = 0; i < si->shallow->nr; i++)
 868                 if (si->used_shallow[i] &&
 869                     (si->used_shallow[i][cmd->index / 32] & mask) &&
 870                     !delayed_reachability_test(si, i))
 871                         oid_array_append(&extra, &si->shallow->oid[i]);
 872
 873         opt.env = tmp_objdir_env(tmp_objdir);
 874         setup_alternate_shallow(&shallow_lock, &opt.shallow_file, &extra);
 875         if (check_connected(command_singleton_iterator, cmd, &opt)) {
 876                 rollback_shallow_file(the_repository, &shallow_lock);
 877                 oid_array_clear(&extra);
 878                 return -1;
 879         }
 880
 881         commit_shallow_file(the_repository, &shallow_lock);
 882
 883         /*
 884          * Make sure setup_alternate_shallow() for the next ref does
 885          * not lose these new roots..
 886          */
 887         for (i = 0; i < extra.nr; i++)
 888                 register_shallow(the_repository, &extra.oid[i]);
 889
 890         si->shallow_ref[cmd->index] = 0;
 891         oid_array_clear(&extra);
 892         return 0;
 893 }
 894
 895 /*
 896  * NEEDSWORK: we should consolidate various implementions of "are we
 897  * on an unborn branch?" test into one, and make the unified one more
 898  * robust. !get_sha1() based check used here and elsewhere would not
 899  * allow us to tell an unborn branch from corrupt ref, for example.
 900  * For the purpose of fixing "deploy-to-update does not work when
 901  * pushing into an empty repository" issue, this should suffice for
 902  * now.
 903  */
 904 static int head_has_history(void)
 905 {
 906         struct object_id oid;
 907
 908         return !get_oid("HEAD", &oid);
 909 }
 910
 911 static const char *push_to_deploy(unsigned char *sha1,
 912                                   struct argv_array *env,
 913                                   const char *work_tree)
 914 {
 915         const char *update_refresh[] = {
 916                 "update-index", "-q", "--ignore-submodules", "--refresh", NULL
 917         };
 918         const char *diff_files[] = {
 919                 "diff-files", "--quiet", "--ignore-submodules", "--", NULL
 920         };
 921         const char *diff_index[] = {
 922                 "diff-index", "--quiet", "--cached", "--ignore-submodules",
 923                 NULL, "--", NULL
 924         };
 925         const char *read_tree[] = {
 926                 "read-tree", "-u", "-m", NULL, NULL
 927         };
 928         struct child_process child = CHILD_PROCESS_INIT;
 929
 930         child.argv = update_refresh;
 931         child.env = env->argv;
 932         child.dir = work_tree;
 933         child.no_stdin = 1;
 934         child.stdout_to_stderr = 1;
 935         child.git_cmd = 1;
 936         if (run_command(&child))
 937                 return "Up-to-date check failed";
 938
 939         /* run_command() does not clean up completely; reinitialize */
 940         child_process_init(&child);
 941         child.argv = diff_files;
 942         child.env = env->argv;
 943         child.dir = work_tree;
 944         child.no_stdin = 1;
 945         child.stdout_to_stderr = 1;
 946         child.git_cmd = 1;
 947         if (run_command(&child))
 948                 return "Working directory has unstaged changes";
 949
 950         /* diff-index with either HEAD or an empty tree */
 951         diff_index[4] = head_has_history() ? "HEAD" : empty_tree_oid_hex();
 952
 953         child_process_init(&child);
 954         child.argv = diff_index;
 955         child.env = env->argv;
 956         child.no_stdin = 1;
 957         child.no_stdout = 1;
 958         child.stdout_to_stderr = 0;
 959         child.git_cmd = 1;
 960         if (run_command(&child))
 961                 return "Working directory has staged changes";
 962
 963         read_tree[3] = hash_to_hex(sha1);
 964         child_process_init(&child);
 965         child.argv = read_tree;
 966         child.env = env->argv;
 967         child.dir = work_tree;
 968         child.no_stdin = 1;
 969         child.no_stdout = 1;
 970         child.stdout_to_stderr = 0;
 971         child.git_cmd = 1;
 972         if (run_command(&child))
 973                 return "Could not update working tree to new HEAD";
 974
 975         return NULL;
 976 }
 977
 978 static const char *push_to_checkout_hook = "push-to-checkout";
 979
 980 static const char *push_to_checkout(unsigned char *hash,
 981                                     struct argv_array *env,
 982                                     const char *work_tree)
 983 {
 984         argv_array_pushf(env, "GIT_WORK_TREE=%s", absolute_path(work_tree));
 985         if (run_hook_le(env->argv, push_to_checkout_hook,
 986                         hash_to_hex(hash), NULL))
 987                 return "push-to-checkout hook declined";
 988         else
 989                 return NULL;
 990 }
 991
 992 static const char *update_worktree(unsigned char *sha1, const struct worktree *worktree)
 993 {
 994         const char *retval, *work_tree, *git_dir = NULL;
 995         struct argv_array env = ARGV_ARRAY_INIT;
 996
 997         if (worktree && worktree->path)
 998                 work_tree = worktree->path;
 999         else if (git_work_tree_cfg)
1000                 work_tree = git_work_tree_cfg;
1001         else
1002                 work_tree = "..";
1003
1004         if (is_bare_repository())
1005                 return "denyCurrentBranch = updateInstead needs a worktree";
1006         if (worktree)
1007                 git_dir = get_worktree_git_dir(worktree);
1008         if (!git_dir)
1009                 git_dir = get_git_dir();
1010
1011         argv_array_pushf(&env, "GIT_DIR=%s", absolute_path(git_dir));
1012
1013         if (!find_hook(push_to_checkout_hook))
1014                 retval = push_to_deploy(sha1, &env, work_tree);
1015         else
1016                 retval = push_to_checkout(sha1, &env, work_tree);
1017
1018         argv_array_clear(&env);
1019         return retval;
1020 }
1021
1022 static const char *update(struct command *cmd, struct shallow_info *si)
1023 {
1024         const char *name = cmd->ref_name;
1025         struct strbuf namespaced_name_buf = STRBUF_INIT;
1026         static char *namespaced_name;
1027         const char *ret;
1028         struct object_id *old_oid = &cmd->old_oid;
1029         struct object_id *new_oid = &cmd->new_oid;
1030         int do_update_worktree = 0;
1031         const struct worktree *worktree = is_bare_repository() ? NULL : find_shared_symref("HEAD", name);
1032
1033         /* only refs/... are allowed */
1034         if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
1035                 rp_error("refusing to create funny ref '%s' remotely", name);
1036                 return "funny refname";
1037         }
1038
1039         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
1040         free(namespaced_name);
1041         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
1042
1043         if (worktree) {
1044                 switch (deny_current_branch) {
1045                 case DENY_IGNORE:
1046                         break;
1047                 case DENY_WARN:
1048                         rp_warning("updating the current branch");
1049                         break;
1050                 case DENY_REFUSE:
1051                 case DENY_UNCONFIGURED:
1052                         rp_error("refusing to update checked out branch: %s", name);
1053                         if (deny_current_branch == DENY_UNCONFIGURED)
1054                                 refuse_unconfigured_deny();
1055                         return "branch is currently checked out";
1056                 case DENY_UPDATE_INSTEAD:
1057                         /* pass -- let other checks intervene first */
1058                         do_update_worktree = 1;
1059                         break;
1060                 }
1061         }
1062
1063         if (!is_null_oid(new_oid) && !has_object_file(new_oid)) {
1064                 error("unpack should have generated %s, "
1065                       "but I can't find it!", oid_to_hex(new_oid));
1066                 return "bad pack";
1067         }
1068
1069         if (!is_null_oid(old_oid) && is_null_oid(new_oid)) {
1070                 if (deny_deletes && starts_with(name, "refs/heads/")) {
1071                         rp_error("denying ref deletion for %s", name);
1072                         return "deletion prohibited";
1073                 }
1074
1075                 if (worktree || (head_name && !strcmp(namespaced_name, head_name))) {
1076                         switch (deny_delete_current) {
1077                         case DENY_IGNORE:
1078                                 break;
1079                         case DENY_WARN:
1080                                 rp_warning("deleting the current branch");
1081                                 break;
1082                         case DENY_REFUSE:
1083                         case DENY_UNCONFIGURED:
1084                         case DENY_UPDATE_INSTEAD:
1085                                 if (deny_delete_current == DENY_UNCONFIGURED)
1086                                         refuse_unconfigured_deny_delete_current();
1087                                 rp_error("refusing to delete the current branch: %s", name);
1088                                 return "deletion of the current branch prohibited";
1089                         default:
1090                                 return "Invalid denyDeleteCurrent setting";
1091                         }
1092                 }
1093         }
1094
1095         if (deny_non_fast_forwards && !is_null_oid(new_oid) &&
1096             !is_null_oid(old_oid) &&
1097             starts_with(name, "refs/heads/")) {
1098                 struct object *old_object, *new_object;
1099                 struct commit *old_commit, *new_commit;
1100
1101                 old_object = parse_object(the_repository, old_oid);
1102                 new_object = parse_object(the_repository, new_oid);
1103
1104                 if (!old_object || !new_object ||
1105                     old_object->type != OBJ_COMMIT ||
1106                     new_object->type != OBJ_COMMIT) {
1107                         error("bad sha1 objects for %s", name);
1108                         return "bad ref";
1109                 }
1110                 old_commit = (struct commit *)old_object;
1111                 new_commit = (struct commit *)new_object;
1112                 if (!in_merge_bases(old_commit, new_commit)) {
1113                         rp_error("denying non-fast-forward %s"
1114                                  " (you should pull first)", name);
1115                         return "non-fast-forward";
1116                 }
1117         }
1118         if (run_update_hook(cmd)) {
1119                 rp_error("hook declined to update %s", name);
1120                 return "hook declined";
1121         }
1122
1123         if (do_update_worktree) {
1124                 ret = update_worktree(new_oid->hash, find_shared_symref("HEAD", name));
1125                 if (ret)
1126                         return ret;
1127         }
1128
1129         if (is_null_oid(new_oid)) {
1130                 struct strbuf err = STRBUF_INIT;
1131                 if (!parse_object(the_repository, old_oid)) {
1132                         old_oid = NULL;
1133                         if (ref_exists(name)) {
1134                                 rp_warning("Allowing deletion of corrupt ref.");
1135                         } else {
1136                                 rp_warning("Deleting a non-existent ref.");
1137                                 cmd->did_not_exist = 1;
1138                         }
1139                 }
1140                 if (ref_transaction_delete(transaction,
1141                                            namespaced_name,
1142                                            old_oid,
1143                                            0, "push", &err)) {
1144                         rp_error("%s", err.buf);
1145                         strbuf_release(&err);
1146                         return "failed to delete";
1147                 }
1148                 strbuf_release(&err);
1149                 return NULL; /* good */
1150         }
1151         else {
1152                 struct strbuf err = STRBUF_INIT;
1153                 if (shallow_update && si->shallow_ref[cmd->index] &&
1154                     update_shallow_ref(cmd, si))
1155                         return "shallow error";
1156
1157                 if (ref_transaction_update(transaction,
1158                                            namespaced_name,
1159                                            new_oid, old_oid,
1160                                            0, "push",
1161                                            &err)) {
1162                         rp_error("%s", err.buf);
1163                         strbuf_release(&err);
1164
1165                         return "failed to update ref";
1166                 }
1167                 strbuf_release(&err);
1168
1169                 return NULL; /* good */
1170         }
1171 }
1172
1173 static void run_update_post_hook(struct command *commands)
1174 {
1175         struct command *cmd;
1176         struct child_process proc = CHILD_PROCESS_INIT;
1177         const char *hook;
1178
1179         hook = find_hook("post-update");
1180         if (!hook)
1181                 return;
1182
1183         for (cmd = commands; cmd; cmd = cmd->next) {
1184                 if (cmd->error_string || cmd->did_not_exist)
1185                         continue;
1186                 if (!proc.args.argc)
1187                         argv_array_push(&proc.args, hook);
1188                 argv_array_push(&proc.args, cmd->ref_name);
1189         }
1190         if (!proc.args.argc)
1191                 return;
1192
1193         proc.no_stdin = 1;
1194         proc.stdout_to_stderr = 1;
1195         proc.err = use_sideband ? -1 : 0;
1196         proc.trace2_hook_name = "post-update";
1197
1198         if (!start_command(&proc)) {
1199                 if (use_sideband)
1200                         copy_to_sideband(proc.err, -1, NULL);
1201                 finish_command(&proc);
1202         }
1203 }
1204
1205 static void check_aliased_update_internal(struct command *cmd,
1206                                           struct string_list *list,
1207                                           const char *dst_name, int flag)
1208 {
1209         struct string_list_item *item;
1210         struct command *dst_cmd;
1211
1212         if (!(flag & REF_ISSYMREF))
1213                 return;
1214
1215         if (!dst_name) {
1216                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
1217                 cmd->skip_update = 1;
1218                 cmd->error_string = "broken symref";
1219                 return;
1220         }
1221         dst_name = strip_namespace(dst_name);
1222
1223         if ((item = string_list_lookup(list, dst_name)) == NULL)
1224                 return;
1225
1226         cmd->skip_update = 1;
1227
1228         dst_cmd = (struct command *) item->util;
1229
1230         if (oideq(&cmd->old_oid, &dst_cmd->old_oid) &&
1231             oideq(&cmd->new_oid, &dst_cmd->new_oid))
1232                 return;
1233
1234         dst_cmd->skip_update = 1;
1235
1236         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1237                  " its target '%s' (%s..%s)",
1238                  cmd->ref_name,
1239                  find_unique_abbrev(&cmd->old_oid, DEFAULT_ABBREV),
1240                  find_unique_abbrev(&cmd->new_oid, DEFAULT_ABBREV),
1241                  dst_cmd->ref_name,
1242                  find_unique_abbrev(&dst_cmd->old_oid, DEFAULT_ABBREV),
1243                  find_unique_abbrev(&dst_cmd->new_oid, DEFAULT_ABBREV));
1244
1245         cmd->error_string = dst_cmd->error_string =
1246                 "inconsistent aliased update";
1247 }
1248
1249 static void check_aliased_update(struct command *cmd, struct string_list *list)
1250 {
1251         struct strbuf buf = STRBUF_INIT;
1252         const char *dst_name;
1253         int flag;
1254
1255         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
1256         dst_name = resolve_ref_unsafe(buf.buf, 0, NULL, &flag);
1257         check_aliased_update_internal(cmd, list, dst_name, flag);
1258         strbuf_release(&buf);
1259 }
1260
1261 static void check_aliased_updates(struct command *commands)
1262 {
1263         struct command *cmd;
1264         struct string_list ref_list = STRING_LIST_INIT_NODUP;
1265
1266         for (cmd = commands; cmd; cmd = cmd->next) {
1267                 struct string_list_item *item =
1268                         string_list_append(&ref_list, cmd->ref_name);
1269                 item->util = (void *)cmd;
1270         }
1271         string_list_sort(&ref_list);
1272
1273         for (cmd = commands; cmd; cmd = cmd->next) {
1274                 if (!cmd->error_string)
1275                         check_aliased_update(cmd, &ref_list);
1276         }
1277
1278         string_list_clear(&ref_list, 0);
1279 }
1280
1281 static int command_singleton_iterator(void *cb_data, struct object_id *oid)
1282 {
1283         struct command **cmd_list = cb_data;
1284         struct command *cmd = *cmd_list;
1285
1286         if (!cmd || is_null_oid(&cmd->new_oid))
1287                 return -1; /* end of list */
1288         *cmd_list = NULL; /* this returns only one */
1289         oidcpy(oid, &cmd->new_oid);
1290         return 0;
1291 }
1292
1293 static void set_connectivity_errors(struct command *commands,
1294                                     struct shallow_info *si)
1295 {
1296         struct command *cmd;
1297
1298         for (cmd = commands; cmd; cmd = cmd->next) {
1299                 struct command *singleton = cmd;
1300                 struct check_connected_options opt = CHECK_CONNECTED_INIT;
1301
1302                 if (shallow_update && si->shallow_ref[cmd->index])
1303                         /* to be checked in update_shallow_ref() */
1304                         continue;
1305
1306                 opt.env = tmp_objdir_env(tmp_objdir);
1307                 if (!check_connected(command_singleton_iterator, &singleton,
1308                                      &opt))
1309                         continue;
1310
1311                 cmd->error_string = "missing necessary objects";
1312         }
1313 }
1314
1315 struct iterate_data {
1316         struct command *cmds;
1317         struct shallow_info *si;
1318 };
1319
1320 static int iterate_receive_command_list(void *cb_data, struct object_id *oid)
1321 {
1322         struct iterate_data *data = cb_data;
1323         struct command **cmd_list = &data->cmds;
1324         struct command *cmd = *cmd_list;
1325
1326         for (; cmd; cmd = cmd->next) {
1327                 if (shallow_update && data->si->shallow_ref[cmd->index])
1328                         /* to be checked in update_shallow_ref() */
1329                         continue;
1330                 if (!is_null_oid(&cmd->new_oid) && !cmd->skip_update) {
1331                         oidcpy(oid, &cmd->new_oid);
1332                         *cmd_list = cmd->next;
1333                         return 0;
1334                 }
1335         }
1336         *cmd_list = NULL;
1337         return -1; /* end of list */
1338 }
1339
1340 static void reject_updates_to_hidden(struct command *commands)
1341 {
1342         struct strbuf refname_full = STRBUF_INIT;
1343         size_t prefix_len;
1344         struct command *cmd;
1345
1346         strbuf_addstr(&refname_full, get_git_namespace());
1347         prefix_len = refname_full.len;
1348
1349         for (cmd = commands; cmd; cmd = cmd->next) {
1350                 if (cmd->error_string)
1351                         continue;
1352
1353                 strbuf_setlen(&refname_full, prefix_len);
1354                 strbuf_addstr(&refname_full, cmd->ref_name);
1355
1356                 if (!ref_is_hidden(cmd->ref_name, refname_full.buf))
1357                         continue;
1358                 if (is_null_oid(&cmd->new_oid))
1359                         cmd->error_string = "deny deleting a hidden ref";
1360                 else
1361                         cmd->error_string = "deny updating a hidden ref";
1362         }
1363
1364         strbuf_release(&refname_full);
1365 }
1366
1367 static int should_process_cmd(struct command *cmd)
1368 {
1369         return !cmd->error_string && !cmd->skip_update;
1370 }
1371
1372 static void warn_if_skipped_connectivity_check(struct command *commands,
1373                                                struct shallow_info *si)
1374 {
1375         struct command *cmd;
1376         int checked_connectivity = 1;
1377
1378         for (cmd = commands; cmd; cmd = cmd->next) {
1379                 if (should_process_cmd(cmd) && si->shallow_ref[cmd->index]) {
1380                         error("BUG: connectivity check has not been run on ref %s",
1381                               cmd->ref_name);
1382                         checked_connectivity = 0;
1383                 }
1384         }
1385         if (!checked_connectivity)
1386                 BUG("connectivity check skipped???");
1387 }
1388
1389 static void execute_commands_non_atomic(struct command *commands,
1390                                         struct shallow_info *si)
1391 {
1392         struct command *cmd;
1393         struct strbuf err = STRBUF_INIT;
1394
1395         for (cmd = commands; cmd; cmd = cmd->next) {
1396                 if (!should_process_cmd(cmd))
1397                         continue;
1398
1399                 transaction = ref_transaction_begin(&err);
1400                 if (!transaction) {
1401                         rp_error("%s", err.buf);
1402                         strbuf_reset(&err);
1403                         cmd->error_string = "transaction failed to start";
1404                         continue;
1405                 }
1406
1407                 cmd->error_string = update(cmd, si);
1408
1409                 if (!cmd->error_string
1410                     && ref_transaction_commit(transaction, &err)) {
1411                         rp_error("%s", err.buf);
1412                         strbuf_reset(&err);
1413                         cmd->error_string = "failed to update ref";
1414                 }
1415                 ref_transaction_free(transaction);
1416         }
1417         strbuf_release(&err);
1418 }
1419
1420 static void execute_commands_atomic(struct command *commands,
1421                                         struct shallow_info *si)
1422 {
1423         struct command *cmd;
1424         struct strbuf err = STRBUF_INIT;
1425         const char *reported_error = "atomic push failure";
1426
1427         transaction = ref_transaction_begin(&err);
1428         if (!transaction) {
1429                 rp_error("%s", err.buf);
1430                 strbuf_reset(&err);
1431                 reported_error = "transaction failed to start";
1432                 goto failure;
1433         }
1434
1435         for (cmd = commands; cmd; cmd = cmd->next) {
1436                 if (!should_process_cmd(cmd))
1437                         continue;
1438
1439                 cmd->error_string = update(cmd, si);
1440
1441                 if (cmd->error_string)
1442                         goto failure;
1443         }
1444
1445         if (ref_transaction_commit(transaction, &err)) {
1446                 rp_error("%s", err.buf);
1447                 reported_error = "atomic transaction failed";
1448                 goto failure;
1449         }
1450         goto cleanup;
1451
1452 failure:
1453         for (cmd = commands; cmd; cmd = cmd->next)
1454                 if (!cmd->error_string)
1455                         cmd->error_string = reported_error;
1456
1457 cleanup:
1458         ref_transaction_free(transaction);
1459         strbuf_release(&err);
1460 }
1461
1462 static void execute_commands(struct command *commands,
1463                              const char *unpacker_error,
1464                              struct shallow_info *si,
1465                              const struct string_list *push_options)
1466 {
1467         struct check_connected_options opt = CHECK_CONNECTED_INIT;
1468         struct command *cmd;
1469         struct iterate_data data;
1470         struct async muxer;
1471         int err_fd = 0;
1472
1473         if (unpacker_error) {
1474                 for (cmd = commands; cmd; cmd = cmd->next)
1475                         cmd->error_string = "unpacker error";
1476                 return;
1477         }
1478
1479         if (use_sideband) {
1480                 memset(&muxer, 0, sizeof(muxer));
1481                 muxer.proc = copy_to_sideband;
1482                 muxer.in = -1;
1483                 if (!start_async(&muxer))
1484                         err_fd = muxer.in;
1485                 /* ...else, continue without relaying sideband */
1486         }
1487
1488         data.cmds = commands;
1489         data.si = si;
1490         opt.err_fd = err_fd;
1491         opt.progress = err_fd && !quiet;
1492         opt.env = tmp_objdir_env(tmp_objdir);
1493         if (check_connected(iterate_receive_command_list, &data, &opt))
1494                 set_connectivity_errors(commands, si);
1495
1496         if (use_sideband)
1497                 finish_async(&muxer);
1498
1499         reject_updates_to_hidden(commands);
1500
1501         if (run_receive_hook(commands, "pre-receive", 0, push_options)) {
1502                 for (cmd = commands; cmd; cmd = cmd->next) {
1503                         if (!cmd->error_string)
1504                                 cmd->error_string = "pre-receive hook declined";
1505                 }
1506                 return;
1507         }
1508
1509         /*
1510          * Now we'll start writing out refs, which means the objects need
1511          * to be in their final positions so that other processes can see them.
1512          */
1513         if (tmp_objdir_migrate(tmp_objdir) < 0) {
1514                 for (cmd = commands; cmd; cmd = cmd->next) {
1515                         if (!cmd->error_string)
1516                                 cmd->error_string = "unable to migrate objects to permanent storage";
1517                 }
1518                 return;
1519         }
1520         tmp_objdir = NULL;
1521
1522         check_aliased_updates(commands);
1523
1524         free(head_name_to_free);
1525         head_name = head_name_to_free = resolve_refdup("HEAD", 0, NULL, NULL);
1526
1527         if (use_atomic)
1528                 execute_commands_atomic(commands, si);
1529         else
1530                 execute_commands_non_atomic(commands, si);
1531
1532         if (shallow_update)
1533                 warn_if_skipped_connectivity_check(commands, si);
1534 }
1535
1536 static struct command **queue_command(struct command **tail,
1537                                       const char *line,
1538                                       int linelen)
1539 {
1540         struct object_id old_oid, new_oid;
1541         struct command *cmd;
1542         const char *refname;
1543         int reflen;
1544         const char *p;
1545
1546         if (parse_oid_hex(line, &old_oid, &p) ||
1547             *p++ != ' ' ||
1548             parse_oid_hex(p, &new_oid, &p) ||
1549             *p++ != ' ')
1550                 die("protocol error: expected old/new/ref, got '%s'", line);
1551
1552         refname = p;
1553         reflen = linelen - (p - line);
1554         FLEX_ALLOC_MEM(cmd, ref_name, refname, reflen);
1555         oidcpy(&cmd->old_oid, &old_oid);
1556         oidcpy(&cmd->new_oid, &new_oid);
1557         *tail = cmd;
1558         return &cmd->next;
1559 }
1560
1561 static void queue_commands_from_cert(struct command **tail,
1562                                      struct strbuf *push_cert)
1563 {
1564         const char *boc, *eoc;
1565
1566         if (*tail)
1567                 die("protocol error: got both push certificate and unsigned commands");
1568
1569         boc = strstr(push_cert->buf, "\n\n");
1570         if (!boc)
1571                 die("malformed push certificate %.*s", 100, push_cert->buf);
1572         else
1573                 boc += 2;
1574         eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1575
1576         while (boc < eoc) {
1577                 const char *eol = memchr(boc, '\n', eoc - boc);
1578                 tail = queue_command(tail, boc, eol ? eol - boc : eoc - boc);
1579                 boc = eol ? eol + 1 : eoc;
1580         }
1581 }
1582
1583 static struct command *read_head_info(struct packet_reader *reader,
1584                                       struct oid_array *shallow)
1585 {
1586         struct command *commands = NULL;
1587         struct command **p = &commands;
1588         for (;;) {
1589                 int linelen;
1590
1591                 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
1592                         break;
1593
1594                 if (reader->pktlen > 8 && starts_with(reader->line, "shallow ")) {
1595                         struct object_id oid;
1596                         if (get_oid_hex(reader->line + 8, &oid))
1597                                 die("protocol error: expected shallow sha, got '%s'",
1598                                     reader->line + 8);
1599                         oid_array_append(shallow, &oid);
1600                         continue;
1601                 }
1602
1603                 linelen = strlen(reader->line);
1604                 if (linelen < reader->pktlen) {
1605                         const char *feature_list = reader->line + linelen + 1;
1606                         if (parse_feature_request(feature_list, "report-status"))
1607                                 report_status = 1;
1608                         if (parse_feature_request(feature_list, "side-band-64k"))
1609                                 use_sideband = LARGE_PACKET_MAX;
1610                         if (parse_feature_request(feature_list, "quiet"))
1611                                 quiet = 1;
1612                         if (advertise_atomic_push
1613                             && parse_feature_request(feature_list, "atomic"))
1614                                 use_atomic = 1;
1615                         if (advertise_push_options
1616                             && parse_feature_request(feature_list, "push-options"))
1617                                 use_push_options = 1;
1618                 }
1619
1620                 if (!strcmp(reader->line, "push-cert")) {
1621                         int true_flush = 0;
1622                         int saved_options = reader->options;
1623                         reader->options &= ~PACKET_READ_CHOMP_NEWLINE;
1624
1625                         for (;;) {
1626                                 packet_reader_read(reader);
1627                                 if (reader->status == PACKET_READ_FLUSH) {
1628                                         true_flush = 1;
1629                                         break;
1630                                 }
1631                                 if (reader->status != PACKET_READ_NORMAL) {
1632                                         die("protocol error: got an unexpected packet");
1633                                 }
1634                                 if (!strcmp(reader->line, "push-cert-end\n"))
1635                                         break; /* end of cert */
1636                                 strbuf_addstr(&push_cert, reader->line);
1637                         }
1638                         reader->options = saved_options;
1639
1640                         if (true_flush)
1641                                 break;
1642                         continue;
1643                 }
1644
1645                 p = queue_command(p, reader->line, linelen);
1646         }
1647
1648         if (push_cert.len)
1649                 queue_commands_from_cert(p, &push_cert);
1650
1651         return commands;
1652 }
1653
1654 static void read_push_options(struct packet_reader *reader,
1655                               struct string_list *options)
1656 {
1657         while (1) {
1658                 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
1659                         break;
1660
1661                 string_list_append(options, reader->line);
1662         }
1663 }
1664
1665 static const char *parse_pack_header(struct pack_header *hdr)
1666 {
1667         switch (read_pack_header(0, hdr)) {
1668         case PH_ERROR_EOF:
1669                 return "eof before pack header was fully read";
1670
1671         case PH_ERROR_PACK_SIGNATURE:
1672                 return "protocol error (pack signature mismatch detected)";
1673
1674         case PH_ERROR_PROTOCOL:
1675                 return "protocol error (pack version unsupported)";
1676
1677         default:
1678                 return "unknown error in parse_pack_header";
1679
1680         case 0:
1681                 return NULL;
1682         }
1683 }
1684
1685 static const char *pack_lockfile;
1686
1687 static void push_header_arg(struct argv_array *args, struct pack_header *hdr)
1688 {
1689         argv_array_pushf(args, "--pack_header=%"PRIu32",%"PRIu32,
1690                         ntohl(hdr->hdr_version), ntohl(hdr->hdr_entries));
1691 }
1692
1693 static const char *unpack(int err_fd, struct shallow_info *si)
1694 {
1695         struct pack_header hdr;
1696         const char *hdr_err;
1697         int status;
1698         struct child_process child = CHILD_PROCESS_INIT;
1699         int fsck_objects = (receive_fsck_objects >= 0
1700                             ? receive_fsck_objects
1701                             : transfer_fsck_objects >= 0
1702                             ? transfer_fsck_objects
1703                             : 0);
1704
1705         hdr_err = parse_pack_header(&hdr);
1706         if (hdr_err) {
1707                 if (err_fd > 0)
1708                         close(err_fd);
1709                 return hdr_err;
1710         }
1711
1712         if (si->nr_ours || si->nr_theirs) {
1713                 alt_shallow_file = setup_temporary_shallow(si->shallow);
1714                 argv_array_push(&child.args, "--shallow-file");
1715                 argv_array_push(&child.args, alt_shallow_file);
1716         }
1717
1718         tmp_objdir = tmp_objdir_create();
1719         if (!tmp_objdir) {
1720                 if (err_fd > 0)
1721                         close(err_fd);
1722                 return "unable to create temporary object directory";
1723         }
1724         child.env = tmp_objdir_env(tmp_objdir);
1725
1726         /*
1727          * Normally we just pass the tmp_objdir environment to the child
1728          * processes that do the heavy lifting, but we may need to see these
1729          * objects ourselves to set up shallow information.
1730          */
1731         tmp_objdir_add_as_alternate(tmp_objdir);
1732
1733         if (ntohl(hdr.hdr_entries) < unpack_limit) {
1734                 argv_array_push(&child.args, "unpack-objects");
1735                 push_header_arg(&child.args, &hdr);
1736                 if (quiet)
1737                         argv_array_push(&child.args, "-q");
1738                 if (fsck_objects)
1739                         argv_array_pushf(&child.args, "--strict%s",
1740                                 fsck_msg_types.buf);
1741                 if (max_input_size)
1742                         argv_array_pushf(&child.args, "--max-input-size=%"PRIuMAX,
1743                                 (uintmax_t)max_input_size);
1744                 child.no_stdout = 1;
1745                 child.err = err_fd;
1746                 child.git_cmd = 1;
1747                 status = run_command(&child);
1748                 if (status)
1749                         return "unpack-objects abnormal exit";
1750         } else {
1751                 char hostname[HOST_NAME_MAX + 1];
1752
1753                 argv_array_pushl(&child.args, "index-pack", "--stdin", NULL);
1754                 push_header_arg(&child.args, &hdr);
1755
1756                 if (xgethostname(hostname, sizeof(hostname)))
1757                         xsnprintf(hostname, sizeof(hostname), "localhost");
1758                 argv_array_pushf(&child.args,
1759                                  "--keep=receive-pack %"PRIuMAX" on %s",
1760                                  (uintmax_t)getpid(),
1761                                  hostname);
1762
1763                 if (!quiet && err_fd)
1764                         argv_array_push(&child.args, "--show-resolving-progress");
1765                 if (use_sideband)
1766                         argv_array_push(&child.args, "--report-end-of-input");
1767                 if (fsck_objects)
1768                         argv_array_pushf(&child.args, "--strict%s",
1769                                 fsck_msg_types.buf);
1770                 if (!reject_thin)
1771                         argv_array_push(&child.args, "--fix-thin");
1772                 if (max_input_size)
1773                         argv_array_pushf(&child.args, "--max-input-size=%"PRIuMAX,
1774                                 (uintmax_t)max_input_size);
1775                 child.out = -1;
1776                 child.err = err_fd;
1777                 child.git_cmd = 1;
1778                 status = start_command(&child);
1779                 if (status)
1780                         return "index-pack fork failed";
1781                 pack_lockfile = index_pack_lockfile(child.out);
1782                 close(child.out);
1783                 status = finish_command(&child);
1784                 if (status)
1785                         return "index-pack abnormal exit";
1786                 reprepare_packed_git(the_repository);
1787         }
1788         return NULL;
1789 }
1790
1791 static const char *unpack_with_sideband(struct shallow_info *si)
1792 {
1793         struct async muxer;
1794         const char *ret;
1795
1796         if (!use_sideband)
1797                 return unpack(0, si);
1798
1799         use_keepalive = KEEPALIVE_AFTER_NUL;
1800         memset(&muxer, 0, sizeof(muxer));
1801         muxer.proc = copy_to_sideband;
1802         muxer.in = -1;
1803         if (start_async(&muxer))
1804                 return NULL;
1805
1806         ret = unpack(muxer.in, si);
1807
1808         finish_async(&muxer);
1809         return ret;
1810 }
1811
1812 static void prepare_shallow_update(struct shallow_info *si)
1813 {
1814         int i, j, k, bitmap_size = DIV_ROUND_UP(si->ref->nr, 32);
1815
1816         ALLOC_ARRAY(si->used_shallow, si->shallow->nr);
1817         assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1818
1819         si->need_reachability_test =
1820                 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1821         si->reachable =
1822                 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1823         si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1824
1825         for (i = 0; i < si->nr_ours; i++)
1826                 si->need_reachability_test[si->ours[i]] = 1;
1827
1828         for (i = 0; i < si->shallow->nr; i++) {
1829                 if (!si->used_shallow[i])
1830                         continue;
1831                 for (j = 0; j < bitmap_size; j++) {
1832                         if (!si->used_shallow[i][j])
1833                                 continue;
1834                         si->need_reachability_test[i]++;
1835                         for (k = 0; k < 32; k++)
1836                                 if (si->used_shallow[i][j] & (1U << k))
1837                                         si->shallow_ref[j * 32 + k]++;
1838                 }
1839
1840                 /*
1841                  * true for those associated with some refs and belong
1842                  * in "ours" list aka "step 7 not done yet"
1843                  */
1844                 si->need_reachability_test[i] =
1845                         si->need_reachability_test[i] > 1;
1846         }
1847
1848         /*
1849          * keep hooks happy by forcing a temporary shallow file via
1850          * env variable because we can't add --shallow-file to every
1851          * command. check_connected() will be done with
1852          * true .git/shallow though.
1853          */
1854         setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1855 }
1856
1857 static void update_shallow_info(struct command *commands,
1858                                 struct shallow_info *si,
1859                                 struct oid_array *ref)
1860 {
1861         struct command *cmd;
1862         int *ref_status;
1863         remove_nonexistent_theirs_shallow(si);
1864         if (!si->nr_ours && !si->nr_theirs) {
1865                 shallow_update = 0;
1866                 return;
1867         }
1868
1869         for (cmd = commands; cmd; cmd = cmd->next) {
1870                 if (is_null_oid(&cmd->new_oid))
1871                         continue;
1872                 oid_array_append(ref, &cmd->new_oid);
1873                 cmd->index = ref->nr - 1;
1874         }
1875         si->ref = ref;
1876
1877         if (shallow_update) {
1878                 prepare_shallow_update(si);
1879                 return;
1880         }
1881
1882         ALLOC_ARRAY(ref_status, ref->nr);
1883         assign_shallow_commits_to_refs(si, NULL, ref_status);
1884         for (cmd = commands; cmd; cmd = cmd->next) {
1885                 if (is_null_oid(&cmd->new_oid))
1886                         continue;
1887                 if (ref_status[cmd->index]) {
1888                         cmd->error_string = "shallow update not allowed";
1889                         cmd->skip_update = 1;
1890                 }
1891         }
1892         free(ref_status);
1893 }
1894
1895 static void report(struct command *commands, const char *unpack_status)
1896 {
1897         struct command *cmd;
1898         struct strbuf buf = STRBUF_INIT;
1899
1900         packet_buf_write(&buf, "unpack %s\n",
1901                          unpack_status ? unpack_status : "ok");
1902         for (cmd = commands; cmd; cmd = cmd->next) {
1903                 if (!cmd->error_string)
1904                         packet_buf_write(&buf, "ok %s\n",
1905                                          cmd->ref_name);
1906                 else
1907                         packet_buf_write(&buf, "ng %s %s\n",
1908                                          cmd->ref_name, cmd->error_string);
1909         }
1910         packet_buf_flush(&buf);
1911
1912         if (use_sideband)
1913                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1914         else
1915                 write_or_die(1, buf.buf, buf.len);
1916         strbuf_release(&buf);
1917 }
1918
1919 static int delete_only(struct command *commands)
1920 {
1921         struct command *cmd;
1922         for (cmd = commands; cmd; cmd = cmd->next) {
1923                 if (!is_null_oid(&cmd->new_oid))
1924                         return 0;
1925         }
1926         return 1;
1927 }
1928
1929 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1930 {
1931         int advertise_refs = 0;
1932         struct command *commands;
1933         struct oid_array shallow = OID_ARRAY_INIT;
1934         struct oid_array ref = OID_ARRAY_INIT;
1935         struct shallow_info si;
1936         struct packet_reader reader;
1937
1938         struct option options[] = {
1939                 OPT__QUIET(&quiet, N_("quiet")),
1940                 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc, NULL),
1941                 OPT_HIDDEN_BOOL(0, "advertise-refs", &advertise_refs, NULL),
1942                 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin, NULL),
1943                 OPT_END()
1944         };
1945
1946         packet_trace_identity("receive-pack");
1947
1948         argc = parse_options(argc, argv, prefix, options, receive_pack_usage, 0);
1949
1950         if (argc > 1)
1951                 usage_msg_opt(_("Too many arguments."), receive_pack_usage, options);
1952         if (argc == 0)
1953                 usage_msg_opt(_("You must specify a directory."), receive_pack_usage, options);
1954
1955         service_dir = argv[0];
1956
1957         setup_path();
1958
1959         if (!enter_repo(service_dir, 0))
1960                 die("'%s' does not appear to be a git repository", service_dir);
1961
1962         git_config(receive_pack_config, NULL);
1963         if (cert_nonce_seed)
1964                 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1965
1966         if (0 <= transfer_unpack_limit)
1967                 unpack_limit = transfer_unpack_limit;
1968         else if (0 <= receive_unpack_limit)
1969                 unpack_limit = receive_unpack_limit;
1970
1971         switch (determine_protocol_version_server()) {
1972         case protocol_v2:
1973                 /*
1974                  * push support for protocol v2 has not been implemented yet,
1975                  * so ignore the request to use v2 and fallback to using v0.
1976                  */
1977                 break;
1978         case protocol_v1:
1979                 /*
1980                  * v1 is just the original protocol with a version string,
1981                  * so just fall through after writing the version string.
1982                  */
1983                 if (advertise_refs || !stateless_rpc)
1984                         packet_write_fmt(1, "version 1\n");
1985
1986                 /* fallthrough */
1987         case protocol_v0:
1988                 break;
1989         case protocol_unknown_version:
1990                 BUG("unknown protocol version");
1991         }
1992
1993         if (advertise_refs || !stateless_rpc) {
1994                 write_head_info();
1995         }
1996         if (advertise_refs)
1997                 return 0;
1998
1999         packet_reader_init(&reader, 0, NULL, 0,
2000                            PACKET_READ_CHOMP_NEWLINE |
2001                            PACKET_READ_DIE_ON_ERR_PACKET);
2002
2003         if ((commands = read_head_info(&reader, &shallow)) != NULL) {
2004                 const char *unpack_status = NULL;
2005                 struct string_list push_options = STRING_LIST_INIT_DUP;
2006
2007                 if (use_push_options)
2008                         read_push_options(&reader, &push_options);
2009                 if (!check_cert_push_options(&push_options)) {
2010                         struct command *cmd;
2011                         for (cmd = commands; cmd; cmd = cmd->next)
2012                                 cmd->error_string = "inconsistent push options";
2013                 }
2014
2015                 prepare_shallow_info(&si, &shallow);
2016                 if (!si.nr_ours && !si.nr_theirs)
2017                         shallow_update = 0;
2018                 if (!delete_only(commands)) {
2019                         unpack_status = unpack_with_sideband(&si);
2020                         update_shallow_info(commands, &si, &ref);
2021                 }
2022                 use_keepalive = KEEPALIVE_ALWAYS;
2023                 execute_commands(commands, unpack_status, &si,
2024                                  &push_options);
2025                 if (pack_lockfile)
2026                         unlink_or_warn(pack_lockfile);
2027                 if (report_status)
2028                         report(commands, unpack_status);
2029                 run_receive_hook(commands, "post-receive", 1,
2030                                  &push_options);
2031                 run_update_post_hook(commands);
2032                 string_list_clear(&push_options, 0);
2033                 if (auto_gc) {
2034                         const char *argv_gc_auto[] = {
2035                                 "gc", "--auto", "--quiet", NULL,
2036                         };
2037                         struct child_process proc = CHILD_PROCESS_INIT;
2038
2039                         proc.no_stdin = 1;
2040                         proc.stdout_to_stderr = 1;
2041                         proc.err = use_sideband ? -1 : 0;
2042                         proc.git_cmd = 1;
2043                         proc.argv = argv_gc_auto;
2044
2045                         close_object_store(the_repository->objects);
2046                         if (!start_command(&proc)) {
2047                                 if (use_sideband)
2048                                         copy_to_sideband(proc.err, -1, NULL);
2049                                 finish_command(&proc);
2050                         }
2051                 }
2052                 if (auto_update_server_info)
2053                         update_server_info(0);
2054                 clear_shallow_info(&si);
2055         }
2056         if (use_sideband)
2057                 packet_flush(1);
2058         oid_array_clear(&shallow);
2059         oid_array_clear(&ref);
2060         free((void *)push_cert_nonce);
2061         return 0;
2062 }