git.oblomov.eu Git - git/blob - 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, "push",
 851                                            &err) ||
 852                     ref_transaction_commit(transaction, &err)) {
 853                         ref_transaction_free(transaction);
 854
 855                         rp_error("%s", err.buf);
 856                         strbuf_release(&err);
 857                         return "failed to update ref";
 858                 }
 859
 860                 ref_transaction_free(transaction);
 861                 strbuf_release(&err);
 862                 return NULL; /* good */
 863         }
 864 }
 865
 866 static void run_update_post_hook(struct command *commands)
 867 {
 868         struct command *cmd;
 869         int argc;
 870         const char **argv;
 871         struct child_process proc = CHILD_PROCESS_INIT;
 872         char *hook;
 873
 874         hook = find_hook("post-update");
 875         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 876                 if (cmd->error_string || cmd->did_not_exist)
 877                         continue;
 878                 argc++;
 879         }
 880         if (!argc || !hook)
 881                 return;
 882
 883         argv = xmalloc(sizeof(*argv) * (2 + argc));
 884         argv[0] = hook;
 885
 886         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 887                 if (cmd->error_string || cmd->did_not_exist)
 888                         continue;
 889                 argv[argc] = xstrdup(cmd->ref_name);
 890                 argc++;
 891         }
 892         argv[argc] = NULL;
 893
 894         proc.no_stdin = 1;
 895         proc.stdout_to_stderr = 1;
 896         proc.err = use_sideband ? -1 : 0;
 897         proc.argv = argv;
 898
 899         if (!start_command(&proc)) {
 900                 if (use_sideband)
 901                         copy_to_sideband(proc.err, -1, NULL);
 902                 finish_command(&proc);
 903         }
 904 }
 905
 906 static void check_aliased_update(struct command *cmd, struct string_list *list)
 907 {
 908         struct strbuf buf = STRBUF_INIT;
 909         const char *dst_name;
 910         struct string_list_item *item;
 911         struct command *dst_cmd;
 912         unsigned char sha1[20];
 913         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 914         int flag;
 915
 916         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 917         dst_name = resolve_ref_unsafe(buf.buf, 0, sha1, &flag);
 918         strbuf_release(&buf);
 919
 920         if (!(flag & REF_ISSYMREF))
 921                 return;
 922
 923         dst_name = strip_namespace(dst_name);
 924         if (!dst_name) {
 925                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 926                 cmd->skip_update = 1;
 927                 cmd->error_string = "broken symref";
 928                 return;
 929         }
 930
 931         if ((item = string_list_lookup(list, dst_name)) == NULL)
 932                 return;
 933
 934         cmd->skip_update = 1;
 935
 936         dst_cmd = (struct command *) item->util;
 937
 938         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 939             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 940                 return;
 941
 942         dst_cmd->skip_update = 1;
 943
 944         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 945         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 946         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 947         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 948         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 949                  " its target '%s' (%s..%s)",
 950                  cmd->ref_name, cmd_oldh, cmd_newh,
 951                  dst_cmd->ref_name, dst_oldh, dst_newh);
 952
 953         cmd->error_string = dst_cmd->error_string =
 954                 "inconsistent aliased update";
 955 }
 956
 957 static void check_aliased_updates(struct command *commands)
 958 {
 959         struct command *cmd;
 960         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 961
 962         for (cmd = commands; cmd; cmd = cmd->next) {
 963                 struct string_list_item *item =
 964                         string_list_append(&ref_list, cmd->ref_name);
 965                 item->util = (void *)cmd;
 966         }
 967         sort_string_list(&ref_list);
 968
 969         for (cmd = commands; cmd; cmd = cmd->next) {
 970                 if (!cmd->error_string)
 971                         check_aliased_update(cmd, &ref_list);
 972         }
 973
 974         string_list_clear(&ref_list, 0);
 975 }
 976
 977 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 978 {
 979         struct command **cmd_list = cb_data;
 980         struct command *cmd = *cmd_list;
 981
 982         if (!cmd || is_null_sha1(cmd->new_sha1))
 983                 return -1; /* end of list */
 984         *cmd_list = NULL; /* this returns only one */
 985         hashcpy(sha1, cmd->new_sha1);
 986         return 0;
 987 }
 988
 989 static void set_connectivity_errors(struct command *commands,
 990                                     struct shallow_info *si)
 991 {
 992         struct command *cmd;
 993
 994         for (cmd = commands; cmd; cmd = cmd->next) {
 995                 struct command *singleton = cmd;
 996                 if (shallow_update && si->shallow_ref[cmd->index])
 997                         /* to be checked in update_shallow_ref() */
 998                         continue;
 999                 if (!check_everything_connected(command_singleton_iterator,
1000                                                 0, &singleton))
1001                         continue;
1002                 cmd->error_string = "missing necessary objects";
1003         }
1004 }
1005
1006 struct iterate_data {
1007         struct command *cmds;
1008         struct shallow_info *si;
1009 };
1010
1011 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
1012 {
1013         struct iterate_data *data = cb_data;
1014         struct command **cmd_list = &data->cmds;
1015         struct command *cmd = *cmd_list;
1016
1017         for (; cmd; cmd = cmd->next) {
1018                 if (shallow_update && data->si->shallow_ref[cmd->index])
1019                         /* to be checked in update_shallow_ref() */
1020                         continue;
1021                 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
1022                         hashcpy(sha1, cmd->new_sha1);
1023                         *cmd_list = cmd->next;
1024                         return 0;
1025                 }
1026         }
1027         *cmd_list = NULL;
1028         return -1; /* end of list */
1029 }
1030
1031 static void reject_updates_to_hidden(struct command *commands)
1032 {
1033         struct command *cmd;
1034
1035         for (cmd = commands; cmd; cmd = cmd->next) {
1036                 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
1037                         continue;
1038                 if (is_null_sha1(cmd->new_sha1))
1039                         cmd->error_string = "deny deleting a hidden ref";
1040                 else
1041                         cmd->error_string = "deny updating a hidden ref";
1042         }
1043 }
1044
1045 static void execute_commands(struct command *commands,
1046                              const char *unpacker_error,
1047                              struct shallow_info *si)
1048 {
1049         int checked_connectivity;
1050         struct command *cmd;
1051         unsigned char sha1[20];
1052         struct iterate_data data;
1053
1054         if (unpacker_error) {
1055                 for (cmd = commands; cmd; cmd = cmd->next)
1056                         cmd->error_string = "unpacker error";
1057                 return;
1058         }
1059
1060         data.cmds = commands;
1061         data.si = si;
1062         if (check_everything_connected(iterate_receive_command_list, 0, &data))
1063                 set_connectivity_errors(commands, si);
1064
1065         reject_updates_to_hidden(commands);
1066
1067         if (run_receive_hook(commands, "pre-receive", 0)) {
1068                 for (cmd = commands; cmd; cmd = cmd->next) {
1069                         if (!cmd->error_string)
1070                                 cmd->error_string = "pre-receive hook declined";
1071                 }
1072                 return;
1073         }
1074
1075         check_aliased_updates(commands);
1076
1077         free(head_name_to_free);
1078         head_name = head_name_to_free = resolve_refdup("HEAD", 0, sha1, NULL);
1079
1080         checked_connectivity = 1;
1081         for (cmd = commands; cmd; cmd = cmd->next) {
1082                 if (cmd->error_string)
1083                         continue;
1084
1085                 if (cmd->skip_update)
1086                         continue;
1087
1088                 cmd->error_string = update(cmd, si);
1089                 if (shallow_update && !cmd->error_string &&
1090                     si->shallow_ref[cmd->index]) {
1091                         error("BUG: connectivity check has not been run on ref %s",
1092                               cmd->ref_name);
1093                         checked_connectivity = 0;
1094                 }
1095         }
1096
1097         if (shallow_update && !checked_connectivity)
1098                 error("BUG: run 'git fsck' for safety.\n"
1099                       "If there are errors, try to remove "
1100                       "the reported refs above");
1101 }
1102
1103 static struct command **queue_command(struct command **tail,
1104                                       const char *line,
1105                                       int linelen)
1106 {
1107         unsigned char old_sha1[20], new_sha1[20];
1108         struct command *cmd;
1109         const char *refname;
1110         int reflen;
1111
1112         if (linelen < 83 ||
1113             line[40] != ' ' ||
1114             line[81] != ' ' ||
1115             get_sha1_hex(line, old_sha1) ||
1116             get_sha1_hex(line + 41, new_sha1))
1117                 die("protocol error: expected old/new/ref, got '%s'", line);
1118
1119         refname = line + 82;
1120         reflen = linelen - 82;
1121         cmd = xcalloc(1, sizeof(struct command) + reflen + 1);
1122         hashcpy(cmd->old_sha1, old_sha1);
1123         hashcpy(cmd->new_sha1, new_sha1);
1124         memcpy(cmd->ref_name, refname, reflen);
1125         cmd->ref_name[reflen] = '\0';
1126         *tail = cmd;
1127         return &cmd->next;
1128 }
1129
1130 static void queue_commands_from_cert(struct command **tail,
1131                                      struct strbuf *push_cert)
1132 {
1133         const char *boc, *eoc;
1134
1135         if (*tail)
1136                 die("protocol error: got both push certificate and unsigned commands");
1137
1138         boc = strstr(push_cert->buf, "\n\n");
1139         if (!boc)
1140                 die("malformed push certificate %.*s", 100, push_cert->buf);
1141         else
1142                 boc += 2;
1143         eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1144
1145         while (boc < eoc) {
1146                 const char *eol = memchr(boc, '\n', eoc - boc);
1147                 tail = queue_command(tail, boc, eol ? eol - boc : eoc - eol);
1148                 boc = eol ? eol + 1 : eoc;
1149         }
1150 }
1151
1152 static struct command *read_head_info(struct sha1_array *shallow)
1153 {
1154         struct command *commands = NULL;
1155         struct command **p = &commands;
1156         for (;;) {
1157                 char *line;
1158                 int len, linelen;
1159
1160                 line = packet_read_line(0, &len);
1161                 if (!line)
1162                         break;
1163
1164                 if (len == 48 && starts_with(line, "shallow ")) {
1165                         unsigned char sha1[20];
1166                         if (get_sha1_hex(line + 8, sha1))
1167                                 die("protocol error: expected shallow sha, got '%s'",
1168                                     line + 8);
1169                         sha1_array_append(shallow, sha1);
1170                         continue;
1171                 }
1172
1173                 linelen = strlen(line);
1174                 if (linelen < len) {
1175                         const char *feature_list = line + linelen + 1;
1176                         if (parse_feature_request(feature_list, "report-status"))
1177                                 report_status = 1;
1178                         if (parse_feature_request(feature_list, "side-band-64k"))
1179                                 use_sideband = LARGE_PACKET_MAX;
1180                         if (parse_feature_request(feature_list, "quiet"))
1181                                 quiet = 1;
1182                 }
1183
1184                 if (!strcmp(line, "push-cert")) {
1185                         int true_flush = 0;
1186                         char certbuf[1024];
1187
1188                         for (;;) {
1189                                 len = packet_read(0, NULL, NULL,
1190                                                   certbuf, sizeof(certbuf), 0);
1191                                 if (!len) {
1192                                         true_flush = 1;
1193                                         break;
1194                                 }
1195                                 if (!strcmp(certbuf, "push-cert-end\n"))
1196                                         break; /* end of cert */
1197                                 strbuf_addstr(&push_cert, certbuf);
1198                         }
1199
1200                         if (true_flush)
1201                                 break;
1202                         continue;
1203                 }
1204
1205                 p = queue_command(p, line, linelen);
1206         }
1207
1208         if (push_cert.len)
1209                 queue_commands_from_cert(p, &push_cert);
1210
1211         return commands;
1212 }
1213
1214 static const char *parse_pack_header(struct pack_header *hdr)
1215 {
1216         switch (read_pack_header(0, hdr)) {
1217         case PH_ERROR_EOF:
1218                 return "eof before pack header was fully read";
1219
1220         case PH_ERROR_PACK_SIGNATURE:
1221                 return "protocol error (pack signature mismatch detected)";
1222
1223         case PH_ERROR_PROTOCOL:
1224                 return "protocol error (pack version unsupported)";
1225
1226         default:
1227                 return "unknown error in parse_pack_header";
1228
1229         case 0:
1230                 return NULL;
1231         }
1232 }
1233
1234 static const char *pack_lockfile;
1235
1236 static const char *unpack(int err_fd, struct shallow_info *si)
1237 {
1238         struct pack_header hdr;
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_push(&child.args, "--shallow-file");
1262                 argv_array_push(&child.args, alt_shallow_file);
1263         }
1264
1265         if (ntohl(hdr.hdr_entries) < unpack_limit) {
1266                 argv_array_pushl(&child.args, "unpack-objects", hdr_arg, NULL);
1267                 if (quiet)
1268                         argv_array_push(&child.args, "-q");
1269                 if (fsck_objects)
1270                         argv_array_push(&child.args, "--strict");
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(&child.args, "index-pack",
1286                                  "--stdin", hdr_arg, keep_arg, NULL);
1287                 if (fsck_objects)
1288                         argv_array_push(&child.args, "--strict");
1289                 if (fix_thin)
1290                         argv_array_push(&child.args, "--fix-thin");
1291                 child.out = -1;
1292                 child.err = err_fd;
1293                 child.git_cmd = 1;
1294                 status = start_command(&child);
1295                 if (status)
1296                         return "index-pack fork failed";
1297                 pack_lockfile = index_pack_lockfile(child.out);
1298                 close(child.out);
1299                 status = finish_command(&child);
1300                 if (status)
1301                         return "index-pack abnormal exit";
1302                 reprepare_packed_git();
1303         }
1304         return NULL;
1305 }
1306
1307 static const char *unpack_with_sideband(struct shallow_info *si)
1308 {
1309         struct async muxer;
1310         const char *ret;
1311
1312         if (!use_sideband)
1313                 return unpack(0, si);
1314
1315         memset(&muxer, 0, sizeof(muxer));
1316         muxer.proc = copy_to_sideband;
1317         muxer.in = -1;
1318         if (start_async(&muxer))
1319                 return NULL;
1320
1321         ret = unpack(muxer.in, si);
1322
1323         finish_async(&muxer);
1324         return ret;
1325 }
1326
1327 static void prepare_shallow_update(struct command *commands,
1328                                    struct shallow_info *si)
1329 {
1330         int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1331
1332         si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1333                                    si->shallow->nr);
1334         assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1335
1336         si->need_reachability_test =
1337                 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1338         si->reachable =
1339                 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1340         si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1341
1342         for (i = 0; i < si->nr_ours; i++)
1343                 si->need_reachability_test[si->ours[i]] = 1;
1344
1345         for (i = 0; i < si->shallow->nr; i++) {
1346                 if (!si->used_shallow[i])
1347                         continue;
1348                 for (j = 0; j < bitmap_size; j++) {
1349                         if (!si->used_shallow[i][j])
1350                                 continue;
1351                         si->need_reachability_test[i]++;
1352                         for (k = 0; k < 32; k++)
1353                                 if (si->used_shallow[i][j] & (1 << k))
1354                                         si->shallow_ref[j * 32 + k]++;
1355                 }
1356
1357                 /*
1358                  * true for those associated with some refs and belong
1359                  * in "ours" list aka "step 7 not done yet"
1360                  */
1361                 si->need_reachability_test[i] =
1362                         si->need_reachability_test[i] > 1;
1363         }
1364
1365         /*
1366          * keep hooks happy by forcing a temporary shallow file via
1367          * env variable because we can't add --shallow-file to every
1368          * command. check_everything_connected() will be done with
1369          * true .git/shallow though.
1370          */
1371         setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1372 }
1373
1374 static void update_shallow_info(struct command *commands,
1375                                 struct shallow_info *si,
1376                                 struct sha1_array *ref)
1377 {
1378         struct command *cmd;
1379         int *ref_status;
1380         remove_nonexistent_theirs_shallow(si);
1381         if (!si->nr_ours && !si->nr_theirs) {
1382                 shallow_update = 0;
1383                 return;
1384         }
1385
1386         for (cmd = commands; cmd; cmd = cmd->next) {
1387                 if (is_null_sha1(cmd->new_sha1))
1388                         continue;
1389                 sha1_array_append(ref, cmd->new_sha1);
1390                 cmd->index = ref->nr - 1;
1391         }
1392         si->ref = ref;
1393
1394         if (shallow_update) {
1395                 prepare_shallow_update(commands, si);
1396                 return;
1397         }
1398
1399         ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1400         assign_shallow_commits_to_refs(si, NULL, ref_status);
1401         for (cmd = commands; cmd; cmd = cmd->next) {
1402                 if (is_null_sha1(cmd->new_sha1))
1403                         continue;
1404                 if (ref_status[cmd->index]) {
1405                         cmd->error_string = "shallow update not allowed";
1406                         cmd->skip_update = 1;
1407                 }
1408         }
1409         free(ref_status);
1410 }
1411
1412 static void report(struct command *commands, const char *unpack_status)
1413 {
1414         struct command *cmd;
1415         struct strbuf buf = STRBUF_INIT;
1416
1417         packet_buf_write(&buf, "unpack %s\n",
1418                          unpack_status ? unpack_status : "ok");
1419         for (cmd = commands; cmd; cmd = cmd->next) {
1420                 if (!cmd->error_string)
1421                         packet_buf_write(&buf, "ok %s\n",
1422                                          cmd->ref_name);
1423                 else
1424                         packet_buf_write(&buf, "ng %s %s\n",
1425                                          cmd->ref_name, cmd->error_string);
1426         }
1427         packet_buf_flush(&buf);
1428
1429         if (use_sideband)
1430                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1431         else
1432                 write_or_die(1, buf.buf, buf.len);
1433         strbuf_release(&buf);
1434 }
1435
1436 static int delete_only(struct command *commands)
1437 {
1438         struct command *cmd;
1439         for (cmd = commands; cmd; cmd = cmd->next) {
1440                 if (!is_null_sha1(cmd->new_sha1))
1441                         return 0;
1442         }
1443         return 1;
1444 }
1445
1446 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1447 {
1448         int advertise_refs = 0;
1449         int i;
1450         struct command *commands;
1451         struct sha1_array shallow = SHA1_ARRAY_INIT;
1452         struct sha1_array ref = SHA1_ARRAY_INIT;
1453         struct shallow_info si;
1454
1455         packet_trace_identity("receive-pack");
1456
1457         argv++;
1458         for (i = 1; i < argc; i++) {
1459                 const char *arg = *argv++;
1460
1461                 if (*arg == '-') {
1462                         if (!strcmp(arg, "--quiet")) {
1463                                 quiet = 1;
1464                                 continue;
1465                         }
1466
1467                         if (!strcmp(arg, "--advertise-refs")) {
1468                                 advertise_refs = 1;
1469                                 continue;
1470                         }
1471                         if (!strcmp(arg, "--stateless-rpc")) {
1472                                 stateless_rpc = 1;
1473                                 continue;
1474                         }
1475                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1476                                 fix_thin = 0;
1477                                 continue;
1478                         }
1479
1480                         usage(receive_pack_usage);
1481                 }
1482                 if (service_dir)
1483                         usage(receive_pack_usage);
1484                 service_dir = arg;
1485         }
1486         if (!service_dir)
1487                 usage(receive_pack_usage);
1488
1489         setup_path();
1490
1491         if (!enter_repo(service_dir, 0))
1492                 die("'%s' does not appear to be a git repository", service_dir);
1493
1494         git_config(receive_pack_config, NULL);
1495         if (cert_nonce_seed)
1496                 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1497
1498         if (0 <= transfer_unpack_limit)
1499                 unpack_limit = transfer_unpack_limit;
1500         else if (0 <= receive_unpack_limit)
1501                 unpack_limit = receive_unpack_limit;
1502
1503         if (advertise_refs || !stateless_rpc) {
1504                 write_head_info();
1505         }
1506         if (advertise_refs)
1507                 return 0;
1508
1509         if ((commands = read_head_info(&shallow)) != NULL) {
1510                 const char *unpack_status = NULL;
1511
1512                 prepare_shallow_info(&si, &shallow);
1513                 if (!si.nr_ours && !si.nr_theirs)
1514                         shallow_update = 0;
1515                 if (!delete_only(commands)) {
1516                         unpack_status = unpack_with_sideband(&si);
1517                         update_shallow_info(commands, &si, &ref);
1518                 }
1519                 execute_commands(commands, unpack_status, &si);
1520                 if (pack_lockfile)
1521                         unlink_or_warn(pack_lockfile);
1522                 if (report_status)
1523                         report(commands, unpack_status);
1524                 run_receive_hook(commands, "post-receive", 1);
1525                 run_update_post_hook(commands);
1526                 if (auto_gc) {
1527                         const char *argv_gc_auto[] = {
1528                                 "gc", "--auto", "--quiet", NULL,
1529                         };
1530                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1531                         run_command_v_opt(argv_gc_auto, opt);
1532                 }
1533                 if (auto_update_server_info)
1534                         update_server_info(0);
1535                 clear_shallow_info(&si);
1536         }
1537         if (use_sideband)
1538                 packet_flush(1);
1539         sha1_array_clear(&shallow);
1540         sha1_array_clear(&ref);
1541         free((void *)push_cert_nonce);
1542         return 0;
1543 }