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         struct argv_array env = ARGV_ARRAY_INIT;
 457
 458         if (!push_cert.len)
 459                 return;
 460
 461         if (!already_done) {
 462                 struct strbuf gpg_output = STRBUF_INIT;
 463                 struct strbuf gpg_status = STRBUF_INIT;
 464                 int bogs /* beginning_of_gpg_sig */;
 465
 466                 already_done = 1;
 467                 if (write_sha1_file(push_cert.buf, push_cert.len, "blob", push_cert_sha1))
 468                         hashclr(push_cert_sha1);
 469
 470                 memset(&sigcheck, '\0', sizeof(sigcheck));
 471                 sigcheck.result = 'N';
 472
 473                 bogs = parse_signature(push_cert.buf, push_cert.len);
 474                 if (verify_signed_buffer(push_cert.buf, bogs,
 475                                          push_cert.buf + bogs, push_cert.len - bogs,
 476                                          &gpg_output, &gpg_status) < 0) {
 477                         ; /* error running gpg */
 478                 } else {
 479                         sigcheck.payload = push_cert.buf;
 480                         sigcheck.gpg_output = gpg_output.buf;
 481                         sigcheck.gpg_status = gpg_status.buf;
 482                         parse_gpg_output(&sigcheck);
 483                 }
 484
 485                 strbuf_release(&gpg_output);
 486                 strbuf_release(&gpg_status);
 487                 nonce_status = check_nonce(push_cert.buf, bogs);
 488         }
 489         if (!is_null_sha1(push_cert_sha1)) {
 490                 argv_array_pushf(&env, "GIT_PUSH_CERT=%s", sha1_to_hex(push_cert_sha1));
 491                 argv_array_pushf(&env, "GIT_PUSH_CERT_SIGNER=%s",
 492                                  sigcheck.signer ? sigcheck.signer : "");
 493                 argv_array_pushf(&env, "GIT_PUSH_CERT_KEY=%s",
 494                                  sigcheck.key ? sigcheck.key : "");
 495                 argv_array_pushf(&env, "GIT_PUSH_CERT_STATUS=%c", sigcheck.result);
 496                 if (push_cert_nonce) {
 497                         argv_array_pushf(&env, "GIT_PUSH_CERT_NONCE=%s", push_cert_nonce);
 498                         argv_array_pushf(&env, "GIT_PUSH_CERT_NONCE_STATUS=%s", nonce_status);
 499                         if (nonce_status == NONCE_SLOP)
 500                                 argv_array_pushf(&env, "GIT_PUSH_CERT_NONCE_SLOP=%ld",
 501                                                  nonce_stamp_slop);
 502                 }
 503                 proc->env = env.argv;
 504         }
 505 }
 506
 507 typedef int (*feed_fn)(void *, const char **, size_t *);
 508 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 509 {
 510         struct child_process proc = CHILD_PROCESS_INIT;
 511         struct async muxer;
 512         const char *argv[2];
 513         int code;
 514
 515         argv[0] = find_hook(hook_name);
 516         if (!argv[0])
 517                 return 0;
 518
 519         argv[1] = NULL;
 520
 521         proc.argv = argv;
 522         proc.in = -1;
 523         proc.stdout_to_stderr = 1;
 524
 525         prepare_push_cert_sha1(&proc);
 526
 527         if (use_sideband) {
 528                 memset(&muxer, 0, sizeof(muxer));
 529                 muxer.proc = copy_to_sideband;
 530                 muxer.in = -1;
 531                 code = start_async(&muxer);
 532                 if (code)
 533                         return code;
 534                 proc.err = muxer.in;
 535         }
 536
 537         code = start_command(&proc);
 538         if (code) {
 539                 if (use_sideband)
 540                         finish_async(&muxer);
 541                 return code;
 542         }
 543
 544         sigchain_push(SIGPIPE, SIG_IGN);
 545
 546         while (1) {
 547                 const char *buf;
 548                 size_t n;
 549                 if (feed(feed_state, &buf, &n))
 550                         break;
 551                 if (write_in_full(proc.in, buf, n) != n)
 552                         break;
 553         }
 554         close(proc.in);
 555         if (use_sideband)
 556                 finish_async(&muxer);
 557
 558         sigchain_pop(SIGPIPE);
 559
 560         return finish_command(&proc);
 561 }
 562
 563 struct receive_hook_feed_state {
 564         struct command *cmd;
 565         int skip_broken;
 566         struct strbuf buf;
 567 };
 568
 569 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 570 {
 571         struct receive_hook_feed_state *state = state_;
 572         struct command *cmd = state->cmd;
 573
 574         while (cmd &&
 575                state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 576                 cmd = cmd->next;
 577         if (!cmd)
 578                 return -1; /* EOF */
 579         strbuf_reset(&state->buf);
 580         strbuf_addf(&state->buf, "%s %s %s\n",
 581                     sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 582                     cmd->ref_name);
 583         state->cmd = cmd->next;
 584         if (bufp) {
 585                 *bufp = state->buf.buf;
 586                 *sizep = state->buf.len;
 587         }
 588         return 0;
 589 }
 590
 591 static int run_receive_hook(struct command *commands, const char *hook_name,
 592                             int skip_broken)
 593 {
 594         struct receive_hook_feed_state state;
 595         int status;
 596
 597         strbuf_init(&state.buf, 0);
 598         state.cmd = commands;
 599         state.skip_broken = skip_broken;
 600         if (feed_receive_hook(&state, NULL, NULL))
 601                 return 0;
 602         state.cmd = commands;
 603         status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 604         strbuf_release(&state.buf);
 605         return status;
 606 }
 607
 608 static int run_update_hook(struct command *cmd)
 609 {
 610         const char *argv[5];
 611         struct child_process proc = CHILD_PROCESS_INIT;
 612         int code;
 613
 614         argv[0] = find_hook("update");
 615         if (!argv[0])
 616                 return 0;
 617
 618         argv[1] = cmd->ref_name;
 619         argv[2] = sha1_to_hex(cmd->old_sha1);
 620         argv[3] = sha1_to_hex(cmd->new_sha1);
 621         argv[4] = NULL;
 622
 623         proc.no_stdin = 1;
 624         proc.stdout_to_stderr = 1;
 625         proc.err = use_sideband ? -1 : 0;
 626         proc.argv = argv;
 627
 628         code = start_command(&proc);
 629         if (code)
 630                 return code;
 631         if (use_sideband)
 632                 copy_to_sideband(proc.err, -1, NULL);
 633         return finish_command(&proc);
 634 }
 635
 636 static int is_ref_checked_out(const char *ref)
 637 {
 638         if (is_bare_repository())
 639                 return 0;
 640
 641         if (!head_name)
 642                 return 0;
 643         return !strcmp(head_name, ref);
 644 }
 645
 646 static char *refuse_unconfigured_deny_msg[] = {
 647         "By default, updating the current branch in a non-bare repository",
 648         "is denied, because it will make the index and work tree inconsistent",
 649         "with what you pushed, and will require 'git reset --hard' to match",
 650         "the work tree to HEAD.",
 651         "",
 652         "You can set 'receive.denyCurrentBranch' configuration variable to",
 653         "'ignore' or 'warn' in the remote repository to allow pushing into",
 654         "its current branch; however, this is not recommended unless you",
 655         "arranged to update its work tree to match what you pushed in some",
 656         "other way.",
 657         "",
 658         "To squelch this message and still keep the default behaviour, set",
 659         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 660 };
 661
 662 static void refuse_unconfigured_deny(void)
 663 {
 664         int i;
 665         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 666                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 667 }
 668
 669 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 670         "By default, deleting the current branch is denied, because the next",
 671         "'git clone' won't result in any file checked out, causing confusion.",
 672         "",
 673         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 674         "'warn' or 'ignore' in the remote repository to allow deleting the",
 675         "current branch, with or without a warning message.",
 676         "",
 677         "To squelch this message, you can set it to 'refuse'."
 678 };
 679
 680 static void refuse_unconfigured_deny_delete_current(void)
 681 {
 682         int i;
 683         for (i = 0;
 684              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 685              i++)
 686                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 687 }
 688
 689 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
 690 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
 691 {
 692         static struct lock_file shallow_lock;
 693         struct sha1_array extra = SHA1_ARRAY_INIT;
 694         const char *alt_file;
 695         uint32_t mask = 1 << (cmd->index % 32);
 696         int i;
 697
 698         trace_printf_key(&trace_shallow,
 699                          "shallow: update_shallow_ref %s\n", cmd->ref_name);
 700         for (i = 0; i < si->shallow->nr; i++)
 701                 if (si->used_shallow[i] &&
 702                     (si->used_shallow[i][cmd->index / 32] & mask) &&
 703                     !delayed_reachability_test(si, i))
 704                         sha1_array_append(&extra, si->shallow->sha1[i]);
 705
 706         setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
 707         if (check_shallow_connected(command_singleton_iterator,
 708                                     0, cmd, alt_file)) {
 709                 rollback_lock_file(&shallow_lock);
 710                 sha1_array_clear(&extra);
 711                 return -1;
 712         }
 713
 714         commit_lock_file(&shallow_lock);
 715
 716         /*
 717          * Make sure setup_alternate_shallow() for the next ref does
 718          * not lose these new roots..
 719          */
 720         for (i = 0; i < extra.nr; i++)
 721                 register_shallow(extra.sha1[i]);
 722
 723         si->shallow_ref[cmd->index] = 0;
 724         sha1_array_clear(&extra);
 725         return 0;
 726 }
 727
 728 static const char *update(struct command *cmd, struct shallow_info *si)
 729 {
 730         const char *name = cmd->ref_name;
 731         struct strbuf namespaced_name_buf = STRBUF_INIT;
 732         const char *namespaced_name;
 733         unsigned char *old_sha1 = cmd->old_sha1;
 734         unsigned char *new_sha1 = cmd->new_sha1;
 735
 736         /* only refs/... are allowed */
 737         if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
 738                 rp_error("refusing to create funny ref '%s' remotely", name);
 739                 return "funny refname";
 740         }
 741
 742         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 743         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 744
 745         if (is_ref_checked_out(namespaced_name)) {
 746                 switch (deny_current_branch) {
 747                 case DENY_IGNORE:
 748                         break;
 749                 case DENY_WARN:
 750                         rp_warning("updating the current branch");
 751                         break;
 752                 case DENY_REFUSE:
 753                 case DENY_UNCONFIGURED:
 754                         rp_error("refusing to update checked out branch: %s", name);
 755                         if (deny_current_branch == DENY_UNCONFIGURED)
 756                                 refuse_unconfigured_deny();
 757                         return "branch is currently checked out";
 758                 }
 759         }
 760
 761         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 762                 error("unpack should have generated %s, "
 763                       "but I can't find it!", sha1_to_hex(new_sha1));
 764                 return "bad pack";
 765         }
 766
 767         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 768                 if (deny_deletes && starts_with(name, "refs/heads/")) {
 769                         rp_error("denying ref deletion for %s", name);
 770                         return "deletion prohibited";
 771                 }
 772
 773                 if (!strcmp(namespaced_name, head_name)) {
 774                         switch (deny_delete_current) {
 775                         case DENY_IGNORE:
 776                                 break;
 777                         case DENY_WARN:
 778                                 rp_warning("deleting the current branch");
 779                                 break;
 780                         case DENY_REFUSE:
 781                         case DENY_UNCONFIGURED:
 782                                 if (deny_delete_current == DENY_UNCONFIGURED)
 783                                         refuse_unconfigured_deny_delete_current();
 784                                 rp_error("refusing to delete the current branch: %s", name);
 785                                 return "deletion of the current branch prohibited";
 786                         }
 787                 }
 788         }
 789
 790         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 791             !is_null_sha1(old_sha1) &&
 792             starts_with(name, "refs/heads/")) {
 793                 struct object *old_object, *new_object;
 794                 struct commit *old_commit, *new_commit;
 795
 796                 old_object = parse_object(old_sha1);
 797                 new_object = parse_object(new_sha1);
 798
 799                 if (!old_object || !new_object ||
 800                     old_object->type != OBJ_COMMIT ||
 801                     new_object->type != OBJ_COMMIT) {
 802                         error("bad sha1 objects for %s", name);
 803                         return "bad ref";
 804                 }
 805                 old_commit = (struct commit *)old_object;
 806                 new_commit = (struct commit *)new_object;
 807                 if (!in_merge_bases(old_commit, new_commit)) {
 808                         rp_error("denying non-fast-forward %s"
 809                                  " (you should pull first)", name);
 810                         return "non-fast-forward";
 811                 }
 812         }
 813         if (run_update_hook(cmd)) {
 814                 rp_error("hook declined to update %s", name);
 815                 return "hook declined";
 816         }
 817
 818         if (is_null_sha1(new_sha1)) {
 819                 if (!parse_object(old_sha1)) {
 820                         old_sha1 = NULL;
 821                         if (ref_exists(name)) {
 822                                 rp_warning("Allowing deletion of corrupt ref.");
 823                         } else {
 824                                 rp_warning("Deleting a non-existent ref.");
 825                                 cmd->did_not_exist = 1;
 826                         }
 827                 }
 828                 if (delete_ref(namespaced_name, old_sha1, 0)) {
 829                         rp_error("failed to delete %s", name);
 830                         return "failed to delete";
 831                 }
 832                 return NULL; /* good */
 833         }
 834         else {
 835                 struct strbuf err = STRBUF_INIT;
 836                 struct ref_transaction *transaction;
 837
 838                 if (shallow_update && si->shallow_ref[cmd->index] &&
 839                     update_shallow_ref(cmd, si))
 840                         return "shallow error";
 841
 842                 transaction = ref_transaction_begin(&err);
 843                 if (!transaction ||
 844                     ref_transaction_update(transaction, namespaced_name,
 845                                            new_sha1, old_sha1, 0, 1, "push",
 846                                            &err) ||
 847                     ref_transaction_commit(transaction, &err)) {
 848                         ref_transaction_free(transaction);
 849
 850                         rp_error("%s", err.buf);
 851                         strbuf_release(&err);
 852                         return "failed to update ref";
 853                 }
 854
 855                 ref_transaction_free(transaction);
 856                 strbuf_release(&err);
 857                 return NULL; /* good */
 858         }
 859 }
 860
 861 static void run_update_post_hook(struct command *commands)
 862 {
 863         struct command *cmd;
 864         int argc;
 865         const char **argv;
 866         struct child_process proc = CHILD_PROCESS_INIT;
 867         char *hook;
 868
 869         hook = find_hook("post-update");
 870         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 871                 if (cmd->error_string || cmd->did_not_exist)
 872                         continue;
 873                 argc++;
 874         }
 875         if (!argc || !hook)
 876                 return;
 877
 878         argv = xmalloc(sizeof(*argv) * (2 + argc));
 879         argv[0] = hook;
 880
 881         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 882                 if (cmd->error_string || cmd->did_not_exist)
 883                         continue;
 884                 argv[argc] = xstrdup(cmd->ref_name);
 885                 argc++;
 886         }
 887         argv[argc] = NULL;
 888
 889         proc.no_stdin = 1;
 890         proc.stdout_to_stderr = 1;
 891         proc.err = use_sideband ? -1 : 0;
 892         proc.argv = argv;
 893
 894         if (!start_command(&proc)) {
 895                 if (use_sideband)
 896                         copy_to_sideband(proc.err, -1, NULL);
 897                 finish_command(&proc);
 898         }
 899 }
 900
 901 static void check_aliased_update(struct command *cmd, struct string_list *list)
 902 {
 903         struct strbuf buf = STRBUF_INIT;
 904         const char *dst_name;
 905         struct string_list_item *item;
 906         struct command *dst_cmd;
 907         unsigned char sha1[20];
 908         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 909         int flag;
 910
 911         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 912         dst_name = resolve_ref_unsafe(buf.buf, 0, sha1, &flag);
 913         strbuf_release(&buf);
 914
 915         if (!(flag & REF_ISSYMREF))
 916                 return;
 917
 918         dst_name = strip_namespace(dst_name);
 919         if (!dst_name) {
 920                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 921                 cmd->skip_update = 1;
 922                 cmd->error_string = "broken symref";
 923                 return;
 924         }
 925
 926         if ((item = string_list_lookup(list, dst_name)) == NULL)
 927                 return;
 928
 929         cmd->skip_update = 1;
 930
 931         dst_cmd = (struct command *) item->util;
 932
 933         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 934             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 935                 return;
 936
 937         dst_cmd->skip_update = 1;
 938
 939         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 940         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 941         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 942         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 943         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 944                  " its target '%s' (%s..%s)",
 945                  cmd->ref_name, cmd_oldh, cmd_newh,
 946                  dst_cmd->ref_name, dst_oldh, dst_newh);
 947
 948         cmd->error_string = dst_cmd->error_string =
 949                 "inconsistent aliased update";
 950 }
 951
 952 static void check_aliased_updates(struct command *commands)
 953 {
 954         struct command *cmd;
 955         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 956
 957         for (cmd = commands; cmd; cmd = cmd->next) {
 958                 struct string_list_item *item =
 959                         string_list_append(&ref_list, cmd->ref_name);
 960                 item->util = (void *)cmd;
 961         }
 962         sort_string_list(&ref_list);
 963
 964         for (cmd = commands; cmd; cmd = cmd->next) {
 965                 if (!cmd->error_string)
 966                         check_aliased_update(cmd, &ref_list);
 967         }
 968
 969         string_list_clear(&ref_list, 0);
 970 }
 971
 972 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 973 {
 974         struct command **cmd_list = cb_data;
 975         struct command *cmd = *cmd_list;
 976
 977         if (!cmd || is_null_sha1(cmd->new_sha1))
 978                 return -1; /* end of list */
 979         *cmd_list = NULL; /* this returns only one */
 980         hashcpy(sha1, cmd->new_sha1);
 981         return 0;
 982 }
 983
 984 static void set_connectivity_errors(struct command *commands,
 985                                     struct shallow_info *si)
 986 {
 987         struct command *cmd;
 988
 989         for (cmd = commands; cmd; cmd = cmd->next) {
 990                 struct command *singleton = cmd;
 991                 if (shallow_update && si->shallow_ref[cmd->index])
 992                         /* to be checked in update_shallow_ref() */
 993                         continue;
 994                 if (!check_everything_connected(command_singleton_iterator,
 995                                                 0, &singleton))
 996                         continue;
 997                 cmd->error_string = "missing necessary objects";
 998         }
 999 }
1000
1001 struct iterate_data {
1002         struct command *cmds;
1003         struct shallow_info *si;
1004 };
1005
1006 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
1007 {
1008         struct iterate_data *data = cb_data;
1009         struct command **cmd_list = &data->cmds;
1010         struct command *cmd = *cmd_list;
1011
1012         for (; cmd; cmd = cmd->next) {
1013                 if (shallow_update && data->si->shallow_ref[cmd->index])
1014                         /* to be checked in update_shallow_ref() */
1015                         continue;
1016                 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
1017                         hashcpy(sha1, cmd->new_sha1);
1018                         *cmd_list = cmd->next;
1019                         return 0;
1020                 }
1021         }
1022         *cmd_list = NULL;
1023         return -1; /* end of list */
1024 }
1025
1026 static void reject_updates_to_hidden(struct command *commands)
1027 {
1028         struct command *cmd;
1029
1030         for (cmd = commands; cmd; cmd = cmd->next) {
1031                 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
1032                         continue;
1033                 if (is_null_sha1(cmd->new_sha1))
1034                         cmd->error_string = "deny deleting a hidden ref";
1035                 else
1036                         cmd->error_string = "deny updating a hidden ref";
1037         }
1038 }
1039
1040 static void execute_commands(struct command *commands,
1041                              const char *unpacker_error,
1042                              struct shallow_info *si)
1043 {
1044         int checked_connectivity;
1045         struct command *cmd;
1046         unsigned char sha1[20];
1047         struct iterate_data data;
1048
1049         if (unpacker_error) {
1050                 for (cmd = commands; cmd; cmd = cmd->next)
1051                         cmd->error_string = "unpacker error";
1052                 return;
1053         }
1054
1055         data.cmds = commands;
1056         data.si = si;
1057         if (check_everything_connected(iterate_receive_command_list, 0, &data))
1058                 set_connectivity_errors(commands, si);
1059
1060         reject_updates_to_hidden(commands);
1061
1062         if (run_receive_hook(commands, "pre-receive", 0)) {
1063                 for (cmd = commands; cmd; cmd = cmd->next) {
1064                         if (!cmd->error_string)
1065                                 cmd->error_string = "pre-receive hook declined";
1066                 }
1067                 return;
1068         }
1069
1070         check_aliased_updates(commands);
1071
1072         free(head_name_to_free);
1073         head_name = head_name_to_free = resolve_refdup("HEAD", 0, sha1, NULL);
1074
1075         checked_connectivity = 1;
1076         for (cmd = commands; cmd; cmd = cmd->next) {
1077                 if (cmd->error_string)
1078                         continue;
1079
1080                 if (cmd->skip_update)
1081                         continue;
1082
1083                 cmd->error_string = update(cmd, si);
1084                 if (shallow_update && !cmd->error_string &&
1085                     si->shallow_ref[cmd->index]) {
1086                         error("BUG: connectivity check has not been run on ref %s",
1087                               cmd->ref_name);
1088                         checked_connectivity = 0;
1089                 }
1090         }
1091
1092         if (shallow_update && !checked_connectivity)
1093                 error("BUG: run 'git fsck' for safety.\n"
1094                       "If there are errors, try to remove "
1095                       "the reported refs above");
1096 }
1097
1098 static struct command **queue_command(struct command **tail,
1099                                       const char *line,
1100                                       int linelen)
1101 {
1102         unsigned char old_sha1[20], new_sha1[20];
1103         struct command *cmd;
1104         const char *refname;
1105         int reflen;
1106
1107         if (linelen < 83 ||
1108             line[40] != ' ' ||
1109             line[81] != ' ' ||
1110             get_sha1_hex(line, old_sha1) ||
1111             get_sha1_hex(line + 41, new_sha1))
1112                 die("protocol error: expected old/new/ref, got '%s'", line);
1113
1114         refname = line + 82;
1115         reflen = linelen - 82;
1116         cmd = xcalloc(1, sizeof(struct command) + reflen + 1);
1117         hashcpy(cmd->old_sha1, old_sha1);
1118         hashcpy(cmd->new_sha1, new_sha1);
1119         memcpy(cmd->ref_name, refname, reflen);
1120         cmd->ref_name[reflen] = '\0';
1121         *tail = cmd;
1122         return &cmd->next;
1123 }
1124
1125 static void queue_commands_from_cert(struct command **tail,
1126                                      struct strbuf *push_cert)
1127 {
1128         const char *boc, *eoc;
1129
1130         if (*tail)
1131                 die("protocol error: got both push certificate and unsigned commands");
1132
1133         boc = strstr(push_cert->buf, "\n\n");
1134         if (!boc)
1135                 die("malformed push certificate %.*s", 100, push_cert->buf);
1136         else
1137                 boc += 2;
1138         eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1139
1140         while (boc < eoc) {
1141                 const char *eol = memchr(boc, '\n', eoc - boc);
1142                 tail = queue_command(tail, boc, eol ? eol - boc : eoc - eol);
1143                 boc = eol ? eol + 1 : eoc;
1144         }
1145 }
1146
1147 static struct command *read_head_info(struct sha1_array *shallow)
1148 {
1149         struct command *commands = NULL;
1150         struct command **p = &commands;
1151         for (;;) {
1152                 char *line;
1153                 int len, linelen;
1154
1155                 line = packet_read_line(0, &len);
1156                 if (!line)
1157                         break;
1158
1159                 if (len == 48 && starts_with(line, "shallow ")) {
1160                         unsigned char sha1[20];
1161                         if (get_sha1_hex(line + 8, sha1))
1162                                 die("protocol error: expected shallow sha, got '%s'",
1163                                     line + 8);
1164                         sha1_array_append(shallow, sha1);
1165                         continue;
1166                 }
1167
1168                 linelen = strlen(line);
1169                 if (linelen < len) {
1170                         const char *feature_list = line + linelen + 1;
1171                         if (parse_feature_request(feature_list, "report-status"))
1172                                 report_status = 1;
1173                         if (parse_feature_request(feature_list, "side-band-64k"))
1174                                 use_sideband = LARGE_PACKET_MAX;
1175                         if (parse_feature_request(feature_list, "quiet"))
1176                                 quiet = 1;
1177                 }
1178
1179                 if (!strcmp(line, "push-cert")) {
1180                         int true_flush = 0;
1181                         char certbuf[1024];
1182
1183                         for (;;) {
1184                                 len = packet_read(0, NULL, NULL,
1185                                                   certbuf, sizeof(certbuf), 0);
1186                                 if (!len) {
1187                                         true_flush = 1;
1188                                         break;
1189                                 }
1190                                 if (!strcmp(certbuf, "push-cert-end\n"))
1191                                         break; /* end of cert */
1192                                 strbuf_addstr(&push_cert, certbuf);
1193                         }
1194
1195                         if (true_flush)
1196                                 break;
1197                         continue;
1198                 }
1199
1200                 p = queue_command(p, line, linelen);
1201         }
1202
1203         if (push_cert.len)
1204                 queue_commands_from_cert(p, &push_cert);
1205
1206         return commands;
1207 }
1208
1209 static const char *parse_pack_header(struct pack_header *hdr)
1210 {
1211         switch (read_pack_header(0, hdr)) {
1212         case PH_ERROR_EOF:
1213                 return "eof before pack header was fully read";
1214
1215         case PH_ERROR_PACK_SIGNATURE:
1216                 return "protocol error (pack signature mismatch detected)";
1217
1218         case PH_ERROR_PROTOCOL:
1219                 return "protocol error (pack version unsupported)";
1220
1221         default:
1222                 return "unknown error in parse_pack_header";
1223
1224         case 0:
1225                 return NULL;
1226         }
1227 }
1228
1229 static const char *pack_lockfile;
1230
1231 static const char *unpack(int err_fd, struct shallow_info *si)
1232 {
1233         struct pack_header hdr;
1234         const char *hdr_err;
1235         int status;
1236         char hdr_arg[38];
1237         struct child_process child = CHILD_PROCESS_INIT;
1238         int fsck_objects = (receive_fsck_objects >= 0
1239                             ? receive_fsck_objects
1240                             : transfer_fsck_objects >= 0
1241                             ? transfer_fsck_objects
1242                             : 0);
1243
1244         hdr_err = parse_pack_header(&hdr);
1245         if (hdr_err) {
1246                 if (err_fd > 0)
1247                         close(err_fd);
1248                 return hdr_err;
1249         }
1250         snprintf(hdr_arg, sizeof(hdr_arg),
1251                         "--pack_header=%"PRIu32",%"PRIu32,
1252                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
1253
1254         if (si->nr_ours || si->nr_theirs) {
1255                 alt_shallow_file = setup_temporary_shallow(si->shallow);
1256                 argv_array_push(&child.args, "--shallow-file");
1257                 argv_array_push(&child.args, alt_shallow_file);
1258         }
1259
1260         if (ntohl(hdr.hdr_entries) < unpack_limit) {
1261                 argv_array_pushl(&child.args, "unpack-objects", hdr_arg, NULL);
1262                 if (quiet)
1263                         argv_array_push(&child.args, "-q");
1264                 if (fsck_objects)
1265                         argv_array_push(&child.args, "--strict");
1266                 child.no_stdout = 1;
1267                 child.err = err_fd;
1268                 child.git_cmd = 1;
1269                 status = run_command(&child);
1270                 if (status)
1271                         return "unpack-objects abnormal exit";
1272         } else {
1273                 int s;
1274                 char keep_arg[256];
1275
1276                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
1277                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
1278                         strcpy(keep_arg + s, "localhost");
1279
1280                 argv_array_pushl(&child.args, "index-pack",
1281                                  "--stdin", hdr_arg, keep_arg, NULL);
1282                 if (fsck_objects)
1283                         argv_array_push(&child.args, "--strict");
1284                 if (fix_thin)
1285                         argv_array_push(&child.args, "--fix-thin");
1286                 child.out = -1;
1287                 child.err = err_fd;
1288                 child.git_cmd = 1;
1289                 status = start_command(&child);
1290                 if (status)
1291                         return "index-pack fork failed";
1292                 pack_lockfile = index_pack_lockfile(child.out);
1293                 close(child.out);
1294                 status = finish_command(&child);
1295                 if (status)
1296                         return "index-pack abnormal exit";
1297                 reprepare_packed_git();
1298         }
1299         return NULL;
1300 }
1301
1302 static const char *unpack_with_sideband(struct shallow_info *si)
1303 {
1304         struct async muxer;
1305         const char *ret;
1306
1307         if (!use_sideband)
1308                 return unpack(0, si);
1309
1310         memset(&muxer, 0, sizeof(muxer));
1311         muxer.proc = copy_to_sideband;
1312         muxer.in = -1;
1313         if (start_async(&muxer))
1314                 return NULL;
1315
1316         ret = unpack(muxer.in, si);
1317
1318         finish_async(&muxer);
1319         return ret;
1320 }
1321
1322 static void prepare_shallow_update(struct command *commands,
1323                                    struct shallow_info *si)
1324 {
1325         int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1326
1327         si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1328                                    si->shallow->nr);
1329         assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1330
1331         si->need_reachability_test =
1332                 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1333         si->reachable =
1334                 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1335         si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1336
1337         for (i = 0; i < si->nr_ours; i++)
1338                 si->need_reachability_test[si->ours[i]] = 1;
1339
1340         for (i = 0; i < si->shallow->nr; i++) {
1341                 if (!si->used_shallow[i])
1342                         continue;
1343                 for (j = 0; j < bitmap_size; j++) {
1344                         if (!si->used_shallow[i][j])
1345                                 continue;
1346                         si->need_reachability_test[i]++;
1347                         for (k = 0; k < 32; k++)
1348                                 if (si->used_shallow[i][j] & (1 << k))
1349                                         si->shallow_ref[j * 32 + k]++;
1350                 }
1351
1352                 /*
1353                  * true for those associated with some refs and belong
1354                  * in "ours" list aka "step 7 not done yet"
1355                  */
1356                 si->need_reachability_test[i] =
1357                         si->need_reachability_test[i] > 1;
1358         }
1359
1360         /*
1361          * keep hooks happy by forcing a temporary shallow file via
1362          * env variable because we can't add --shallow-file to every
1363          * command. check_everything_connected() will be done with
1364          * true .git/shallow though.
1365          */
1366         setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1367 }
1368
1369 static void update_shallow_info(struct command *commands,
1370                                 struct shallow_info *si,
1371                                 struct sha1_array *ref)
1372 {
1373         struct command *cmd;
1374         int *ref_status;
1375         remove_nonexistent_theirs_shallow(si);
1376         if (!si->nr_ours && !si->nr_theirs) {
1377                 shallow_update = 0;
1378                 return;
1379         }
1380
1381         for (cmd = commands; cmd; cmd = cmd->next) {
1382                 if (is_null_sha1(cmd->new_sha1))
1383                         continue;
1384                 sha1_array_append(ref, cmd->new_sha1);
1385                 cmd->index = ref->nr - 1;
1386         }
1387         si->ref = ref;
1388
1389         if (shallow_update) {
1390                 prepare_shallow_update(commands, si);
1391                 return;
1392         }
1393
1394         ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1395         assign_shallow_commits_to_refs(si, NULL, ref_status);
1396         for (cmd = commands; cmd; cmd = cmd->next) {
1397                 if (is_null_sha1(cmd->new_sha1))
1398                         continue;
1399                 if (ref_status[cmd->index]) {
1400                         cmd->error_string = "shallow update not allowed";
1401                         cmd->skip_update = 1;
1402                 }
1403         }
1404         free(ref_status);
1405 }
1406
1407 static void report(struct command *commands, const char *unpack_status)
1408 {
1409         struct command *cmd;
1410         struct strbuf buf = STRBUF_INIT;
1411
1412         packet_buf_write(&buf, "unpack %s\n",
1413                          unpack_status ? unpack_status : "ok");
1414         for (cmd = commands; cmd; cmd = cmd->next) {
1415                 if (!cmd->error_string)
1416                         packet_buf_write(&buf, "ok %s\n",
1417                                          cmd->ref_name);
1418                 else
1419                         packet_buf_write(&buf, "ng %s %s\n",
1420                                          cmd->ref_name, cmd->error_string);
1421         }
1422         packet_buf_flush(&buf);
1423
1424         if (use_sideband)
1425                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1426         else
1427                 write_or_die(1, buf.buf, buf.len);
1428         strbuf_release(&buf);
1429 }
1430
1431 static int delete_only(struct command *commands)
1432 {
1433         struct command *cmd;
1434         for (cmd = commands; cmd; cmd = cmd->next) {
1435                 if (!is_null_sha1(cmd->new_sha1))
1436                         return 0;
1437         }
1438         return 1;
1439 }
1440
1441 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1442 {
1443         int advertise_refs = 0;
1444         int i;
1445         struct command *commands;
1446         struct sha1_array shallow = SHA1_ARRAY_INIT;
1447         struct sha1_array ref = SHA1_ARRAY_INIT;
1448         struct shallow_info si;
1449
1450         packet_trace_identity("receive-pack");
1451
1452         argv++;
1453         for (i = 1; i < argc; i++) {
1454                 const char *arg = *argv++;
1455
1456                 if (*arg == '-') {
1457                         if (!strcmp(arg, "--quiet")) {
1458                                 quiet = 1;
1459                                 continue;
1460                         }
1461
1462                         if (!strcmp(arg, "--advertise-refs")) {
1463                                 advertise_refs = 1;
1464                                 continue;
1465                         }
1466                         if (!strcmp(arg, "--stateless-rpc")) {
1467                                 stateless_rpc = 1;
1468                                 continue;
1469                         }
1470                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1471                                 fix_thin = 0;
1472                                 continue;
1473                         }
1474
1475                         usage(receive_pack_usage);
1476                 }
1477                 if (service_dir)
1478                         usage(receive_pack_usage);
1479                 service_dir = arg;
1480         }
1481         if (!service_dir)
1482                 usage(receive_pack_usage);
1483
1484         setup_path();
1485
1486         if (!enter_repo(service_dir, 0))
1487                 die("'%s' does not appear to be a git repository", service_dir);
1488
1489         git_config(receive_pack_config, NULL);
1490         if (cert_nonce_seed)
1491                 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1492
1493         if (0 <= transfer_unpack_limit)
1494                 unpack_limit = transfer_unpack_limit;
1495         else if (0 <= receive_unpack_limit)
1496                 unpack_limit = receive_unpack_limit;
1497
1498         if (advertise_refs || !stateless_rpc) {
1499                 write_head_info();
1500         }
1501         if (advertise_refs)
1502                 return 0;
1503
1504         if ((commands = read_head_info(&shallow)) != NULL) {
1505                 const char *unpack_status = NULL;
1506
1507                 prepare_shallow_info(&si, &shallow);
1508                 if (!si.nr_ours && !si.nr_theirs)
1509                         shallow_update = 0;
1510                 if (!delete_only(commands)) {
1511                         unpack_status = unpack_with_sideband(&si);
1512                         update_shallow_info(commands, &si, &ref);
1513                 }
1514                 execute_commands(commands, unpack_status, &si);
1515                 if (pack_lockfile)
1516                         unlink_or_warn(pack_lockfile);
1517                 if (report_status)
1518                         report(commands, unpack_status);
1519                 run_receive_hook(commands, "post-receive", 1);
1520                 run_update_post_hook(commands);
1521                 if (auto_gc) {
1522                         const char *argv_gc_auto[] = {
1523                                 "gc", "--auto", "--quiet", NULL,
1524                         };
1525                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1526                         run_command_v_opt(argv_gc_auto, opt);
1527                 }
1528                 if (auto_update_server_info)
1529                         update_server_info(0);
1530                 clear_shallow_info(&si);
1531         }
1532         if (use_sideband)
1533                 packet_flush(1);
1534         sha1_array_clear(&shallow);
1535         sha1_array_clear(&ref);
1536         free((void *)push_cert_nonce);
1537         return 0;
1538 }