send-pack.con commit Merge branch 'jc/verify-loose-object-header' into maint (f7f0a87)
   1#include "builtin.h"
   2#include "commit.h"
   3#include "refs.h"
   4#include "pkt-line.h"
   5#include "sideband.h"
   6#include "run-command.h"
   7#include "remote.h"
   8#include "connect.h"
   9#include "send-pack.h"
  10#include "quote.h"
  11#include "transport.h"
  12#include "version.h"
  13#include "sha1-array.h"
  14#include "gpg-interface.h"
  15#include "cache.h"
  16
  17int option_parse_push_signed(const struct option *opt,
  18                             const char *arg, int unset)
  19{
  20        if (unset) {
  21                *(int *)(opt->value) = SEND_PACK_PUSH_CERT_NEVER;
  22                return 0;
  23        }
  24        switch (git_parse_maybe_bool(arg)) {
  25        case 1:
  26                *(int *)(opt->value) = SEND_PACK_PUSH_CERT_ALWAYS;
  27                return 0;
  28        case 0:
  29                *(int *)(opt->value) = SEND_PACK_PUSH_CERT_NEVER;
  30                return 0;
  31        }
  32        if (!strcasecmp("if-asked", arg)) {
  33                *(int *)(opt->value) = SEND_PACK_PUSH_CERT_IF_ASKED;
  34                return 0;
  35        }
  36        die("bad %s argument: %s", opt->long_name, arg);
  37}
  38
  39static void feed_object(const unsigned char *sha1, FILE *fh, int negative)
  40{
  41        if (negative && !has_sha1_file(sha1))
  42                return;
  43
  44        if (negative)
  45                putc('^', fh);
  46        fputs(sha1_to_hex(sha1), fh);
  47        putc('\n', fh);
  48}
  49
  50/*
  51 * Make a pack stream and spit it out into file descriptor fd
  52 */
  53static int pack_objects(int fd, struct ref *refs, struct sha1_array *extra, struct send_pack_args *args)
  54{
  55        /*
  56         * The child becomes pack-objects --revs; we feed
  57         * the revision parameters to it via its stdin and
  58         * let its stdout go back to the other end.
  59         */
  60        const char *argv[] = {
  61                "pack-objects",
  62                "--all-progress-implied",
  63                "--revs",
  64                "--stdout",
  65                NULL,
  66                NULL,
  67                NULL,
  68                NULL,
  69                NULL,
  70                NULL,
  71        };
  72        struct child_process po = CHILD_PROCESS_INIT;
  73        FILE *po_in;
  74        int i;
  75
  76        i = 4;
  77        if (args->use_thin_pack)
  78                argv[i++] = "--thin";
  79        if (args->use_ofs_delta)
  80                argv[i++] = "--delta-base-offset";
  81        if (args->quiet || !args->progress)
  82                argv[i++] = "-q";
  83        if (args->progress)
  84                argv[i++] = "--progress";
  85        if (is_repository_shallow())
  86                argv[i++] = "--shallow";
  87        po.argv = argv;
  88        po.in = -1;
  89        po.out = args->stateless_rpc ? -1 : fd;
  90        po.git_cmd = 1;
  91        if (start_command(&po))
  92                die_errno("git pack-objects failed");
  93
  94        /*
  95         * We feed the pack-objects we just spawned with revision
  96         * parameters by writing to the pipe.
  97         */
  98        po_in = xfdopen(po.in, "w");
  99        for (i = 0; i < extra->nr; i++)
 100                feed_object(extra->sha1[i], po_in, 1);
 101
 102        while (refs) {
 103                if (!is_null_oid(&refs->old_oid))
 104                        feed_object(refs->old_oid.hash, po_in, 1);
 105                if (!is_null_oid(&refs->new_oid))
 106                        feed_object(refs->new_oid.hash, po_in, 0);
 107                refs = refs->next;
 108        }
 109
 110        fflush(po_in);
 111        if (ferror(po_in))
 112                die_errno("error writing to pack-objects");
 113        fclose(po_in);
 114
 115        if (args->stateless_rpc) {
 116                char *buf = xmalloc(LARGE_PACKET_MAX);
 117                while (1) {
 118                        ssize_t n = xread(po.out, buf, LARGE_PACKET_MAX);
 119                        if (n <= 0)
 120                                break;
 121                        send_sideband(fd, -1, buf, n, LARGE_PACKET_MAX);
 122                }
 123                free(buf);
 124                close(po.out);
 125                po.out = -1;
 126        }
 127
 128        if (finish_command(&po))
 129                return -1;
 130        return 0;
 131}
 132
 133static int receive_status(int in, struct ref *refs)
 134{
 135        struct ref *hint;
 136        int ret = 0;
 137        char *line = packet_read_line(in, NULL);
 138        if (!starts_with(line, "unpack "))
 139                return error("did not receive remote status");
 140        if (strcmp(line, "unpack ok")) {
 141                error("unpack failed: %s", line + 7);
 142                ret = -1;
 143        }
 144        hint = NULL;
 145        while (1) {
 146                char *refname;
 147                char *msg;
 148                line = packet_read_line(in, NULL);
 149                if (!line)
 150                        break;
 151                if (!starts_with(line, "ok ") && !starts_with(line, "ng ")) {
 152                        error("invalid ref status from remote: %s", line);
 153                        ret = -1;
 154                        break;
 155                }
 156
 157                refname = line + 3;
 158                msg = strchr(refname, ' ');
 159                if (msg)
 160                        *msg++ = '\0';
 161
 162                /* first try searching at our hint, falling back to all refs */
 163                if (hint)
 164                        hint = find_ref_by_name(hint, refname);
 165                if (!hint)
 166                        hint = find_ref_by_name(refs, refname);
 167                if (!hint) {
 168                        warning("remote reported status on unknown ref: %s",
 169                                        refname);
 170                        continue;
 171                }
 172                if (hint->status != REF_STATUS_EXPECTING_REPORT) {
 173                        warning("remote reported status on unexpected ref: %s",
 174                                        refname);
 175                        continue;
 176                }
 177
 178                if (line[0] == 'o' && line[1] == 'k')
 179                        hint->status = REF_STATUS_OK;
 180                else {
 181                        hint->status = REF_STATUS_REMOTE_REJECT;
 182                        ret = -1;
 183                }
 184                if (msg)
 185                        hint->remote_status = xstrdup(msg);
 186                /* start our next search from the next ref */
 187                hint = hint->next;
 188        }
 189        return ret;
 190}
 191
 192static int sideband_demux(int in, int out, void *data)
 193{
 194        int *fd = data, ret;
 195#ifdef NO_PTHREADS
 196        close(fd[1]);
 197#endif
 198        ret = recv_sideband("send-pack", fd[0], out);
 199        close(out);
 200        return ret;
 201}
 202
 203static int advertise_shallow_grafts_cb(const struct commit_graft *graft, void *cb)
 204{
 205        struct strbuf *sb = cb;
 206        if (graft->nr_parent == -1)
 207                packet_buf_write(sb, "shallow %s\n", oid_to_hex(&graft->oid));
 208        return 0;
 209}
 210
 211static void advertise_shallow_grafts_buf(struct strbuf *sb)
 212{
 213        if (!is_repository_shallow())
 214                return;
 215        for_each_commit_graft(advertise_shallow_grafts_cb, sb);
 216}
 217
 218#define CHECK_REF_NO_PUSH -1
 219#define CHECK_REF_STATUS_REJECTED -2
 220#define CHECK_REF_UPTODATE -3
 221static int check_to_send_update(const struct ref *ref, const struct send_pack_args *args)
 222{
 223        if (!ref->peer_ref && !args->send_mirror)
 224                return CHECK_REF_NO_PUSH;
 225
 226        /* Check for statuses set by set_ref_status_for_push() */
 227        switch (ref->status) {
 228        case REF_STATUS_REJECT_NONFASTFORWARD:
 229        case REF_STATUS_REJECT_ALREADY_EXISTS:
 230        case REF_STATUS_REJECT_FETCH_FIRST:
 231        case REF_STATUS_REJECT_NEEDS_FORCE:
 232        case REF_STATUS_REJECT_STALE:
 233        case REF_STATUS_REJECT_NODELETE:
 234                return CHECK_REF_STATUS_REJECTED;
 235        case REF_STATUS_UPTODATE:
 236                return CHECK_REF_UPTODATE;
 237        default:
 238                return 0;
 239        }
 240}
 241
 242/*
 243 * the beginning of the next line, or the end of buffer.
 244 *
 245 * NEEDSWORK: perhaps move this to git-compat-util.h or somewhere and
 246 * convert many similar uses found by "git grep -A4 memchr".
 247 */
 248static const char *next_line(const char *line, size_t len)
 249{
 250        const char *nl = memchr(line, '\n', len);
 251        if (!nl)
 252                return line + len; /* incomplete line */
 253        return nl + 1;
 254}
 255
 256static int generate_push_cert(struct strbuf *req_buf,
 257                              const struct ref *remote_refs,
 258                              struct send_pack_args *args,
 259                              const char *cap_string,
 260                              const char *push_cert_nonce)
 261{
 262        const struct ref *ref;
 263        struct string_list_item *item;
 264        char *signing_key = xstrdup(get_signing_key());
 265        const char *cp, *np;
 266        struct strbuf cert = STRBUF_INIT;
 267        int update_seen = 0;
 268
 269        strbuf_addstr(&cert, "certificate version 0.1\n");
 270        strbuf_addf(&cert, "pusher %s ", signing_key);
 271        datestamp(&cert);
 272        strbuf_addch(&cert, '\n');
 273        if (args->url && *args->url) {
 274                char *anon_url = transport_anonymize_url(args->url);
 275                strbuf_addf(&cert, "pushee %s\n", anon_url);
 276                free(anon_url);
 277        }
 278        if (push_cert_nonce[0])
 279                strbuf_addf(&cert, "nonce %s\n", push_cert_nonce);
 280        if (args->push_options)
 281                for_each_string_list_item(item, args->push_options)
 282                        strbuf_addf(&cert, "push-option %s\n", item->string);
 283        strbuf_addstr(&cert, "\n");
 284
 285        for (ref = remote_refs; ref; ref = ref->next) {
 286                if (check_to_send_update(ref, args) < 0)
 287                        continue;
 288                update_seen = 1;
 289                strbuf_addf(&cert, "%s %s %s\n",
 290                            oid_to_hex(&ref->old_oid),
 291                            oid_to_hex(&ref->new_oid),
 292                            ref->name);
 293        }
 294        if (!update_seen)
 295                goto free_return;
 296
 297        if (sign_buffer(&cert, &cert, signing_key))
 298                die(_("failed to sign the push certificate"));
 299
 300        packet_buf_write(req_buf, "push-cert%c%s", 0, cap_string);
 301        for (cp = cert.buf; cp < cert.buf + cert.len; cp = np) {
 302                np = next_line(cp, cert.buf + cert.len - cp);
 303                packet_buf_write(req_buf,
 304                                 "%.*s", (int)(np - cp), cp);
 305        }
 306        packet_buf_write(req_buf, "push-cert-end\n");
 307
 308free_return:
 309        free(signing_key);
 310        strbuf_release(&cert);
 311        return update_seen;
 312}
 313
 314
 315static int atomic_push_failure(struct send_pack_args *args,
 316                               struct ref *remote_refs,
 317                               struct ref *failing_ref)
 318{
 319        struct ref *ref;
 320        /* Mark other refs as failed */
 321        for (ref = remote_refs; ref; ref = ref->next) {
 322                if (!ref->peer_ref && !args->send_mirror)
 323                        continue;
 324
 325                switch (ref->status) {
 326                case REF_STATUS_EXPECTING_REPORT:
 327                        ref->status = REF_STATUS_ATOMIC_PUSH_FAILED;
 328                        continue;
 329                default:
 330                        break; /* do nothing */
 331                }
 332        }
 333        return error("atomic push failed for ref %s. status: %d\n",
 334                     failing_ref->name, failing_ref->status);
 335}
 336
 337#define NONCE_LEN_LIMIT 256
 338
 339static void reject_invalid_nonce(const char *nonce, int len)
 340{
 341        int i = 0;
 342
 343        if (NONCE_LEN_LIMIT <= len)
 344                die("the receiving end asked to sign an invalid nonce <%.*s>",
 345                    len, nonce);
 346
 347        for (i = 0; i < len; i++) {
 348                int ch = nonce[i] & 0xFF;
 349                if (isalnum(ch) ||
 350                    ch == '-' || ch == '.' ||
 351                    ch == '/' || ch == '+' ||
 352                    ch == '=' || ch == '_')
 353                        continue;
 354                die("the receiving end asked to sign an invalid nonce <%.*s>",
 355                    len, nonce);
 356        }
 357}
 358
 359int send_pack(struct send_pack_args *args,
 360              int fd[], struct child_process *conn,
 361              struct ref *remote_refs,
 362              struct sha1_array *extra_have)
 363{
 364        int in = fd[0];
 365        int out = fd[1];
 366        struct strbuf req_buf = STRBUF_INIT;
 367        struct strbuf cap_buf = STRBUF_INIT;
 368        struct ref *ref;
 369        int need_pack_data = 0;
 370        int allow_deleting_refs = 0;
 371        int status_report = 0;
 372        int use_sideband = 0;
 373        int quiet_supported = 0;
 374        int agent_supported = 0;
 375        int use_atomic = 0;
 376        int atomic_supported = 0;
 377        int use_push_options = 0;
 378        int push_options_supported = 0;
 379        unsigned cmds_sent = 0;
 380        int ret;
 381        struct async demux;
 382        const char *push_cert_nonce = NULL;
 383
 384        /* Does the other end support the reporting? */
 385        if (server_supports("report-status"))
 386                status_report = 1;
 387        if (server_supports("delete-refs"))
 388                allow_deleting_refs = 1;
 389        if (server_supports("ofs-delta"))
 390                args->use_ofs_delta = 1;
 391        if (server_supports("side-band-64k"))
 392                use_sideband = 1;
 393        if (server_supports("quiet"))
 394                quiet_supported = 1;
 395        if (server_supports("agent"))
 396                agent_supported = 1;
 397        if (server_supports("no-thin"))
 398                args->use_thin_pack = 0;
 399        if (server_supports("atomic"))
 400                atomic_supported = 1;
 401        if (server_supports("push-options"))
 402                push_options_supported = 1;
 403
 404        if (args->push_cert != SEND_PACK_PUSH_CERT_NEVER) {
 405                int len;
 406                push_cert_nonce = server_feature_value("push-cert", &len);
 407                if (push_cert_nonce) {
 408                        reject_invalid_nonce(push_cert_nonce, len);
 409                        push_cert_nonce = xmemdupz(push_cert_nonce, len);
 410                } else if (args->push_cert == SEND_PACK_PUSH_CERT_ALWAYS) {
 411                        die(_("the receiving end does not support --signed push"));
 412                } else if (args->push_cert == SEND_PACK_PUSH_CERT_IF_ASKED) {
 413                        warning(_("not sending a push certificate since the"
 414                                  " receiving end does not support --signed"
 415                                  " push"));
 416                }
 417        }
 418
 419        if (!remote_refs) {
 420                fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
 421                        "Perhaps you should specify a branch such as 'master'.\n");
 422                return 0;
 423        }
 424        if (args->atomic && !atomic_supported)
 425                die(_("the receiving end does not support --atomic push"));
 426
 427        use_atomic = atomic_supported && args->atomic;
 428
 429        if (args->push_options && !push_options_supported)
 430                die(_("the receiving end does not support push options"));
 431
 432        use_push_options = push_options_supported && args->push_options;
 433
 434        if (status_report)
 435                strbuf_addstr(&cap_buf, " report-status");
 436        if (use_sideband)
 437                strbuf_addstr(&cap_buf, " side-band-64k");
 438        if (quiet_supported && (args->quiet || !args->progress))
 439                strbuf_addstr(&cap_buf, " quiet");
 440        if (use_atomic)
 441                strbuf_addstr(&cap_buf, " atomic");
 442        if (use_push_options)
 443                strbuf_addstr(&cap_buf, " push-options");
 444        if (agent_supported)
 445                strbuf_addf(&cap_buf, " agent=%s", git_user_agent_sanitized());
 446
 447        /*
 448         * NEEDSWORK: why does delete-refs have to be so specific to
 449         * send-pack machinery that set_ref_status_for_push() cannot
 450         * set this bit for us???
 451         */
 452        for (ref = remote_refs; ref; ref = ref->next)
 453                if (ref->deletion && !allow_deleting_refs)
 454                        ref->status = REF_STATUS_REJECT_NODELETE;
 455
 456        if (!args->dry_run)
 457                advertise_shallow_grafts_buf(&req_buf);
 458
 459        if (!args->dry_run && push_cert_nonce)
 460                cmds_sent = generate_push_cert(&req_buf, remote_refs, args,
 461                                               cap_buf.buf, push_cert_nonce);
 462
 463        /*
 464         * Clear the status for each ref and see if we need to send
 465         * the pack data.
 466         */
 467        for (ref = remote_refs; ref; ref = ref->next) {
 468                switch (check_to_send_update(ref, args)) {
 469                case 0: /* no error */
 470                        break;
 471                case CHECK_REF_STATUS_REJECTED:
 472                        /*
 473                         * When we know the server would reject a ref update if
 474                         * we were to send it and we're trying to send the refs
 475                         * atomically, abort the whole operation.
 476                         */
 477                        if (use_atomic)
 478                                return atomic_push_failure(args, remote_refs, ref);
 479                        /* Fallthrough for non atomic case. */
 480                default:
 481                        continue;
 482                }
 483                if (!ref->deletion)
 484                        need_pack_data = 1;
 485
 486                if (args->dry_run || !status_report)
 487                        ref->status = REF_STATUS_OK;
 488                else
 489                        ref->status = REF_STATUS_EXPECTING_REPORT;
 490        }
 491
 492        /*
 493         * Finally, tell the other end!
 494         */
 495        for (ref = remote_refs; ref; ref = ref->next) {
 496                char *old_hex, *new_hex;
 497
 498                if (args->dry_run || push_cert_nonce)
 499                        continue;
 500
 501                if (check_to_send_update(ref, args) < 0)
 502                        continue;
 503
 504                old_hex = oid_to_hex(&ref->old_oid);
 505                new_hex = oid_to_hex(&ref->new_oid);
 506                if (!cmds_sent) {
 507                        packet_buf_write(&req_buf,
 508                                         "%s %s %s%c%s",
 509                                         old_hex, new_hex, ref->name, 0,
 510                                         cap_buf.buf);
 511                        cmds_sent = 1;
 512                } else {
 513                        packet_buf_write(&req_buf, "%s %s %s",
 514                                         old_hex, new_hex, ref->name);
 515                }
 516        }
 517
 518        if (args->stateless_rpc) {
 519                if (!args->dry_run && (cmds_sent || is_repository_shallow())) {
 520                        packet_buf_flush(&req_buf);
 521                        send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);
 522                }
 523        } else {
 524                write_or_die(out, req_buf.buf, req_buf.len);
 525                packet_flush(out);
 526        }
 527        strbuf_release(&req_buf);
 528        strbuf_release(&cap_buf);
 529
 530        if (use_push_options) {
 531                struct string_list_item *item;
 532                struct strbuf sb = STRBUF_INIT;
 533
 534                for_each_string_list_item(item, args->push_options)
 535                        packet_buf_write(&sb, "%s", item->string);
 536
 537                write_or_die(out, sb.buf, sb.len);
 538                packet_flush(out);
 539                strbuf_release(&sb);
 540        }
 541
 542        if (use_sideband && cmds_sent) {
 543                memset(&demux, 0, sizeof(demux));
 544                demux.proc = sideband_demux;
 545                demux.data = fd;
 546                demux.out = -1;
 547                demux.isolate_sigpipe = 1;
 548                if (start_async(&demux))
 549                        die("send-pack: unable to fork off sideband demultiplexer");
 550                in = demux.out;
 551        }
 552
 553        if (need_pack_data && cmds_sent) {
 554                if (pack_objects(out, remote_refs, extra_have, args) < 0) {
 555                        for (ref = remote_refs; ref; ref = ref->next)
 556                                ref->status = REF_STATUS_NONE;
 557                        if (args->stateless_rpc)
 558                                close(out);
 559                        if (git_connection_is_socket(conn))
 560                                shutdown(fd[0], SHUT_WR);
 561                        if (use_sideband) {
 562                                close(demux.out);
 563                                finish_async(&demux);
 564                        }
 565                        fd[1] = -1;
 566                        return -1;
 567                }
 568                if (!args->stateless_rpc)
 569                        /* Closed by pack_objects() via start_command() */
 570                        fd[1] = -1;
 571        }
 572        if (args->stateless_rpc && cmds_sent)
 573                packet_flush(out);
 574
 575        if (status_report && cmds_sent)
 576                ret = receive_status(in, remote_refs);
 577        else
 578                ret = 0;
 579        if (args->stateless_rpc)
 580                packet_flush(out);
 581
 582        if (use_sideband && cmds_sent) {
 583                close(demux.out);
 584                if (finish_async(&demux)) {
 585                        error("error in sideband demultiplexer");
 586                        ret = -1;
 587                }
 588        }
 589
 590        if (ret < 0)
 591                return ret;
 592
 593        if (args->porcelain)
 594                return 0;
 595
 596        for (ref = remote_refs; ref; ref = ref->next) {
 597                switch (ref->status) {
 598                case REF_STATUS_NONE:
 599                case REF_STATUS_UPTODATE:
 600                case REF_STATUS_OK:
 601                        break;
 602                default:
 603                        return -1;
 604                }
 605        }
 606        return 0;
 607}