builtin/receive-pack.c

   1 #include "builtin.h"
   2 #include "lockfile.h"
   3 #include "pack.h"
   4 #include "refs.h"
   5 #include "pkt-line.h"
   6 #include "sideband.h"
   7 #include "run-command.h"
   8 #include "exec_cmd.h"
   9 #include "commit.h"
  10 #include "object.h"
  11 #include "remote.h"
  12 #include "connect.h"
  13 #include "transport.h"
  14 #include "string-list.h"
  15 #include "sha1-array.h"
  16 #include "connected.h"
  17 #include "argv-array.h"
  18 #include "version.h"
  19 #include "tag.h"
  20 #include "gpg-interface.h"
  21 #include "sigchain.h"
  22
  23 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
  24
  25 enum deny_action {
  26         DENY_UNCONFIGURED,
  27         DENY_IGNORE,
  28         DENY_WARN,
  29         DENY_REFUSE
  30 };
  31
  32 static int deny_deletes;
  33 static int deny_non_fast_forwards;
  34 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
  35 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
  36 static int receive_fsck_objects = -1;
  37 static int transfer_fsck_objects = -1;
  38 static int receive_unpack_limit = -1;
  39 static int transfer_unpack_limit = -1;
  40 static int unpack_limit = 100;
  41 static int report_status;
  42 static int use_sideband;
  43 static int quiet;
  44 static int prefer_ofs_delta = 1;
  45 static int auto_update_server_info;
  46 static int auto_gc = 1;
  47 static int fix_thin = 1;
  48 static int stateless_rpc;
  49 static const char *service_dir;
  50 static const char *head_name;
  51 static void *head_name_to_free;
  52 static int sent_capabilities;
  53 static int shallow_update;
  54 static const char *alt_shallow_file;
  55 static struct strbuf push_cert = STRBUF_INIT;
  56 static unsigned char push_cert_sha1[20];
  57 static struct signature_check sigcheck;
  58 static const char *push_cert_nonce;
  59 static const char *cert_nonce_seed;
  60
  61 static const char *NONCE_UNSOLICITED = "UNSOLICITED";
  62 static const char *NONCE_BAD = "BAD";
  63 static const char *NONCE_MISSING = "MISSING";
  64 static const char *NONCE_OK = "OK";
  65 static const char *NONCE_SLOP = "SLOP";
  66 static const char *nonce_status;
  67 static long nonce_stamp_slop;
  68 static unsigned long nonce_stamp_slop_limit;
  69
  70 static enum deny_action parse_deny_action(const char *var, const char *value)
  71 {
  72         if (value) {
  73                 if (!strcasecmp(value, "ignore"))
  74                         return DENY_IGNORE;
  75                 if (!strcasecmp(value, "warn"))
  76                         return DENY_WARN;
  77                 if (!strcasecmp(value, "refuse"))
  78                         return DENY_REFUSE;
  79         }
  80         if (git_config_bool(var, value))
  81                 return DENY_REFUSE;
  82         return DENY_IGNORE;
  83 }
  84
  85 static int receive_pack_config(const char *var, const char *value, void *cb)
  86 {
  87         int status = parse_hide_refs_config(var, value, "receive");
  88
  89         if (status)
  90                 return status;
  91
  92         if (strcmp(var, "receive.denydeletes") == 0) {
  93                 deny_deletes = git_config_bool(var, value);
  94                 return 0;
  95         }
  96
  97         if (strcmp(var, "receive.denynonfastforwards") == 0) {
  98                 deny_non_fast_forwards = git_config_bool(var, value);
  99                 return 0;
 100         }
 101
 102         if (strcmp(var, "receive.unpacklimit") == 0) {
 103                 receive_unpack_limit = git_config_int(var, value);
 104                 return 0;
 105         }
 106
 107         if (strcmp(var, "transfer.unpacklimit") == 0) {
 108                 transfer_unpack_limit = git_config_int(var, value);
 109                 return 0;
 110         }
 111
 112         if (strcmp(var, "receive.fsckobjects") == 0) {
 113                 receive_fsck_objects = git_config_bool(var, value);
 114                 return 0;
 115         }
 116
 117         if (strcmp(var, "transfer.fsckobjects") == 0) {
 118                 transfer_fsck_objects = git_config_bool(var, value);
 119                 return 0;
 120         }
 121
 122         if (!strcmp(var, "receive.denycurrentbranch")) {
 123                 deny_current_branch = parse_deny_action(var, value);
 124                 return 0;
 125         }
 126
 127         if (strcmp(var, "receive.denydeletecurrent") == 0) {
 128                 deny_delete_current = parse_deny_action(var, value);
 129                 return 0;
 130         }
 131
 132         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 133                 prefer_ofs_delta = git_config_bool(var, value);
 134                 return 0;
 135         }
 136
 137         if (strcmp(var, "receive.updateserverinfo") == 0) {
 138                 auto_update_server_info = git_config_bool(var, value);
 139                 return 0;
 140         }
 141
 142         if (strcmp(var, "receive.autogc") == 0) {
 143                 auto_gc = git_config_bool(var, value);
 144                 return 0;
 145         }
 146
 147         if (strcmp(var, "receive.shallowupdate") == 0) {
 148                 shallow_update = git_config_bool(var, value);
 149                 return 0;
 150         }
 151
 152         if (strcmp(var, "receive.certnonceseed") == 0)
 153                 return git_config_string(&cert_nonce_seed, var, value);
 154
 155         if (strcmp(var, "receive.certnonceslop") == 0) {
 156                 nonce_stamp_slop_limit = git_config_ulong(var, value);
 157                 return 0;
 158         }
 159
 160         return git_default_config(var, value, cb);
 161 }
 162
 163 static void show_ref(const char *path, const unsigned char *sha1)
 164 {
 165         if (ref_is_hidden(path))
 166                 return;
 167
 168         if (sent_capabilities) {
 169                 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 170         } else {
 171                 struct strbuf cap = STRBUF_INIT;
 172
 173                 strbuf_addstr(&cap,
 174                               "report-status delete-refs side-band-64k quiet");
 175                 if (prefer_ofs_delta)
 176                         strbuf_addstr(&cap, " ofs-delta");
 177                 if (push_cert_nonce)
 178                         strbuf_addf(&cap, " push-cert=%s", push_cert_nonce);
 179                 strbuf_addf(&cap, " agent=%s", git_user_agent_sanitized());
 180                 packet_write(1, "%s %s%c%s\n",
 181                              sha1_to_hex(sha1), path, 0, cap.buf);
 182                 strbuf_release(&cap);
 183                 sent_capabilities = 1;
 184         }
 185 }
 186
 187 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
 188 {
 189         path = strip_namespace(path);
 190         /*
 191          * Advertise refs outside our current namespace as ".have"
 192          * refs, so that the client can use them to minimize data
 193          * transfer but will otherwise ignore them. This happens to
 194          * cover ".have" that are thrown in by add_one_alternate_ref()
 195          * to mark histories that are complete in our alternates as
 196          * well.
 197          */
 198         if (!path)
 199                 path = ".have";
 200         show_ref(path, sha1);
 201         return 0;
 202 }
 203
 204 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 205 {
 206         show_ref(".have", sha1);
 207 }
 208
 209 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 210 {
 211         struct sha1_array *sa = data;
 212         sha1_array_append(sa, ref->old_sha1);
 213 }
 214
 215 static void write_head_info(void)
 216 {
 217         struct sha1_array sa = SHA1_ARRAY_INIT;
 218         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 219         sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
 220         sha1_array_clear(&sa);
 221         for_each_ref(show_ref_cb, NULL);
 222         if (!sent_capabilities)
 223                 show_ref("capabilities^{}", null_sha1);
 224
 225         advertise_shallow_grafts(1);
 226
 227         /* EOF */
 228         packet_flush(1);
 229 }
 230
 231 struct command {
 232         struct command *next;
 233         const char *error_string;
 234         unsigned int skip_update:1,
 235                      did_not_exist:1;
 236         int index;
 237         unsigned char old_sha1[20];
 238         unsigned char new_sha1[20];
 239         char ref_name[FLEX_ARRAY]; /* more */
 240 };
 241
 242 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 243 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 244
 245 static void report_message(const char *prefix, const char *err, va_list params)
 246 {
 247         int sz = strlen(prefix);
 248         char msg[4096];
 249
 250         strncpy(msg, prefix, sz);
 251         sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 252         if (sz > (sizeof(msg) - 1))
 253                 sz = sizeof(msg) - 1;
 254         msg[sz++] = '\n';
 255
 256         if (use_sideband)
 257                 send_sideband(1, 2, msg, sz, use_sideband);
 258         else
 259                 xwrite(2, msg, sz);
 260 }
 261
 262 static void rp_warning(const char *err, ...)
 263 {
 264         va_list params;
 265         va_start(params, err);
 266         report_message("warning: ", err, params);
 267         va_end(params);
 268 }
 269
 270 static void rp_error(const char *err, ...)
 271 {
 272         va_list params;
 273         va_start(params, err);
 274         report_message("error: ", err, params);
 275         va_end(params);
 276 }
 277
 278 static int copy_to_sideband(int in, int out, void *arg)
 279 {
 280         char data[128];
 281         while (1) {
 282                 ssize_t sz = xread(in, data, sizeof(data));
 283                 if (sz <= 0)
 284                         break;
 285                 send_sideband(1, 2, data, sz, use_sideband);
 286         }
 287         close(in);
 288         return 0;
 289 }
 290
 291 #define HMAC_BLOCK_SIZE 64
 292
 293 static void hmac_sha1(unsigned char *out,
 294                       const char *key_in, size_t key_len,
 295                       const char *text, size_t text_len)
 296 {
 297         unsigned char key[HMAC_BLOCK_SIZE];
 298         unsigned char k_ipad[HMAC_BLOCK_SIZE];
 299         unsigned char k_opad[HMAC_BLOCK_SIZE];
 300         int i;
 301         git_SHA_CTX ctx;
 302
 303         /* RFC 2104 2. (1) */
 304         memset(key, '\0', HMAC_BLOCK_SIZE);
 305         if (HMAC_BLOCK_SIZE < key_len) {
 306                 git_SHA1_Init(&ctx);
 307                 git_SHA1_Update(&ctx, key_in, key_len);
 308                 git_SHA1_Final(key, &ctx);
 309         } else {
 310                 memcpy(key, key_in, key_len);
 311         }
 312
 313         /* RFC 2104 2. (2) & (5) */
 314         for (i = 0; i < sizeof(key); i++) {
 315                 k_ipad[i] = key[i] ^ 0x36;
 316                 k_opad[i] = key[i] ^ 0x5c;
 317         }
 318
 319         /* RFC 2104 2. (3) & (4) */
 320         git_SHA1_Init(&ctx);
 321         git_SHA1_Update(&ctx, k_ipad, sizeof(k_ipad));
 322         git_SHA1_Update(&ctx, text, text_len);
 323         git_SHA1_Final(out, &ctx);
 324
 325         /* RFC 2104 2. (6) & (7) */
 326         git_SHA1_Init(&ctx);
 327         git_SHA1_Update(&ctx, k_opad, sizeof(k_opad));
 328         git_SHA1_Update(&ctx, out, 20);
 329         git_SHA1_Final(out, &ctx);
 330 }
 331
 332 static char *prepare_push_cert_nonce(const char *path, unsigned long stamp)
 333 {
 334         struct strbuf buf = STRBUF_INIT;
 335         unsigned char sha1[20];
 336
 337         strbuf_addf(&buf, "%s:%lu", path, stamp);
 338         hmac_sha1(sha1, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));;
 339         strbuf_release(&buf);
 340
 341         /* RFC 2104 5. HMAC-SHA1-80 */
 342         strbuf_addf(&buf, "%lu-%.*s", stamp, 20, sha1_to_hex(sha1));
 343         return strbuf_detach(&buf, NULL);
 344 }
 345
 346 /*
 347  * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
 348  * after dropping "_commit" from its name and possibly moving it out
 349  * of commit.c
 350  */
 351 static char *find_header(const char *msg, size_t len, const char *key)
 352 {
 353         int key_len = strlen(key);
 354         const char *line = msg;
 355
 356         while (line && line < msg + len) {
 357                 const char *eol = strchrnul(line, '\n');
 358
 359                 if ((msg + len <= eol) || line == eol)
 360                         return NULL;
 361                 if (line + key_len < eol &&
 362                     !memcmp(line, key, key_len) && line[key_len] == ' ') {
 363                         int offset = key_len + 1;
 364                         return xmemdupz(line + offset, (eol - line) - offset);
 365                 }
 366                 line = *eol ? eol + 1 : NULL;
 367         }
 368         return NULL;
 369 }
 370
 371 static const char *check_nonce(const char *buf, size_t len)
 372 {
 373         char *nonce = find_header(buf, len, "nonce");
 374         unsigned long stamp, ostamp;
 375         char *bohmac, *expect = NULL;
 376         const char *retval = NONCE_BAD;
 377
 378         if (!nonce) {
 379                 retval = NONCE_MISSING;
 380                 goto leave;
 381         } else if (!push_cert_nonce) {
 382                 retval = NONCE_UNSOLICITED;
 383                 goto leave;
 384         } else if (!strcmp(push_cert_nonce, nonce)) {
 385                 retval = NONCE_OK;
 386                 goto leave;
 387         }
 388
 389         if (!stateless_rpc) {
 390                 /* returned nonce MUST match what we gave out earlier */
 391                 retval = NONCE_BAD;
 392                 goto leave;
 393         }
 394
 395         /*
 396          * In stateless mode, we may be receiving a nonce issued by
 397          * another instance of the server that serving the same
 398          * repository, and the timestamps may not match, but the
 399          * nonce-seed and dir should match, so we can recompute and
 400          * report the time slop.
 401          *
 402          * In addition, when a nonce issued by another instance has
 403          * timestamp within receive.certnonceslop seconds, we pretend
 404          * as if we issued that nonce when reporting to the hook.
 405          */
 406
 407         /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
 408         if (*nonce <= '0' || '9' < *nonce) {
 409                 retval = NONCE_BAD;
 410                 goto leave;
 411         }
 412         stamp = strtoul(nonce, &bohmac, 10);
 413         if (bohmac == nonce || bohmac[0] != '-') {
 414                 retval = NONCE_BAD;
 415                 goto leave;
 416         }
 417
 418         expect = prepare_push_cert_nonce(service_dir, stamp);
 419         if (strcmp(expect, nonce)) {
 420                 /* Not what we would have signed earlier */
 421                 retval = NONCE_BAD;
 422                 goto leave;
 423         }
 424
 425         /*
 426          * By how many seconds is this nonce stale?  Negative value
 427          * would mean it was issued by another server with its clock
 428          * skewed in the future.
 429          */
 430         ostamp = strtoul(push_cert_nonce, NULL, 10);
 431         nonce_stamp_slop = (long)ostamp - (long)stamp;
 432
 433         if (nonce_stamp_slop_limit &&
 434             abs(nonce_stamp_slop) <= nonce_stamp_slop_limit) {
 435                 /*
 436                  * Pretend as if the received nonce (which passes the
 437                  * HMAC check, so it is not a forged by third-party)
 438                  * is what we issued.
 439                  */
 440                 free((void *)push_cert_nonce);
 441                 push_cert_nonce = xstrdup(nonce);
 442                 retval = NONCE_OK;
 443         } else {
 444                 retval = NONCE_SLOP;
 445         }
 446
 447 leave:
 448         free(nonce);
 449         free(expect);
 450         return retval;
 451 }
 452
 453 static void prepare_push_cert_sha1(struct child_process *proc)
 454 {
 455         static int already_done;
 456
 457         if (!push_cert.len)
 458                 return;
 459
 460         if (!already_done) {
 461                 struct strbuf gpg_output = STRBUF_INIT;
 462                 struct strbuf gpg_status = STRBUF_INIT;
 463                 int bogs /* beginning_of_gpg_sig */;
 464
 465                 already_done = 1;
 466                 if (write_sha1_file(push_cert.buf, push_cert.len, "blob", push_cert_sha1))
 467                         hashclr(push_cert_sha1);
 468
 469                 memset(&sigcheck, '\0', sizeof(sigcheck));
 470                 sigcheck.result = 'N';
 471
 472                 bogs = parse_signature(push_cert.buf, push_cert.len);
 473                 if (verify_signed_buffer(push_cert.buf, bogs,
 474                                          push_cert.buf + bogs, push_cert.len - bogs,
 475                                          &gpg_output, &gpg_status) < 0) {
 476                         ; /* error running gpg */
 477                 } else {
 478                         sigcheck.payload = push_cert.buf;
 479                         sigcheck.gpg_output = gpg_output.buf;
 480                         sigcheck.gpg_status = gpg_status.buf;
 481                         parse_gpg_output(&sigcheck);
 482                 }
 483
 484                 strbuf_release(&gpg_output);
 485                 strbuf_release(&gpg_status);
 486                 nonce_status = check_nonce(push_cert.buf, bogs);
 487         }
 488         if (!is_null_sha1(push_cert_sha1)) {
 489                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT=%s",
 490                                  sha1_to_hex(push_cert_sha1));
 491                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_SIGNER=%s",
 492                                  sigcheck.signer ? sigcheck.signer : "");
 493                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_KEY=%s",
 494                                  sigcheck.key ? sigcheck.key : "");
 495                 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_STATUS=%c",
 496                                  sigcheck.result);
 497                 if (push_cert_nonce) {
 498                         argv_array_pushf(&proc->env_array,
 499                                          "GIT_PUSH_CERT_NONCE=%s",
 500                                          push_cert_nonce);
 501                         argv_array_pushf(&proc->env_array,
 502                                          "GIT_PUSH_CERT_NONCE_STATUS=%s",
 503                                          nonce_status);
 504                         if (nonce_status == NONCE_SLOP)
 505                                 argv_array_pushf(&proc->env_array,
 506                                                  "GIT_PUSH_CERT_NONCE_SLOP=%ld",
 507                                                  nonce_stamp_slop);
 508                 }
 509         }
 510 }
 511
 512 typedef int (*feed_fn)(void *, const char **, size_t *);
 513 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 514 {
 515         struct child_process proc = CHILD_PROCESS_INIT;
 516         struct async muxer;
 517         const char *argv[2];
 518         int code;
 519
 520         argv[0] = find_hook(hook_name);
 521         if (!argv[0])
 522                 return 0;
 523
 524         argv[1] = NULL;
 525
 526         proc.argv = argv;
 527         proc.in = -1;
 528         proc.stdout_to_stderr = 1;
 529
 530         prepare_push_cert_sha1(&proc);
 531
 532         if (use_sideband) {
 533                 memset(&muxer, 0, sizeof(muxer));
 534                 muxer.proc = copy_to_sideband;
 535                 muxer.in = -1;
 536                 code = start_async(&muxer);
 537                 if (code)
 538                         return code;
 539                 proc.err = muxer.in;
 540         }
 541
 542         code = start_command(&proc);
 543         if (code) {
 544                 if (use_sideband)
 545                         finish_async(&muxer);
 546                 return code;
 547         }
 548
 549         sigchain_push(SIGPIPE, SIG_IGN);
 550
 551         while (1) {
 552                 const char *buf;
 553                 size_t n;
 554                 if (feed(feed_state, &buf, &n))
 555                         break;
 556                 if (write_in_full(proc.in, buf, n) != n)
 557                         break;
 558         }
 559         close(proc.in);
 560         if (use_sideband)
 561                 finish_async(&muxer);
 562
 563         sigchain_pop(SIGPIPE);
 564
 565         return finish_command(&proc);
 566 }
 567
 568 struct receive_hook_feed_state {
 569         struct command *cmd;
 570         int skip_broken;
 571         struct strbuf buf;
 572 };
 573
 574 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 575 {
 576         struct receive_hook_feed_state *state = state_;
 577         struct command *cmd = state->cmd;
 578
 579         while (cmd &&
 580                state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 581                 cmd = cmd->next;
 582         if (!cmd)
 583                 return -1; /* EOF */
 584         strbuf_reset(&state->buf);
 585         strbuf_addf(&state->buf, "%s %s %s\n",
 586                     sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 587                     cmd->ref_name);
 588         state->cmd = cmd->next;
 589         if (bufp) {
 590                 *bufp = state->buf.buf;
 591                 *sizep = state->buf.len;
 592         }
 593         return 0;
 594 }
 595
 596 static int run_receive_hook(struct command *commands, const char *hook_name,
 597                             int skip_broken)
 598 {
 599         struct receive_hook_feed_state state;
 600         int status;
 601
 602         strbuf_init(&state.buf, 0);
 603         state.cmd = commands;
 604         state.skip_broken = skip_broken;
 605         if (feed_receive_hook(&state, NULL, NULL))
 606                 return 0;
 607         state.cmd = commands;
 608         status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 609         strbuf_release(&state.buf);
 610         return status;
 611 }
 612
 613 static int run_update_hook(struct command *cmd)
 614 {
 615         const char *argv[5];
 616         struct child_process proc = CHILD_PROCESS_INIT;
 617         int code;
 618
 619         argv[0] = find_hook("update");
 620         if (!argv[0])
 621                 return 0;
 622
 623         argv[1] = cmd->ref_name;
 624         argv[2] = sha1_to_hex(cmd->old_sha1);
 625         argv[3] = sha1_to_hex(cmd->new_sha1);
 626         argv[4] = NULL;
 627
 628         proc.no_stdin = 1;
 629         proc.stdout_to_stderr = 1;
 630         proc.err = use_sideband ? -1 : 0;
 631         proc.argv = argv;
 632
 633         code = start_command(&proc);
 634         if (code)
 635                 return code;
 636         if (use_sideband)
 637                 copy_to_sideband(proc.err, -1, NULL);
 638         return finish_command(&proc);
 639 }
 640
 641 static int is_ref_checked_out(const char *ref)
 642 {
 643         if (is_bare_repository())
 644                 return 0;
 645
 646         if (!head_name)
 647                 return 0;
 648         return !strcmp(head_name, ref);
 649 }
 650
 651 static char *refuse_unconfigured_deny_msg[] = {
 652         "By default, updating the current branch in a non-bare repository",
 653         "is denied, because it will make the index and work tree inconsistent",
 654         "with what you pushed, and will require 'git reset --hard' to match",
 655         "the work tree to HEAD.",
 656         "",
 657         "You can set 'receive.denyCurrentBranch' configuration variable to",
 658         "'ignore' or 'warn' in the remote repository to allow pushing into",
 659         "its current branch; however, this is not recommended unless you",
 660         "arranged to update its work tree to match what you pushed in some",
 661         "other way.",
 662         "",
 663         "To squelch this message and still keep the default behaviour, set",
 664         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 665 };
 666
 667 static void refuse_unconfigured_deny(void)
 668 {
 669         int i;
 670         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 671                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 672 }
 673
 674 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 675         "By default, deleting the current branch is denied, because the next",
 676         "'git clone' won't result in any file checked out, causing confusion.",
 677         "",
 678         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 679         "'warn' or 'ignore' in the remote repository to allow deleting the",
 680         "current branch, with or without a warning message.",
 681         "",
 682         "To squelch this message, you can set it to 'refuse'."
 683 };
 684
 685 static void refuse_unconfigured_deny_delete_current(void)
 686 {
 687         int i;
 688         for (i = 0;
 689              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 690              i++)
 691                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 692 }
 693
 694 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
 695 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
 696 {
 697         static struct lock_file shallow_lock;
 698         struct sha1_array extra = SHA1_ARRAY_INIT;
 699         const char *alt_file;
 700         uint32_t mask = 1 << (cmd->index % 32);
 701         int i;
 702
 703         trace_printf_key(&trace_shallow,
 704                          "shallow: update_shallow_ref %s\n", cmd->ref_name);
 705         for (i = 0; i < si->shallow->nr; i++)
 706                 if (si->used_shallow[i] &&
 707                     (si->used_shallow[i][cmd->index / 32] & mask) &&
 708                     !delayed_reachability_test(si, i))
 709                         sha1_array_append(&extra, si->shallow->sha1[i]);
 710
 711         setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
 712         if (check_shallow_connected(command_singleton_iterator,
 713                                     0, cmd, alt_file)) {
 714                 rollback_lock_file(&shallow_lock);
 715                 sha1_array_clear(&extra);
 716                 return -1;
 717         }
 718
 719         commit_lock_file(&shallow_lock);
 720
 721         /*
 722          * Make sure setup_alternate_shallow() for the next ref does
 723          * not lose these new roots..
 724          */
 725         for (i = 0; i < extra.nr; i++)
 726                 register_shallow(extra.sha1[i]);
 727
 728         si->shallow_ref[cmd->index] = 0;
 729         sha1_array_clear(&extra);
 730         return 0;
 731 }
 732
 733 static const char *update(struct command *cmd, struct shallow_info *si)
 734 {
 735         const char *name = cmd->ref_name;
 736         struct strbuf namespaced_name_buf = STRBUF_INIT;
 737         const char *namespaced_name;
 738         unsigned char *old_sha1 = cmd->old_sha1;
 739         unsigned char *new_sha1 = cmd->new_sha1;
 740
 741         /* only refs/... are allowed */
 742         if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
 743                 rp_error("refusing to create funny ref '%s' remotely", name);
 744                 return "funny refname";
 745         }
 746
 747         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 748         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 749
 750         if (is_ref_checked_out(namespaced_name)) {
 751                 switch (deny_current_branch) {
 752                 case DENY_IGNORE:
 753                         break;
 754                 case DENY_WARN:
 755                         rp_warning("updating the current branch");
 756                         break;
 757                 case DENY_REFUSE:
 758                 case DENY_UNCONFIGURED:
 759                         rp_error("refusing to update checked out branch: %s", name);
 760                         if (deny_current_branch == DENY_UNCONFIGURED)
 761                                 refuse_unconfigured_deny();
 762                         return "branch is currently checked out";
 763                 }
 764         }
 765
 766         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 767                 error("unpack should have generated %s, "
 768                       "but I can't find it!", sha1_to_hex(new_sha1));
 769                 return "bad pack";
 770         }
 771
 772         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 773                 if (deny_deletes && starts_with(name, "refs/heads/")) {
 774                         rp_error("denying ref deletion for %s", name);
 775                         return "deletion prohibited";
 776                 }
 777
 778                 if (!strcmp(namespaced_name, head_name)) {
 779                         switch (deny_delete_current) {
 780                         case DENY_IGNORE:
 781                                 break;
 782                         case DENY_WARN:
 783                                 rp_warning("deleting the current branch");
 784                                 break;
 785                         case DENY_REFUSE:
 786                         case DENY_UNCONFIGURED:
 787                                 if (deny_delete_current == DENY_UNCONFIGURED)
 788                                         refuse_unconfigured_deny_delete_current();
 789                                 rp_error("refusing to delete the current branch: %s", name);
 790                                 return "deletion of the current branch prohibited";
 791                         }
 792                 }
 793         }
 794
 795         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 796             !is_null_sha1(old_sha1) &&
 797             starts_with(name, "refs/heads/")) {
 798                 struct object *old_object, *new_object;
 799                 struct commit *old_commit, *new_commit;
 800
 801                 old_object = parse_object(old_sha1);
 802                 new_object = parse_object(new_sha1);
 803
 804                 if (!old_object || !new_object ||
 805                     old_object->type != OBJ_COMMIT ||
 806                     new_object->type != OBJ_COMMIT) {
 807                         error("bad sha1 objects for %s", name);
 808                         return "bad ref";
 809                 }
 810                 old_commit = (struct commit *)old_object;
 811                 new_commit = (struct commit *)new_object;
 812                 if (!in_merge_bases(old_commit, new_commit)) {
 813                         rp_error("denying non-fast-forward %s"
 814                                  " (you should pull first)", name);
 815                         return "non-fast-forward";
 816                 }
 817         }
 818         if (run_update_hook(cmd)) {
 819                 rp_error("hook declined to update %s", name);
 820                 return "hook declined";
 821         }
 822
 823         if (is_null_sha1(new_sha1)) {
 824                 if (!parse_object(old_sha1)) {
 825                         old_sha1 = NULL;
 826                         if (ref_exists(name)) {
 827                                 rp_warning("Allowing deletion of corrupt ref.");
 828                         } else {
 829                                 rp_warning("Deleting a non-existent ref.");
 830                                 cmd->did_not_exist = 1;
 831                         }
 832                 }
 833                 if (delete_ref(namespaced_name, old_sha1, 0)) {
 834                         rp_error("failed to delete %s", name);
 835                         return "failed to delete";
 836                 }
 837                 return NULL; /* good */
 838         }
 839         else {
 840                 struct strbuf err = STRBUF_INIT;
 841                 struct ref_transaction *transaction;
 842
 843                 if (shallow_update && si->shallow_ref[cmd->index] &&
 844                     update_shallow_ref(cmd, si))
 845                         return "shallow error";
 846
 847                 transaction = ref_transaction_begin(&err);
 848                 if (!transaction ||
 849                     ref_transaction_update(transaction, namespaced_name,
 850                                            new_sha1, old_sha1, 0, 1, &err) ||
 851                     ref_transaction_commit(transaction, "push", &err)) {
 852                         ref_transaction_free(transaction);
 853
 854                         rp_error("%s", err.buf);
 855                         strbuf_release(&err);
 856                         return "failed to update ref";
 857                 }
 858
 859                 ref_transaction_free(transaction);
 860                 strbuf_release(&err);
 861                 return NULL; /* good */
 862         }
 863 }
 864
 865 static void run_update_post_hook(struct command *commands)
 866 {
 867         struct command *cmd;
 868         int argc;
 869         const char **argv;
 870         struct child_process proc = CHILD_PROCESS_INIT;
 871         char *hook;
 872
 873         hook = find_hook("post-update");
 874         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 875                 if (cmd->error_string || cmd->did_not_exist)
 876                         continue;
 877                 argc++;
 878         }
 879         if (!argc || !hook)
 880                 return;
 881
 882         argv = xmalloc(sizeof(*argv) * (2 + argc));
 883         argv[0] = hook;
 884
 885         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 886                 if (cmd->error_string || cmd->did_not_exist)
 887                         continue;
 888                 argv[argc] = xstrdup(cmd->ref_name);
 889                 argc++;
 890         }
 891         argv[argc] = NULL;
 892
 893         proc.no_stdin = 1;
 894         proc.stdout_to_stderr = 1;
 895         proc.err = use_sideband ? -1 : 0;
 896         proc.argv = argv;
 897
 898         if (!start_command(&proc)) {
 899                 if (use_sideband)
 900                         copy_to_sideband(proc.err, -1, NULL);
 901                 finish_command(&proc);
 902         }
 903 }
 904
 905 static void check_aliased_update(struct command *cmd, struct string_list *list)
 906 {
 907         struct strbuf buf = STRBUF_INIT;
 908         const char *dst_name;
 909         struct string_list_item *item;
 910         struct command *dst_cmd;
 911         unsigned char sha1[20];
 912         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 913         int flag;
 914
 915         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 916         dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 917         strbuf_release(&buf);
 918
 919         if (!(flag & REF_ISSYMREF))
 920                 return;
 921
 922         dst_name = strip_namespace(dst_name);
 923         if (!dst_name) {
 924                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 925                 cmd->skip_update = 1;
 926                 cmd->error_string = "broken symref";
 927                 return;
 928         }
 929
 930         if ((item = string_list_lookup(list, dst_name)) == NULL)
 931                 return;
 932
 933         cmd->skip_update = 1;
 934
 935         dst_cmd = (struct command *) item->util;
 936
 937         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 938             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 939                 return;
 940
 941         dst_cmd->skip_update = 1;
 942
 943         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 944         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 945         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 946         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 947         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 948                  " its target '%s' (%s..%s)",
 949                  cmd->ref_name, cmd_oldh, cmd_newh,
 950                  dst_cmd->ref_name, dst_oldh, dst_newh);
 951
 952         cmd->error_string = dst_cmd->error_string =
 953                 "inconsistent aliased update";
 954 }
 955
 956 static void check_aliased_updates(struct command *commands)
 957 {
 958         struct command *cmd;
 959         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 960
 961         for (cmd = commands; cmd; cmd = cmd->next) {
 962                 struct string_list_item *item =
 963                         string_list_append(&ref_list, cmd->ref_name);
 964                 item->util = (void *)cmd;
 965         }
 966         sort_string_list(&ref_list);
 967
 968         for (cmd = commands; cmd; cmd = cmd->next) {
 969                 if (!cmd->error_string)
 970                         check_aliased_update(cmd, &ref_list);
 971         }
 972
 973         string_list_clear(&ref_list, 0);
 974 }
 975
 976 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 977 {
 978         struct command **cmd_list = cb_data;
 979         struct command *cmd = *cmd_list;
 980
 981         if (!cmd || is_null_sha1(cmd->new_sha1))
 982                 return -1; /* end of list */
 983         *cmd_list = NULL; /* this returns only one */
 984         hashcpy(sha1, cmd->new_sha1);
 985         return 0;
 986 }
 987
 988 static void set_connectivity_errors(struct command *commands,
 989                                     struct shallow_info *si)
 990 {
 991         struct command *cmd;
 992
 993         for (cmd = commands; cmd; cmd = cmd->next) {
 994                 struct command *singleton = cmd;
 995                 if (shallow_update && si->shallow_ref[cmd->index])
 996                         /* to be checked in update_shallow_ref() */
 997                         continue;
 998                 if (!check_everything_connected(command_singleton_iterator,
 999                                                 0, &singleton))
1000                         continue;
1001                 cmd->error_string = "missing necessary objects";
1002         }
1003 }
1004
1005 struct iterate_data {
1006         struct command *cmds;
1007         struct shallow_info *si;
1008 };
1009
1010 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
1011 {
1012         struct iterate_data *data = cb_data;
1013         struct command **cmd_list = &data->cmds;
1014         struct command *cmd = *cmd_list;
1015
1016         for (; cmd; cmd = cmd->next) {
1017                 if (shallow_update && data->si->shallow_ref[cmd->index])
1018                         /* to be checked in update_shallow_ref() */
1019                         continue;
1020                 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
1021                         hashcpy(sha1, cmd->new_sha1);
1022                         *cmd_list = cmd->next;
1023                         return 0;
1024                 }
1025         }
1026         *cmd_list = NULL;
1027         return -1; /* end of list */
1028 }
1029
1030 static void reject_updates_to_hidden(struct command *commands)
1031 {
1032         struct command *cmd;
1033
1034         for (cmd = commands; cmd; cmd = cmd->next) {
1035                 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
1036                         continue;
1037                 if (is_null_sha1(cmd->new_sha1))
1038                         cmd->error_string = "deny deleting a hidden ref";
1039                 else
1040                         cmd->error_string = "deny updating a hidden ref";
1041         }
1042 }
1043
1044 static void execute_commands(struct command *commands,
1045                              const char *unpacker_error,
1046                              struct shallow_info *si)
1047 {
1048         int checked_connectivity;
1049         struct command *cmd;
1050         unsigned char sha1[20];
1051         struct iterate_data data;
1052
1053         if (unpacker_error) {
1054                 for (cmd = commands; cmd; cmd = cmd->next)
1055                         cmd->error_string = "unpacker error";
1056                 return;
1057         }
1058
1059         data.cmds = commands;
1060         data.si = si;
1061         if (check_everything_connected(iterate_receive_command_list, 0, &data))
1062                 set_connectivity_errors(commands, si);
1063
1064         reject_updates_to_hidden(commands);
1065
1066         if (run_receive_hook(commands, "pre-receive", 0)) {
1067                 for (cmd = commands; cmd; cmd = cmd->next) {
1068                         if (!cmd->error_string)
1069                                 cmd->error_string = "pre-receive hook declined";
1070                 }
1071                 return;
1072         }
1073
1074         check_aliased_updates(commands);
1075
1076         free(head_name_to_free);
1077         head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
1078
1079         checked_connectivity = 1;
1080         for (cmd = commands; cmd; cmd = cmd->next) {
1081                 if (cmd->error_string)
1082                         continue;
1083
1084                 if (cmd->skip_update)
1085                         continue;
1086
1087                 cmd->error_string = update(cmd, si);
1088                 if (shallow_update && !cmd->error_string &&
1089                     si->shallow_ref[cmd->index]) {
1090                         error("BUG: connectivity check has not been run on ref %s",
1091                               cmd->ref_name);
1092                         checked_connectivity = 0;
1093                 }
1094         }
1095
1096         if (shallow_update && !checked_connectivity)
1097                 error("BUG: run 'git fsck' for safety.\n"
1098                       "If there are errors, try to remove "
1099                       "the reported refs above");
1100 }
1101
1102 static struct command **queue_command(struct command **tail,
1103                                       const char *line,
1104                                       int linelen)
1105 {
1106         unsigned char old_sha1[20], new_sha1[20];
1107         struct command *cmd;
1108         const char *refname;
1109         int reflen;
1110
1111         if (linelen < 83 ||
1112             line[40] != ' ' ||
1113             line[81] != ' ' ||
1114             get_sha1_hex(line, old_sha1) ||
1115             get_sha1_hex(line + 41, new_sha1))
1116                 die("protocol error: expected old/new/ref, got '%s'", line);
1117
1118         refname = line + 82;
1119         reflen = linelen - 82;
1120         cmd = xcalloc(1, sizeof(struct command) + reflen + 1);
1121         hashcpy(cmd->old_sha1, old_sha1);
1122         hashcpy(cmd->new_sha1, new_sha1);
1123         memcpy(cmd->ref_name, refname, reflen);
1124         cmd->ref_name[reflen] = '\0';
1125         *tail = cmd;
1126         return &cmd->next;
1127 }
1128
1129 static void queue_commands_from_cert(struct command **tail,
1130                                      struct strbuf *push_cert)
1131 {
1132         const char *boc, *eoc;
1133
1134         if (*tail)
1135                 die("protocol error: got both push certificate and unsigned commands");
1136
1137         boc = strstr(push_cert->buf, "\n\n");
1138         if (!boc)
1139                 die("malformed push certificate %.*s", 100, push_cert->buf);
1140         else
1141                 boc += 2;
1142         eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1143
1144         while (boc < eoc) {
1145                 const char *eol = memchr(boc, '\n', eoc - boc);
1146                 tail = queue_command(tail, boc, eol ? eol - boc : eoc - eol);
1147                 boc = eol ? eol + 1 : eoc;
1148         }
1149 }
1150
1151 static struct command *read_head_info(struct sha1_array *shallow)
1152 {
1153         struct command *commands = NULL;
1154         struct command **p = &commands;
1155         for (;;) {
1156                 char *line;
1157                 int len, linelen;
1158
1159                 line = packet_read_line(0, &len);
1160                 if (!line)
1161                         break;
1162
1163                 if (len == 48 && starts_with(line, "shallow ")) {
1164                         unsigned char sha1[20];
1165                         if (get_sha1_hex(line + 8, sha1))
1166                                 die("protocol error: expected shallow sha, got '%s'",
1167                                     line + 8);
1168                         sha1_array_append(shallow, sha1);
1169                         continue;
1170                 }
1171
1172                 linelen = strlen(line);
1173                 if (linelen < len) {
1174                         const char *feature_list = line + linelen + 1;
1175                         if (parse_feature_request(feature_list, "report-status"))
1176                                 report_status = 1;
1177                         if (parse_feature_request(feature_list, "side-band-64k"))
1178                                 use_sideband = LARGE_PACKET_MAX;
1179                         if (parse_feature_request(feature_list, "quiet"))
1180                                 quiet = 1;
1181                 }
1182
1183                 if (!strcmp(line, "push-cert")) {
1184                         int true_flush = 0;
1185                         char certbuf[1024];
1186
1187                         for (;;) {
1188                                 len = packet_read(0, NULL, NULL,
1189                                                   certbuf, sizeof(certbuf), 0);
1190                                 if (!len) {
1191                                         true_flush = 1;
1192                                         break;
1193                                 }
1194                                 if (!strcmp(certbuf, "push-cert-end\n"))
1195                                         break; /* end of cert */
1196                                 strbuf_addstr(&push_cert, certbuf);
1197                         }
1198
1199                         if (true_flush)
1200                                 break;
1201                         continue;
1202                 }
1203
1204                 p = queue_command(p, line, linelen);
1205         }
1206
1207         if (push_cert.len)
1208                 queue_commands_from_cert(p, &push_cert);
1209
1210         return commands;
1211 }
1212
1213 static const char *parse_pack_header(struct pack_header *hdr)
1214 {
1215         switch (read_pack_header(0, hdr)) {
1216         case PH_ERROR_EOF:
1217                 return "eof before pack header was fully read";
1218
1219         case PH_ERROR_PACK_SIGNATURE:
1220                 return "protocol error (pack signature mismatch detected)";
1221
1222         case PH_ERROR_PROTOCOL:
1223                 return "protocol error (pack version unsupported)";
1224
1225         default:
1226                 return "unknown error in parse_pack_header";
1227
1228         case 0:
1229                 return NULL;
1230         }
1231 }
1232
1233 static const char *pack_lockfile;
1234
1235 static const char *unpack(int err_fd, struct shallow_info *si)
1236 {
1237         struct pack_header hdr;
1238         struct argv_array av = ARGV_ARRAY_INIT;
1239         const char *hdr_err;
1240         int status;
1241         char hdr_arg[38];
1242         struct child_process child = CHILD_PROCESS_INIT;
1243         int fsck_objects = (receive_fsck_objects >= 0
1244                             ? receive_fsck_objects
1245                             : transfer_fsck_objects >= 0
1246                             ? transfer_fsck_objects
1247                             : 0);
1248
1249         hdr_err = parse_pack_header(&hdr);
1250         if (hdr_err) {
1251                 if (err_fd > 0)
1252                         close(err_fd);
1253                 return hdr_err;
1254         }
1255         snprintf(hdr_arg, sizeof(hdr_arg),
1256                         "--pack_header=%"PRIu32",%"PRIu32,
1257                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
1258
1259         if (si->nr_ours || si->nr_theirs) {
1260                 alt_shallow_file = setup_temporary_shallow(si->shallow);
1261                 argv_array_pushl(&av, "--shallow-file", alt_shallow_file, NULL);
1262         }
1263
1264         if (ntohl(hdr.hdr_entries) < unpack_limit) {
1265                 argv_array_pushl(&av, "unpack-objects", hdr_arg, NULL);
1266                 if (quiet)
1267                         argv_array_push(&av, "-q");
1268                 if (fsck_objects)
1269                         argv_array_push(&av, "--strict");
1270                 child.argv = av.argv;
1271                 child.no_stdout = 1;
1272                 child.err = err_fd;
1273                 child.git_cmd = 1;
1274                 status = run_command(&child);
1275                 if (status)
1276                         return "unpack-objects abnormal exit";
1277         } else {
1278                 int s;
1279                 char keep_arg[256];
1280
1281                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
1282                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
1283                         strcpy(keep_arg + s, "localhost");
1284
1285                 argv_array_pushl(&av, "index-pack",
1286                                  "--stdin", hdr_arg, keep_arg, NULL);
1287                 if (fsck_objects)
1288                         argv_array_push(&av, "--strict");
1289                 if (fix_thin)
1290                         argv_array_push(&av, "--fix-thin");
1291                 child.argv = av.argv;
1292                 child.out = -1;
1293                 child.err = err_fd;
1294                 child.git_cmd = 1;
1295                 status = start_command(&child);
1296                 if (status)
1297                         return "index-pack fork failed";
1298                 pack_lockfile = index_pack_lockfile(child.out);
1299                 close(child.out);
1300                 status = finish_command(&child);
1301                 if (status)
1302                         return "index-pack abnormal exit";
1303                 reprepare_packed_git();
1304         }
1305         return NULL;
1306 }
1307
1308 static const char *unpack_with_sideband(struct shallow_info *si)
1309 {
1310         struct async muxer;
1311         const char *ret;
1312
1313         if (!use_sideband)
1314                 return unpack(0, si);
1315
1316         memset(&muxer, 0, sizeof(muxer));
1317         muxer.proc = copy_to_sideband;
1318         muxer.in = -1;
1319         if (start_async(&muxer))
1320                 return NULL;
1321
1322         ret = unpack(muxer.in, si);
1323
1324         finish_async(&muxer);
1325         return ret;
1326 }
1327
1328 static void prepare_shallow_update(struct command *commands,
1329                                    struct shallow_info *si)
1330 {
1331         int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1332
1333         si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1334                                    si->shallow->nr);
1335         assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1336
1337         si->need_reachability_test =
1338                 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1339         si->reachable =
1340                 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1341         si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1342
1343         for (i = 0; i < si->nr_ours; i++)
1344                 si->need_reachability_test[si->ours[i]] = 1;
1345
1346         for (i = 0; i < si->shallow->nr; i++) {
1347                 if (!si->used_shallow[i])
1348                         continue;
1349                 for (j = 0; j < bitmap_size; j++) {
1350                         if (!si->used_shallow[i][j])
1351                                 continue;
1352                         si->need_reachability_test[i]++;
1353                         for (k = 0; k < 32; k++)
1354                                 if (si->used_shallow[i][j] & (1 << k))
1355                                         si->shallow_ref[j * 32 + k]++;
1356                 }
1357
1358                 /*
1359                  * true for those associated with some refs and belong
1360                  * in "ours" list aka "step 7 not done yet"
1361                  */
1362                 si->need_reachability_test[i] =
1363                         si->need_reachability_test[i] > 1;
1364         }
1365
1366         /*
1367          * keep hooks happy by forcing a temporary shallow file via
1368          * env variable because we can't add --shallow-file to every
1369          * command. check_everything_connected() will be done with
1370          * true .git/shallow though.
1371          */
1372         setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1373 }
1374
1375 static void update_shallow_info(struct command *commands,
1376                                 struct shallow_info *si,
1377                                 struct sha1_array *ref)
1378 {
1379         struct command *cmd;
1380         int *ref_status;
1381         remove_nonexistent_theirs_shallow(si);
1382         if (!si->nr_ours && !si->nr_theirs) {
1383                 shallow_update = 0;
1384                 return;
1385         }
1386
1387         for (cmd = commands; cmd; cmd = cmd->next) {
1388                 if (is_null_sha1(cmd->new_sha1))
1389                         continue;
1390                 sha1_array_append(ref, cmd->new_sha1);
1391                 cmd->index = ref->nr - 1;
1392         }
1393         si->ref = ref;
1394
1395         if (shallow_update) {
1396                 prepare_shallow_update(commands, si);
1397                 return;
1398         }
1399
1400         ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1401         assign_shallow_commits_to_refs(si, NULL, ref_status);
1402         for (cmd = commands; cmd; cmd = cmd->next) {
1403                 if (is_null_sha1(cmd->new_sha1))
1404                         continue;
1405                 if (ref_status[cmd->index]) {
1406                         cmd->error_string = "shallow update not allowed";
1407                         cmd->skip_update = 1;
1408                 }
1409         }
1410         free(ref_status);
1411 }
1412
1413 static void report(struct command *commands, const char *unpack_status)
1414 {
1415         struct command *cmd;
1416         struct strbuf buf = STRBUF_INIT;
1417
1418         packet_buf_write(&buf, "unpack %s\n",
1419                          unpack_status ? unpack_status : "ok");
1420         for (cmd = commands; cmd; cmd = cmd->next) {
1421                 if (!cmd->error_string)
1422                         packet_buf_write(&buf, "ok %s\n",
1423                                          cmd->ref_name);
1424                 else
1425                         packet_buf_write(&buf, "ng %s %s\n",
1426                                          cmd->ref_name, cmd->error_string);
1427         }
1428         packet_buf_flush(&buf);
1429
1430         if (use_sideband)
1431                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1432         else
1433                 write_or_die(1, buf.buf, buf.len);
1434         strbuf_release(&buf);
1435 }
1436
1437 static int delete_only(struct command *commands)
1438 {
1439         struct command *cmd;
1440         for (cmd = commands; cmd; cmd = cmd->next) {
1441                 if (!is_null_sha1(cmd->new_sha1))
1442                         return 0;
1443         }
1444         return 1;
1445 }
1446
1447 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1448 {
1449         int advertise_refs = 0;
1450         int i;
1451         struct command *commands;
1452         struct sha1_array shallow = SHA1_ARRAY_INIT;
1453         struct sha1_array ref = SHA1_ARRAY_INIT;
1454         struct shallow_info si;
1455
1456         packet_trace_identity("receive-pack");
1457
1458         argv++;
1459         for (i = 1; i < argc; i++) {
1460                 const char *arg = *argv++;
1461
1462                 if (*arg == '-') {
1463                         if (!strcmp(arg, "--quiet")) {
1464                                 quiet = 1;
1465                                 continue;
1466                         }
1467
1468                         if (!strcmp(arg, "--advertise-refs")) {
1469                                 advertise_refs = 1;
1470                                 continue;
1471                         }
1472                         if (!strcmp(arg, "--stateless-rpc")) {
1473                                 stateless_rpc = 1;
1474                                 continue;
1475                         }
1476                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1477                                 fix_thin = 0;
1478                                 continue;
1479                         }
1480
1481                         usage(receive_pack_usage);
1482                 }
1483                 if (service_dir)
1484                         usage(receive_pack_usage);
1485                 service_dir = arg;
1486         }
1487         if (!service_dir)
1488                 usage(receive_pack_usage);
1489
1490         setup_path();
1491
1492         if (!enter_repo(service_dir, 0))
1493                 die("'%s' does not appear to be a git repository", service_dir);
1494
1495         git_config(receive_pack_config, NULL);
1496         if (cert_nonce_seed)
1497                 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1498
1499         if (0 <= transfer_unpack_limit)
1500                 unpack_limit = transfer_unpack_limit;
1501         else if (0 <= receive_unpack_limit)
1502                 unpack_limit = receive_unpack_limit;
1503
1504         if (advertise_refs || !stateless_rpc) {
1505                 write_head_info();
1506         }
1507         if (advertise_refs)
1508                 return 0;
1509
1510         if ((commands = read_head_info(&shallow)) != NULL) {
1511                 const char *unpack_status = NULL;
1512
1513                 prepare_shallow_info(&si, &shallow);
1514                 if (!si.nr_ours && !si.nr_theirs)
1515                         shallow_update = 0;
1516                 if (!delete_only(commands)) {
1517                         unpack_status = unpack_with_sideband(&si);
1518                         update_shallow_info(commands, &si, &ref);
1519                 }
1520                 execute_commands(commands, unpack_status, &si);
1521                 if (pack_lockfile)
1522                         unlink_or_warn(pack_lockfile);
1523                 if (report_status)
1524                         report(commands, unpack_status);
1525                 run_receive_hook(commands, "post-receive", 1);
1526                 run_update_post_hook(commands);
1527                 if (auto_gc) {
1528                         const char *argv_gc_auto[] = {
1529                                 "gc", "--auto", "--quiet", NULL,
1530                         };
1531                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1532                         run_command_v_opt(argv_gc_auto, opt);
1533                 }
1534                 if (auto_update_server_info)
1535                         update_server_info(0);
1536                 clear_shallow_info(&si);
1537         }
1538         if (use_sideband)
1539                 packet_flush(1);
1540         sha1_array_clear(&shallow);
1541         sha1_array_clear(&ref);
1542         free((void *)push_cert_nonce);
1543         return 0;
1544 }