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         if (use_sideband) {
 531                 memset(&muxer, 0, sizeof(muxer));
 532                 muxer.proc = copy_to_sideband;
 533                 muxer.in = -1;
 534                 code = start_async(&muxer);
 535                 if (code)
 536                         return code;
 537                 proc.err = muxer.in;
 538         }
 539
 540         prepare_push_cert_sha1(&proc);
 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 int should_process_cmd(struct command *cmd)
1046 {
1047         return !cmd->error_string && !cmd->skip_update;
1048 }
1049
1050 static void warn_if_skipped_connectivity_check(struct command *commands,
1051                                                struct shallow_info *si)
1052 {
1053         struct command *cmd;
1054         int checked_connectivity = 1;
1055
1056         for (cmd = commands; cmd; cmd = cmd->next) {
1057                 if (should_process_cmd(cmd) && si->shallow_ref[cmd->index]) {
1058                         error("BUG: connectivity check has not been run on ref %s",
1059                               cmd->ref_name);
1060                         checked_connectivity = 0;
1061                 }
1062         }
1063         if (!checked_connectivity)
1064                 die("BUG: connectivity check skipped???");
1065 }
1066
1067 static void execute_commands_non_atomic(struct command *commands,
1068                                         struct shallow_info *si)
1069 {
1070         struct command *cmd;
1071         for (cmd = commands; cmd; cmd = cmd->next) {
1072                 if (!should_process_cmd(cmd))
1073                         continue;
1074
1075                 cmd->error_string = update(cmd, si);
1076         }
1077 }
1078
1079 static void execute_commands(struct command *commands,
1080                              const char *unpacker_error,
1081                              struct shallow_info *si)
1082 {
1083         struct command *cmd;
1084         unsigned char sha1[20];
1085         struct iterate_data data;
1086
1087         if (unpacker_error) {
1088                 for (cmd = commands; cmd; cmd = cmd->next)
1089                         cmd->error_string = "unpacker error";
1090                 return;
1091         }
1092
1093         data.cmds = commands;
1094         data.si = si;
1095         if (check_everything_connected(iterate_receive_command_list, 0, &data))
1096                 set_connectivity_errors(commands, si);
1097
1098         reject_updates_to_hidden(commands);
1099
1100         if (run_receive_hook(commands, "pre-receive", 0)) {
1101                 for (cmd = commands; cmd; cmd = cmd->next) {
1102                         if (!cmd->error_string)
1103                                 cmd->error_string = "pre-receive hook declined";
1104                 }
1105                 return;
1106         }
1107
1108         check_aliased_updates(commands);
1109
1110         free(head_name_to_free);
1111         head_name = head_name_to_free = resolve_refdup("HEAD", 0, sha1, NULL);
1112
1113         execute_commands_non_atomic(commands, si);
1114
1115         if (shallow_update)
1116                 warn_if_skipped_connectivity_check(commands, si);
1117 }
1118
1119 static struct command **queue_command(struct command **tail,
1120                                       const char *line,
1121                                       int linelen)
1122 {
1123         unsigned char old_sha1[20], new_sha1[20];
1124         struct command *cmd;
1125         const char *refname;
1126         int reflen;
1127
1128         if (linelen < 83 ||
1129             line[40] != ' ' ||
1130             line[81] != ' ' ||
1131             get_sha1_hex(line, old_sha1) ||
1132             get_sha1_hex(line + 41, new_sha1))
1133                 die("protocol error: expected old/new/ref, got '%s'", line);
1134
1135         refname = line + 82;
1136         reflen = linelen - 82;
1137         cmd = xcalloc(1, sizeof(struct command) + reflen + 1);
1138         hashcpy(cmd->old_sha1, old_sha1);
1139         hashcpy(cmd->new_sha1, new_sha1);
1140         memcpy(cmd->ref_name, refname, reflen);
1141         cmd->ref_name[reflen] = '\0';
1142         *tail = cmd;
1143         return &cmd->next;
1144 }
1145
1146 static void queue_commands_from_cert(struct command **tail,
1147                                      struct strbuf *push_cert)
1148 {
1149         const char *boc, *eoc;
1150
1151         if (*tail)
1152                 die("protocol error: got both push certificate and unsigned commands");
1153
1154         boc = strstr(push_cert->buf, "\n\n");
1155         if (!boc)
1156                 die("malformed push certificate %.*s", 100, push_cert->buf);
1157         else
1158                 boc += 2;
1159         eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1160
1161         while (boc < eoc) {
1162                 const char *eol = memchr(boc, '\n', eoc - boc);
1163                 tail = queue_command(tail, boc, eol ? eol - boc : eoc - eol);
1164                 boc = eol ? eol + 1 : eoc;
1165         }
1166 }
1167
1168 static struct command *read_head_info(struct sha1_array *shallow)
1169 {
1170         struct command *commands = NULL;
1171         struct command **p = &commands;
1172         for (;;) {
1173                 char *line;
1174                 int len, linelen;
1175
1176                 line = packet_read_line(0, &len);
1177                 if (!line)
1178                         break;
1179
1180                 if (len == 48 && starts_with(line, "shallow ")) {
1181                         unsigned char sha1[20];
1182                         if (get_sha1_hex(line + 8, sha1))
1183                                 die("protocol error: expected shallow sha, got '%s'",
1184                                     line + 8);
1185                         sha1_array_append(shallow, sha1);
1186                         continue;
1187                 }
1188
1189                 linelen = strlen(line);
1190                 if (linelen < len) {
1191                         const char *feature_list = line + linelen + 1;
1192                         if (parse_feature_request(feature_list, "report-status"))
1193                                 report_status = 1;
1194                         if (parse_feature_request(feature_list, "side-band-64k"))
1195                                 use_sideband = LARGE_PACKET_MAX;
1196                         if (parse_feature_request(feature_list, "quiet"))
1197                                 quiet = 1;
1198                 }
1199
1200                 if (!strcmp(line, "push-cert")) {
1201                         int true_flush = 0;
1202                         char certbuf[1024];
1203
1204                         for (;;) {
1205                                 len = packet_read(0, NULL, NULL,
1206                                                   certbuf, sizeof(certbuf), 0);
1207                                 if (!len) {
1208                                         true_flush = 1;
1209                                         break;
1210                                 }
1211                                 if (!strcmp(certbuf, "push-cert-end\n"))
1212                                         break; /* end of cert */
1213                                 strbuf_addstr(&push_cert, certbuf);
1214                         }
1215
1216                         if (true_flush)
1217                                 break;
1218                         continue;
1219                 }
1220
1221                 p = queue_command(p, line, linelen);
1222         }
1223
1224         if (push_cert.len)
1225                 queue_commands_from_cert(p, &push_cert);
1226
1227         return commands;
1228 }
1229
1230 static const char *parse_pack_header(struct pack_header *hdr)
1231 {
1232         switch (read_pack_header(0, hdr)) {
1233         case PH_ERROR_EOF:
1234                 return "eof before pack header was fully read";
1235
1236         case PH_ERROR_PACK_SIGNATURE:
1237                 return "protocol error (pack signature mismatch detected)";
1238
1239         case PH_ERROR_PROTOCOL:
1240                 return "protocol error (pack version unsupported)";
1241
1242         default:
1243                 return "unknown error in parse_pack_header";
1244
1245         case 0:
1246                 return NULL;
1247         }
1248 }
1249
1250 static const char *pack_lockfile;
1251
1252 static const char *unpack(int err_fd, struct shallow_info *si)
1253 {
1254         struct pack_header hdr;
1255         const char *hdr_err;
1256         int status;
1257         char hdr_arg[38];
1258         struct child_process child = CHILD_PROCESS_INIT;
1259         int fsck_objects = (receive_fsck_objects >= 0
1260                             ? receive_fsck_objects
1261                             : transfer_fsck_objects >= 0
1262                             ? transfer_fsck_objects
1263                             : 0);
1264
1265         hdr_err = parse_pack_header(&hdr);
1266         if (hdr_err) {
1267                 if (err_fd > 0)
1268                         close(err_fd);
1269                 return hdr_err;
1270         }
1271         snprintf(hdr_arg, sizeof(hdr_arg),
1272                         "--pack_header=%"PRIu32",%"PRIu32,
1273                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
1274
1275         if (si->nr_ours || si->nr_theirs) {
1276                 alt_shallow_file = setup_temporary_shallow(si->shallow);
1277                 argv_array_push(&child.args, "--shallow-file");
1278                 argv_array_push(&child.args, alt_shallow_file);
1279         }
1280
1281         if (ntohl(hdr.hdr_entries) < unpack_limit) {
1282                 argv_array_pushl(&child.args, "unpack-objects", hdr_arg, NULL);
1283                 if (quiet)
1284                         argv_array_push(&child.args, "-q");
1285                 if (fsck_objects)
1286                         argv_array_push(&child.args, "--strict");
1287                 child.no_stdout = 1;
1288                 child.err = err_fd;
1289                 child.git_cmd = 1;
1290                 status = run_command(&child);
1291                 if (status)
1292                         return "unpack-objects abnormal exit";
1293         } else {
1294                 int s;
1295                 char keep_arg[256];
1296
1297                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
1298                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
1299                         strcpy(keep_arg + s, "localhost");
1300
1301                 argv_array_pushl(&child.args, "index-pack",
1302                                  "--stdin", hdr_arg, keep_arg, NULL);
1303                 if (fsck_objects)
1304                         argv_array_push(&child.args, "--strict");
1305                 if (fix_thin)
1306                         argv_array_push(&child.args, "--fix-thin");
1307                 child.out = -1;
1308                 child.err = err_fd;
1309                 child.git_cmd = 1;
1310                 status = start_command(&child);
1311                 if (status)
1312                         return "index-pack fork failed";
1313                 pack_lockfile = index_pack_lockfile(child.out);
1314                 close(child.out);
1315                 status = finish_command(&child);
1316                 if (status)
1317                         return "index-pack abnormal exit";
1318                 reprepare_packed_git();
1319         }
1320         return NULL;
1321 }
1322
1323 static const char *unpack_with_sideband(struct shallow_info *si)
1324 {
1325         struct async muxer;
1326         const char *ret;
1327
1328         if (!use_sideband)
1329                 return unpack(0, si);
1330
1331         memset(&muxer, 0, sizeof(muxer));
1332         muxer.proc = copy_to_sideband;
1333         muxer.in = -1;
1334         if (start_async(&muxer))
1335                 return NULL;
1336
1337         ret = unpack(muxer.in, si);
1338
1339         finish_async(&muxer);
1340         return ret;
1341 }
1342
1343 static void prepare_shallow_update(struct command *commands,
1344                                    struct shallow_info *si)
1345 {
1346         int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1347
1348         si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1349                                    si->shallow->nr);
1350         assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1351
1352         si->need_reachability_test =
1353                 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1354         si->reachable =
1355                 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1356         si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1357
1358         for (i = 0; i < si->nr_ours; i++)
1359                 si->need_reachability_test[si->ours[i]] = 1;
1360
1361         for (i = 0; i < si->shallow->nr; i++) {
1362                 if (!si->used_shallow[i])
1363                         continue;
1364                 for (j = 0; j < bitmap_size; j++) {
1365                         if (!si->used_shallow[i][j])
1366                                 continue;
1367                         si->need_reachability_test[i]++;
1368                         for (k = 0; k < 32; k++)
1369                                 if (si->used_shallow[i][j] & (1 << k))
1370                                         si->shallow_ref[j * 32 + k]++;
1371                 }
1372
1373                 /*
1374                  * true for those associated with some refs and belong
1375                  * in "ours" list aka "step 7 not done yet"
1376                  */
1377                 si->need_reachability_test[i] =
1378                         si->need_reachability_test[i] > 1;
1379         }
1380
1381         /*
1382          * keep hooks happy by forcing a temporary shallow file via
1383          * env variable because we can't add --shallow-file to every
1384          * command. check_everything_connected() will be done with
1385          * true .git/shallow though.
1386          */
1387         setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1388 }
1389
1390 static void update_shallow_info(struct command *commands,
1391                                 struct shallow_info *si,
1392                                 struct sha1_array *ref)
1393 {
1394         struct command *cmd;
1395         int *ref_status;
1396         remove_nonexistent_theirs_shallow(si);
1397         if (!si->nr_ours && !si->nr_theirs) {
1398                 shallow_update = 0;
1399                 return;
1400         }
1401
1402         for (cmd = commands; cmd; cmd = cmd->next) {
1403                 if (is_null_sha1(cmd->new_sha1))
1404                         continue;
1405                 sha1_array_append(ref, cmd->new_sha1);
1406                 cmd->index = ref->nr - 1;
1407         }
1408         si->ref = ref;
1409
1410         if (shallow_update) {
1411                 prepare_shallow_update(commands, si);
1412                 return;
1413         }
1414
1415         ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1416         assign_shallow_commits_to_refs(si, NULL, ref_status);
1417         for (cmd = commands; cmd; cmd = cmd->next) {
1418                 if (is_null_sha1(cmd->new_sha1))
1419                         continue;
1420                 if (ref_status[cmd->index]) {
1421                         cmd->error_string = "shallow update not allowed";
1422                         cmd->skip_update = 1;
1423                 }
1424         }
1425         free(ref_status);
1426 }
1427
1428 static void report(struct command *commands, const char *unpack_status)
1429 {
1430         struct command *cmd;
1431         struct strbuf buf = STRBUF_INIT;
1432
1433         packet_buf_write(&buf, "unpack %s\n",
1434                          unpack_status ? unpack_status : "ok");
1435         for (cmd = commands; cmd; cmd = cmd->next) {
1436                 if (!cmd->error_string)
1437                         packet_buf_write(&buf, "ok %s\n",
1438                                          cmd->ref_name);
1439                 else
1440                         packet_buf_write(&buf, "ng %s %s\n",
1441                                          cmd->ref_name, cmd->error_string);
1442         }
1443         packet_buf_flush(&buf);
1444
1445         if (use_sideband)
1446                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1447         else
1448                 write_or_die(1, buf.buf, buf.len);
1449         strbuf_release(&buf);
1450 }
1451
1452 static int delete_only(struct command *commands)
1453 {
1454         struct command *cmd;
1455         for (cmd = commands; cmd; cmd = cmd->next) {
1456                 if (!is_null_sha1(cmd->new_sha1))
1457                         return 0;
1458         }
1459         return 1;
1460 }
1461
1462 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1463 {
1464         int advertise_refs = 0;
1465         int i;
1466         struct command *commands;
1467         struct sha1_array shallow = SHA1_ARRAY_INIT;
1468         struct sha1_array ref = SHA1_ARRAY_INIT;
1469         struct shallow_info si;
1470
1471         packet_trace_identity("receive-pack");
1472
1473         argv++;
1474         for (i = 1; i < argc; i++) {
1475                 const char *arg = *argv++;
1476
1477                 if (*arg == '-') {
1478                         if (!strcmp(arg, "--quiet")) {
1479                                 quiet = 1;
1480                                 continue;
1481                         }
1482
1483                         if (!strcmp(arg, "--advertise-refs")) {
1484                                 advertise_refs = 1;
1485                                 continue;
1486                         }
1487                         if (!strcmp(arg, "--stateless-rpc")) {
1488                                 stateless_rpc = 1;
1489                                 continue;
1490                         }
1491                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1492                                 fix_thin = 0;
1493                                 continue;
1494                         }
1495
1496                         usage(receive_pack_usage);
1497                 }
1498                 if (service_dir)
1499                         usage(receive_pack_usage);
1500                 service_dir = arg;
1501         }
1502         if (!service_dir)
1503                 usage(receive_pack_usage);
1504
1505         setup_path();
1506
1507         if (!enter_repo(service_dir, 0))
1508                 die("'%s' does not appear to be a git repository", service_dir);
1509
1510         git_config(receive_pack_config, NULL);
1511         if (cert_nonce_seed)
1512                 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1513
1514         if (0 <= transfer_unpack_limit)
1515                 unpack_limit = transfer_unpack_limit;
1516         else if (0 <= receive_unpack_limit)
1517                 unpack_limit = receive_unpack_limit;
1518
1519         if (advertise_refs || !stateless_rpc) {
1520                 write_head_info();
1521         }
1522         if (advertise_refs)
1523                 return 0;
1524
1525         if ((commands = read_head_info(&shallow)) != NULL) {
1526                 const char *unpack_status = NULL;
1527
1528                 prepare_shallow_info(&si, &shallow);
1529                 if (!si.nr_ours && !si.nr_theirs)
1530                         shallow_update = 0;
1531                 if (!delete_only(commands)) {
1532                         unpack_status = unpack_with_sideband(&si);
1533                         update_shallow_info(commands, &si, &ref);
1534                 }
1535                 execute_commands(commands, unpack_status, &si);
1536                 if (pack_lockfile)
1537                         unlink_or_warn(pack_lockfile);
1538                 if (report_status)
1539                         report(commands, unpack_status);
1540                 run_receive_hook(commands, "post-receive", 1);
1541                 run_update_post_hook(commands);
1542                 if (auto_gc) {
1543                         const char *argv_gc_auto[] = {
1544                                 "gc", "--auto", "--quiet", NULL,
1545                         };
1546                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1547                         run_command_v_opt(argv_gc_auto, opt);
1548                 }
1549                 if (auto_update_server_info)
1550                         update_server_info(0);
1551                 clear_shallow_info(&si);
1552         }
1553         if (use_sideband)
1554                 packet_flush(1);
1555         sha1_array_clear(&shallow);
1556         sha1_array_clear(&ref);
1557         free((void *)push_cert_nonce);
1558         return 0;
1559 }