http-push.con commit Merge branch 'pw/add-p-single' (60f8b89)
   1#include "cache.h"
   2#include "commit.h"
   3#include "tag.h"
   4#include "blob.h"
   5#include "http.h"
   6#include "refs.h"
   7#include "diff.h"
   8#include "revision.h"
   9#include "exec_cmd.h"
  10#include "remote.h"
  11#include "list-objects.h"
  12#include "sigchain.h"
  13#include "argv-array.h"
  14#include "packfile.h"
  15
  16#ifdef EXPAT_NEEDS_XMLPARSE_H
  17#include <xmlparse.h>
  18#else
  19#include <expat.h>
  20#endif
  21
  22static const char http_push_usage[] =
  23"git http-push [--all] [--dry-run] [--force] [--verbose] <remote> [<head>...]\n";
  24
  25#ifndef XML_STATUS_OK
  26enum XML_Status {
  27  XML_STATUS_OK = 1,
  28  XML_STATUS_ERROR = 0
  29};
  30#define XML_STATUS_OK    1
  31#define XML_STATUS_ERROR 0
  32#endif
  33
  34#define PREV_BUF_SIZE 4096
  35
  36/* DAV methods */
  37#define DAV_LOCK "LOCK"
  38#define DAV_MKCOL "MKCOL"
  39#define DAV_MOVE "MOVE"
  40#define DAV_PROPFIND "PROPFIND"
  41#define DAV_PUT "PUT"
  42#define DAV_UNLOCK "UNLOCK"
  43#define DAV_DELETE "DELETE"
  44
  45/* DAV lock flags */
  46#define DAV_PROP_LOCKWR (1u << 0)
  47#define DAV_PROP_LOCKEX (1u << 1)
  48#define DAV_LOCK_OK (1u << 2)
  49
  50/* DAV XML properties */
  51#define DAV_CTX_LOCKENTRY ".multistatus.response.propstat.prop.supportedlock.lockentry"
  52#define DAV_CTX_LOCKTYPE_WRITE ".multistatus.response.propstat.prop.supportedlock.lockentry.locktype.write"
  53#define DAV_CTX_LOCKTYPE_EXCLUSIVE ".multistatus.response.propstat.prop.supportedlock.lockentry.lockscope.exclusive"
  54#define DAV_ACTIVELOCK_OWNER ".prop.lockdiscovery.activelock.owner.href"
  55#define DAV_ACTIVELOCK_TIMEOUT ".prop.lockdiscovery.activelock.timeout"
  56#define DAV_ACTIVELOCK_TOKEN ".prop.lockdiscovery.activelock.locktoken.href"
  57#define DAV_PROPFIND_RESP ".multistatus.response"
  58#define DAV_PROPFIND_NAME ".multistatus.response.href"
  59#define DAV_PROPFIND_COLLECTION ".multistatus.response.propstat.prop.resourcetype.collection"
  60
  61/* DAV request body templates */
  62#define PROPFIND_SUPPORTEDLOCK_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:prop xmlns:R=\"%s\">\n<D:supportedlock/>\n</D:prop>\n</D:propfind>"
  63#define PROPFIND_ALL_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/>\n</D:propfind>"
  64#define LOCK_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:lockinfo xmlns:D=\"DAV:\">\n<D:lockscope><D:exclusive/></D:lockscope>\n<D:locktype><D:write/></D:locktype>\n<D:owner>\n<D:href>mailto:%s</D:href>\n</D:owner>\n</D:lockinfo>"
  65
  66#define LOCK_TIME 600
  67#define LOCK_REFRESH 30
  68
  69/* Remember to update object flag allocation in object.h */
  70#define LOCAL    (1u<<16)
  71#define REMOTE   (1u<<17)
  72#define FETCHING (1u<<18)
  73#define PUSHING  (1u<<19)
  74
  75/* We allow "recursive" symbolic refs. Only within reason, though */
  76#define MAXDEPTH 5
  77
  78static int pushing;
  79static int aborted;
  80static signed char remote_dir_exists[256];
  81
  82static int push_verbosely;
  83static int push_all = MATCH_REFS_NONE;
  84static int force_all;
  85static int dry_run;
  86static int helper_status;
  87
  88static struct object_list *objects;
  89
  90struct repo {
  91        char *url;
  92        char *path;
  93        int path_len;
  94        int has_info_refs;
  95        int can_update_info_refs;
  96        int has_info_packs;
  97        struct packed_git *packs;
  98        struct remote_lock *locks;
  99};
 100
 101static struct repo *repo;
 102
 103enum transfer_state {
 104        NEED_FETCH,
 105        RUN_FETCH_LOOSE,
 106        RUN_FETCH_PACKED,
 107        NEED_PUSH,
 108        RUN_MKCOL,
 109        RUN_PUT,
 110        RUN_MOVE,
 111        ABORTED,
 112        COMPLETE
 113};
 114
 115struct transfer_request {
 116        struct object *obj;
 117        char *url;
 118        char *dest;
 119        struct remote_lock *lock;
 120        struct curl_slist *headers;
 121        struct buffer buffer;
 122        enum transfer_state state;
 123        CURLcode curl_result;
 124        char errorstr[CURL_ERROR_SIZE];
 125        long http_code;
 126        void *userData;
 127        struct active_request_slot *slot;
 128        struct transfer_request *next;
 129};
 130
 131static struct transfer_request *request_queue_head;
 132
 133struct xml_ctx {
 134        char *name;
 135        int len;
 136        char *cdata;
 137        void (*userFunc)(struct xml_ctx *ctx, int tag_closed);
 138        void *userData;
 139};
 140
 141struct remote_lock {
 142        char *url;
 143        char *owner;
 144        char *token;
 145        char tmpfile_suffix[41];
 146        time_t start_time;
 147        long timeout;
 148        int refreshing;
 149        struct remote_lock *next;
 150};
 151
 152/* Flags that control remote_ls processing */
 153#define PROCESS_FILES (1u << 0)
 154#define PROCESS_DIRS  (1u << 1)
 155#define RECURSIVE     (1u << 2)
 156
 157/* Flags that remote_ls passes to callback functions */
 158#define IS_DIR (1u << 0)
 159
 160struct remote_ls_ctx {
 161        char *path;
 162        void (*userFunc)(struct remote_ls_ctx *ls);
 163        void *userData;
 164        int flags;
 165        char *dentry_name;
 166        int dentry_flags;
 167        struct remote_ls_ctx *parent;
 168};
 169
 170/* get_dav_token_headers options */
 171enum dav_header_flag {
 172        DAV_HEADER_IF = (1u << 0),
 173        DAV_HEADER_LOCK = (1u << 1),
 174        DAV_HEADER_TIMEOUT = (1u << 2)
 175};
 176
 177static char *xml_entities(const char *s)
 178{
 179        struct strbuf buf = STRBUF_INIT;
 180        strbuf_addstr_xml_quoted(&buf, s);
 181        return strbuf_detach(&buf, NULL);
 182}
 183
 184static void curl_setup_http_get(CURL *curl, const char *url,
 185                const char *custom_req)
 186{
 187        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
 188        curl_easy_setopt(curl, CURLOPT_URL, url);
 189        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, custom_req);
 190        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, fwrite_null);
 191}
 192
 193static void curl_setup_http(CURL *curl, const char *url,
 194                const char *custom_req, struct buffer *buffer,
 195                curl_write_callback write_fn)
 196{
 197        curl_easy_setopt(curl, CURLOPT_PUT, 1);
 198        curl_easy_setopt(curl, CURLOPT_URL, url);
 199        curl_easy_setopt(curl, CURLOPT_INFILE, buffer);
 200        curl_easy_setopt(curl, CURLOPT_INFILESIZE, buffer->buf.len);
 201        curl_easy_setopt(curl, CURLOPT_READFUNCTION, fread_buffer);
 202#ifndef NO_CURL_IOCTL
 203        curl_easy_setopt(curl, CURLOPT_IOCTLFUNCTION, ioctl_buffer);
 204        curl_easy_setopt(curl, CURLOPT_IOCTLDATA, buffer);
 205#endif
 206        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_fn);
 207        curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
 208        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, custom_req);
 209        curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
 210}
 211
 212static struct curl_slist *get_dav_token_headers(struct remote_lock *lock, enum dav_header_flag options)
 213{
 214        struct strbuf buf = STRBUF_INIT;
 215        struct curl_slist *dav_headers = http_copy_default_headers();
 216
 217        if (options & DAV_HEADER_IF) {
 218                strbuf_addf(&buf, "If: (<%s>)", lock->token);
 219                dav_headers = curl_slist_append(dav_headers, buf.buf);
 220                strbuf_reset(&buf);
 221        }
 222        if (options & DAV_HEADER_LOCK) {
 223                strbuf_addf(&buf, "Lock-Token: <%s>", lock->token);
 224                dav_headers = curl_slist_append(dav_headers, buf.buf);
 225                strbuf_reset(&buf);
 226        }
 227        if (options & DAV_HEADER_TIMEOUT) {
 228                strbuf_addf(&buf, "Timeout: Second-%ld", lock->timeout);
 229                dav_headers = curl_slist_append(dav_headers, buf.buf);
 230                strbuf_reset(&buf);
 231        }
 232        strbuf_release(&buf);
 233
 234        return dav_headers;
 235}
 236
 237static void finish_request(struct transfer_request *request);
 238static void release_request(struct transfer_request *request);
 239
 240static void process_response(void *callback_data)
 241{
 242        struct transfer_request *request =
 243                (struct transfer_request *)callback_data;
 244
 245        finish_request(request);
 246}
 247
 248#ifdef USE_CURL_MULTI
 249
 250static void start_fetch_loose(struct transfer_request *request)
 251{
 252        struct active_request_slot *slot;
 253        struct http_object_request *obj_req;
 254
 255        obj_req = new_http_object_request(repo->url, request->obj->oid.hash);
 256        if (obj_req == NULL) {
 257                request->state = ABORTED;
 258                return;
 259        }
 260
 261        slot = obj_req->slot;
 262        slot->callback_func = process_response;
 263        slot->callback_data = request;
 264        request->slot = slot;
 265        request->userData = obj_req;
 266
 267        /* Try to get the request started, abort the request on error */
 268        request->state = RUN_FETCH_LOOSE;
 269        if (!start_active_slot(slot)) {
 270                fprintf(stderr, "Unable to start GET request\n");
 271                repo->can_update_info_refs = 0;
 272                release_http_object_request(obj_req);
 273                release_request(request);
 274        }
 275}
 276
 277static void start_mkcol(struct transfer_request *request)
 278{
 279        char *hex = oid_to_hex(&request->obj->oid);
 280        struct active_request_slot *slot;
 281
 282        request->url = get_remote_object_url(repo->url, hex, 1);
 283
 284        slot = get_active_slot();
 285        slot->callback_func = process_response;
 286        slot->callback_data = request;
 287        curl_setup_http_get(slot->curl, request->url, DAV_MKCOL);
 288        curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
 289
 290        if (start_active_slot(slot)) {
 291                request->slot = slot;
 292                request->state = RUN_MKCOL;
 293        } else {
 294                request->state = ABORTED;
 295                FREE_AND_NULL(request->url);
 296        }
 297}
 298#endif
 299
 300static void start_fetch_packed(struct transfer_request *request)
 301{
 302        struct packed_git *target;
 303
 304        struct transfer_request *check_request = request_queue_head;
 305        struct http_pack_request *preq;
 306
 307        target = find_sha1_pack(request->obj->oid.hash, repo->packs);
 308        if (!target) {
 309                fprintf(stderr, "Unable to fetch %s, will not be able to update server info refs\n", oid_to_hex(&request->obj->oid));
 310                repo->can_update_info_refs = 0;
 311                release_request(request);
 312                return;
 313        }
 314
 315        fprintf(stderr, "Fetching pack %s\n", sha1_to_hex(target->sha1));
 316        fprintf(stderr, " which contains %s\n", oid_to_hex(&request->obj->oid));
 317
 318        preq = new_http_pack_request(target, repo->url);
 319        if (preq == NULL) {
 320                repo->can_update_info_refs = 0;
 321                return;
 322        }
 323        preq->lst = &repo->packs;
 324
 325        /* Make sure there isn't another open request for this pack */
 326        while (check_request) {
 327                if (check_request->state == RUN_FETCH_PACKED &&
 328                    !strcmp(check_request->url, preq->url)) {
 329                        release_http_pack_request(preq);
 330                        release_request(request);
 331                        return;
 332                }
 333                check_request = check_request->next;
 334        }
 335
 336        preq->slot->callback_func = process_response;
 337        preq->slot->callback_data = request;
 338        request->slot = preq->slot;
 339        request->userData = preq;
 340
 341        /* Try to get the request started, abort the request on error */
 342        request->state = RUN_FETCH_PACKED;
 343        if (!start_active_slot(preq->slot)) {
 344                fprintf(stderr, "Unable to start GET request\n");
 345                release_http_pack_request(preq);
 346                repo->can_update_info_refs = 0;
 347                release_request(request);
 348        }
 349}
 350
 351static void start_put(struct transfer_request *request)
 352{
 353        char *hex = oid_to_hex(&request->obj->oid);
 354        struct active_request_slot *slot;
 355        struct strbuf buf = STRBUF_INIT;
 356        enum object_type type;
 357        char hdr[50];
 358        void *unpacked;
 359        unsigned long len;
 360        int hdrlen;
 361        ssize_t size;
 362        git_zstream stream;
 363
 364        unpacked = read_sha1_file(request->obj->oid.hash, &type, &len);
 365        hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(type), len) + 1;
 366
 367        /* Set it up */
 368        git_deflate_init(&stream, zlib_compression_level);
 369        size = git_deflate_bound(&stream, len + hdrlen);
 370        strbuf_init(&request->buffer.buf, size);
 371        request->buffer.posn = 0;
 372
 373        /* Compress it */
 374        stream.next_out = (unsigned char *)request->buffer.buf.buf;
 375        stream.avail_out = size;
 376
 377        /* First header.. */
 378        stream.next_in = (void *)hdr;
 379        stream.avail_in = hdrlen;
 380        while (git_deflate(&stream, 0) == Z_OK)
 381                ; /* nothing */
 382
 383        /* Then the data itself.. */
 384        stream.next_in = unpacked;
 385        stream.avail_in = len;
 386        while (git_deflate(&stream, Z_FINISH) == Z_OK)
 387                ; /* nothing */
 388        git_deflate_end(&stream);
 389        free(unpacked);
 390
 391        request->buffer.buf.len = stream.total_out;
 392
 393        strbuf_addstr(&buf, "Destination: ");
 394        append_remote_object_url(&buf, repo->url, hex, 0);
 395        request->dest = strbuf_detach(&buf, NULL);
 396
 397        append_remote_object_url(&buf, repo->url, hex, 0);
 398        strbuf_add(&buf, request->lock->tmpfile_suffix, 41);
 399        request->url = strbuf_detach(&buf, NULL);
 400
 401        slot = get_active_slot();
 402        slot->callback_func = process_response;
 403        slot->callback_data = request;
 404        curl_setup_http(slot->curl, request->url, DAV_PUT,
 405                        &request->buffer, fwrite_null);
 406
 407        if (start_active_slot(slot)) {
 408                request->slot = slot;
 409                request->state = RUN_PUT;
 410        } else {
 411                request->state = ABORTED;
 412                FREE_AND_NULL(request->url);
 413        }
 414}
 415
 416static void start_move(struct transfer_request *request)
 417{
 418        struct active_request_slot *slot;
 419        struct curl_slist *dav_headers = http_copy_default_headers();
 420
 421        slot = get_active_slot();
 422        slot->callback_func = process_response;
 423        slot->callback_data = request;
 424        curl_setup_http_get(slot->curl, request->url, DAV_MOVE);
 425        dav_headers = curl_slist_append(dav_headers, request->dest);
 426        dav_headers = curl_slist_append(dav_headers, "Overwrite: T");
 427        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
 428
 429        if (start_active_slot(slot)) {
 430                request->slot = slot;
 431                request->state = RUN_MOVE;
 432        } else {
 433                request->state = ABORTED;
 434                FREE_AND_NULL(request->url);
 435        }
 436}
 437
 438static int refresh_lock(struct remote_lock *lock)
 439{
 440        struct active_request_slot *slot;
 441        struct slot_results results;
 442        struct curl_slist *dav_headers;
 443        int rc = 0;
 444
 445        lock->refreshing = 1;
 446
 447        dav_headers = get_dav_token_headers(lock, DAV_HEADER_IF | DAV_HEADER_TIMEOUT);
 448
 449        slot = get_active_slot();
 450        slot->results = &results;
 451        curl_setup_http_get(slot->curl, lock->url, DAV_LOCK);
 452        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
 453
 454        if (start_active_slot(slot)) {
 455                run_active_slot(slot);
 456                if (results.curl_result != CURLE_OK) {
 457                        fprintf(stderr, "LOCK HTTP error %ld\n",
 458                                results.http_code);
 459                } else {
 460                        lock->start_time = time(NULL);
 461                        rc = 1;
 462                }
 463        }
 464
 465        lock->refreshing = 0;
 466        curl_slist_free_all(dav_headers);
 467
 468        return rc;
 469}
 470
 471static void check_locks(void)
 472{
 473        struct remote_lock *lock = repo->locks;
 474        time_t current_time = time(NULL);
 475        int time_remaining;
 476
 477        while (lock) {
 478                time_remaining = lock->start_time + lock->timeout -
 479                        current_time;
 480                if (!lock->refreshing && time_remaining < LOCK_REFRESH) {
 481                        if (!refresh_lock(lock)) {
 482                                fprintf(stderr,
 483                                        "Unable to refresh lock for %s\n",
 484                                        lock->url);
 485                                aborted = 1;
 486                                return;
 487                        }
 488                }
 489                lock = lock->next;
 490        }
 491}
 492
 493static void release_request(struct transfer_request *request)
 494{
 495        struct transfer_request *entry = request_queue_head;
 496
 497        if (request == request_queue_head) {
 498                request_queue_head = request->next;
 499        } else {
 500                while (entry->next != NULL && entry->next != request)
 501                        entry = entry->next;
 502                if (entry->next == request)
 503                        entry->next = entry->next->next;
 504        }
 505
 506        free(request->url);
 507        free(request);
 508}
 509
 510static void finish_request(struct transfer_request *request)
 511{
 512        struct http_pack_request *preq;
 513        struct http_object_request *obj_req;
 514
 515        request->curl_result = request->slot->curl_result;
 516        request->http_code = request->slot->http_code;
 517        request->slot = NULL;
 518
 519        /* Keep locks active */
 520        check_locks();
 521
 522        if (request->headers != NULL)
 523                curl_slist_free_all(request->headers);
 524
 525        /* URL is reused for MOVE after PUT */
 526        if (request->state != RUN_PUT) {
 527                FREE_AND_NULL(request->url);
 528        }
 529
 530        if (request->state == RUN_MKCOL) {
 531                if (request->curl_result == CURLE_OK ||
 532                    request->http_code == 405) {
 533                        remote_dir_exists[request->obj->oid.hash[0]] = 1;
 534                        start_put(request);
 535                } else {
 536                        fprintf(stderr, "MKCOL %s failed, aborting (%d/%ld)\n",
 537                                oid_to_hex(&request->obj->oid),
 538                                request->curl_result, request->http_code);
 539                        request->state = ABORTED;
 540                        aborted = 1;
 541                }
 542        } else if (request->state == RUN_PUT) {
 543                if (request->curl_result == CURLE_OK) {
 544                        start_move(request);
 545                } else {
 546                        fprintf(stderr, "PUT %s failed, aborting (%d/%ld)\n",
 547                                oid_to_hex(&request->obj->oid),
 548                                request->curl_result, request->http_code);
 549                        request->state = ABORTED;
 550                        aborted = 1;
 551                }
 552        } else if (request->state == RUN_MOVE) {
 553                if (request->curl_result == CURLE_OK) {
 554                        if (push_verbosely)
 555                                fprintf(stderr, "    sent %s\n",
 556                                        oid_to_hex(&request->obj->oid));
 557                        request->obj->flags |= REMOTE;
 558                        release_request(request);
 559                } else {
 560                        fprintf(stderr, "MOVE %s failed, aborting (%d/%ld)\n",
 561                                oid_to_hex(&request->obj->oid),
 562                                request->curl_result, request->http_code);
 563                        request->state = ABORTED;
 564                        aborted = 1;
 565                }
 566        } else if (request->state == RUN_FETCH_LOOSE) {
 567                obj_req = (struct http_object_request *)request->userData;
 568
 569                if (finish_http_object_request(obj_req) == 0)
 570                        if (obj_req->rename == 0)
 571                                request->obj->flags |= (LOCAL | REMOTE);
 572
 573                /* Try fetching packed if necessary */
 574                if (request->obj->flags & LOCAL) {
 575                        release_http_object_request(obj_req);
 576                        release_request(request);
 577                } else
 578                        start_fetch_packed(request);
 579
 580        } else if (request->state == RUN_FETCH_PACKED) {
 581                int fail = 1;
 582                if (request->curl_result != CURLE_OK) {
 583                        fprintf(stderr, "Unable to get pack file %s\n%s",
 584                                request->url, curl_errorstr);
 585                } else {
 586                        preq = (struct http_pack_request *)request->userData;
 587
 588                        if (preq) {
 589                                if (finish_http_pack_request(preq) == 0)
 590                                        fail = 0;
 591                                release_http_pack_request(preq);
 592                        }
 593                }
 594                if (fail)
 595                        repo->can_update_info_refs = 0;
 596                release_request(request);
 597        }
 598}
 599
 600#ifdef USE_CURL_MULTI
 601static int is_running_queue;
 602static int fill_active_slot(void *unused)
 603{
 604        struct transfer_request *request;
 605
 606        if (aborted || !is_running_queue)
 607                return 0;
 608
 609        for (request = request_queue_head; request; request = request->next) {
 610                if (request->state == NEED_FETCH) {
 611                        start_fetch_loose(request);
 612                        return 1;
 613                } else if (pushing && request->state == NEED_PUSH) {
 614                        if (remote_dir_exists[request->obj->oid.hash[0]] == 1) {
 615                                start_put(request);
 616                        } else {
 617                                start_mkcol(request);
 618                        }
 619                        return 1;
 620                }
 621        }
 622        return 0;
 623}
 624#endif
 625
 626static void get_remote_object_list(unsigned char parent);
 627
 628static void add_fetch_request(struct object *obj)
 629{
 630        struct transfer_request *request;
 631
 632        check_locks();
 633
 634        /*
 635         * Don't fetch the object if it's known to exist locally
 636         * or is already in the request queue
 637         */
 638        if (remote_dir_exists[obj->oid.hash[0]] == -1)
 639                get_remote_object_list(obj->oid.hash[0]);
 640        if (obj->flags & (LOCAL | FETCHING))
 641                return;
 642
 643        obj->flags |= FETCHING;
 644        request = xmalloc(sizeof(*request));
 645        request->obj = obj;
 646        request->url = NULL;
 647        request->lock = NULL;
 648        request->headers = NULL;
 649        request->state = NEED_FETCH;
 650        request->next = request_queue_head;
 651        request_queue_head = request;
 652
 653#ifdef USE_CURL_MULTI
 654        fill_active_slots();
 655        step_active_slots();
 656#endif
 657}
 658
 659static int add_send_request(struct object *obj, struct remote_lock *lock)
 660{
 661        struct transfer_request *request;
 662        struct packed_git *target;
 663
 664        /* Keep locks active */
 665        check_locks();
 666
 667        /*
 668         * Don't push the object if it's known to exist on the remote
 669         * or is already in the request queue
 670         */
 671        if (remote_dir_exists[obj->oid.hash[0]] == -1)
 672                get_remote_object_list(obj->oid.hash[0]);
 673        if (obj->flags & (REMOTE | PUSHING))
 674                return 0;
 675        target = find_sha1_pack(obj->oid.hash, repo->packs);
 676        if (target) {
 677                obj->flags |= REMOTE;
 678                return 0;
 679        }
 680
 681        obj->flags |= PUSHING;
 682        request = xmalloc(sizeof(*request));
 683        request->obj = obj;
 684        request->url = NULL;
 685        request->lock = lock;
 686        request->headers = NULL;
 687        request->state = NEED_PUSH;
 688        request->next = request_queue_head;
 689        request_queue_head = request;
 690
 691#ifdef USE_CURL_MULTI
 692        fill_active_slots();
 693        step_active_slots();
 694#endif
 695
 696        return 1;
 697}
 698
 699static int fetch_indices(void)
 700{
 701        int ret;
 702
 703        if (push_verbosely)
 704                fprintf(stderr, "Getting pack list\n");
 705
 706        switch (http_get_info_packs(repo->url, &repo->packs)) {
 707        case HTTP_OK:
 708        case HTTP_MISSING_TARGET:
 709                ret = 0;
 710                break;
 711        default:
 712                ret = -1;
 713        }
 714
 715        return ret;
 716}
 717
 718static void one_remote_object(const struct object_id *oid)
 719{
 720        struct object *obj;
 721
 722        obj = lookup_object(oid->hash);
 723        if (!obj)
 724                obj = parse_object(oid);
 725
 726        /* Ignore remote objects that don't exist locally */
 727        if (!obj)
 728                return;
 729
 730        obj->flags |= REMOTE;
 731        if (!object_list_contains(objects, obj))
 732                object_list_insert(obj, &objects);
 733}
 734
 735static void handle_lockprop_ctx(struct xml_ctx *ctx, int tag_closed)
 736{
 737        int *lock_flags = (int *)ctx->userData;
 738
 739        if (tag_closed) {
 740                if (!strcmp(ctx->name, DAV_CTX_LOCKENTRY)) {
 741                        if ((*lock_flags & DAV_PROP_LOCKEX) &&
 742                            (*lock_flags & DAV_PROP_LOCKWR)) {
 743                                *lock_flags |= DAV_LOCK_OK;
 744                        }
 745                        *lock_flags &= DAV_LOCK_OK;
 746                } else if (!strcmp(ctx->name, DAV_CTX_LOCKTYPE_WRITE)) {
 747                        *lock_flags |= DAV_PROP_LOCKWR;
 748                } else if (!strcmp(ctx->name, DAV_CTX_LOCKTYPE_EXCLUSIVE)) {
 749                        *lock_flags |= DAV_PROP_LOCKEX;
 750                }
 751        }
 752}
 753
 754static void handle_new_lock_ctx(struct xml_ctx *ctx, int tag_closed)
 755{
 756        struct remote_lock *lock = (struct remote_lock *)ctx->userData;
 757        git_SHA_CTX sha_ctx;
 758        unsigned char lock_token_sha1[20];
 759
 760        if (tag_closed && ctx->cdata) {
 761                if (!strcmp(ctx->name, DAV_ACTIVELOCK_OWNER)) {
 762                        lock->owner = xstrdup(ctx->cdata);
 763                } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TIMEOUT)) {
 764                        const char *arg;
 765                        if (skip_prefix(ctx->cdata, "Second-", &arg))
 766                                lock->timeout = strtol(arg, NULL, 10);
 767                } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TOKEN)) {
 768                        lock->token = xstrdup(ctx->cdata);
 769
 770                        git_SHA1_Init(&sha_ctx);
 771                        git_SHA1_Update(&sha_ctx, lock->token, strlen(lock->token));
 772                        git_SHA1_Final(lock_token_sha1, &sha_ctx);
 773
 774                        lock->tmpfile_suffix[0] = '_';
 775                        memcpy(lock->tmpfile_suffix + 1, sha1_to_hex(lock_token_sha1), 40);
 776                }
 777        }
 778}
 779
 780static void one_remote_ref(const char *refname);
 781
 782static void
 783xml_start_tag(void *userData, const char *name, const char **atts)
 784{
 785        struct xml_ctx *ctx = (struct xml_ctx *)userData;
 786        const char *c = strchr(name, ':');
 787        int old_namelen, new_len;
 788
 789        if (c == NULL)
 790                c = name;
 791        else
 792                c++;
 793
 794        old_namelen = strlen(ctx->name);
 795        new_len = old_namelen + strlen(c) + 2;
 796
 797        if (new_len > ctx->len) {
 798                ctx->name = xrealloc(ctx->name, new_len);
 799                ctx->len = new_len;
 800        }
 801        xsnprintf(ctx->name + old_namelen, ctx->len - old_namelen, ".%s", c);
 802
 803        FREE_AND_NULL(ctx->cdata);
 804
 805        ctx->userFunc(ctx, 0);
 806}
 807
 808static void
 809xml_end_tag(void *userData, const char *name)
 810{
 811        struct xml_ctx *ctx = (struct xml_ctx *)userData;
 812        const char *c = strchr(name, ':');
 813        char *ep;
 814
 815        ctx->userFunc(ctx, 1);
 816
 817        if (c == NULL)
 818                c = name;
 819        else
 820                c++;
 821
 822        ep = ctx->name + strlen(ctx->name) - strlen(c) - 1;
 823        *ep = 0;
 824}
 825
 826static void
 827xml_cdata(void *userData, const XML_Char *s, int len)
 828{
 829        struct xml_ctx *ctx = (struct xml_ctx *)userData;
 830        free(ctx->cdata);
 831        ctx->cdata = xmemdupz(s, len);
 832}
 833
 834static struct remote_lock *lock_remote(const char *path, long timeout)
 835{
 836        struct active_request_slot *slot;
 837        struct slot_results results;
 838        struct buffer out_buffer = { STRBUF_INIT, 0 };
 839        struct strbuf in_buffer = STRBUF_INIT;
 840        char *url;
 841        char *ep;
 842        char timeout_header[25];
 843        struct remote_lock *lock = NULL;
 844        struct curl_slist *dav_headers = http_copy_default_headers();
 845        struct xml_ctx ctx;
 846        char *escaped;
 847
 848        url = xstrfmt("%s%s", repo->url, path);
 849
 850        /* Make sure leading directories exist for the remote ref */
 851        ep = strchr(url + strlen(repo->url) + 1, '/');
 852        while (ep) {
 853                char saved_character = ep[1];
 854                ep[1] = '\0';
 855                slot = get_active_slot();
 856                slot->results = &results;
 857                curl_setup_http_get(slot->curl, url, DAV_MKCOL);
 858                if (start_active_slot(slot)) {
 859                        run_active_slot(slot);
 860                        if (results.curl_result != CURLE_OK &&
 861                            results.http_code != 405) {
 862                                fprintf(stderr,
 863                                        "Unable to create branch path %s\n",
 864                                        url);
 865                                free(url);
 866                                return NULL;
 867                        }
 868                } else {
 869                        fprintf(stderr, "Unable to start MKCOL request\n");
 870                        free(url);
 871                        return NULL;
 872                }
 873                ep[1] = saved_character;
 874                ep = strchr(ep + 1, '/');
 875        }
 876
 877        escaped = xml_entities(ident_default_email());
 878        strbuf_addf(&out_buffer.buf, LOCK_REQUEST, escaped);
 879        free(escaped);
 880
 881        xsnprintf(timeout_header, sizeof(timeout_header), "Timeout: Second-%ld", timeout);
 882        dav_headers = curl_slist_append(dav_headers, timeout_header);
 883        dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
 884
 885        slot = get_active_slot();
 886        slot->results = &results;
 887        curl_setup_http(slot->curl, url, DAV_LOCK, &out_buffer, fwrite_buffer);
 888        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
 889        curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
 890
 891        lock = xcalloc(1, sizeof(*lock));
 892        lock->timeout = -1;
 893
 894        if (start_active_slot(slot)) {
 895                run_active_slot(slot);
 896                if (results.curl_result == CURLE_OK) {
 897                        XML_Parser parser = XML_ParserCreate(NULL);
 898                        enum XML_Status result;
 899                        ctx.name = xcalloc(10, 1);
 900                        ctx.len = 0;
 901                        ctx.cdata = NULL;
 902                        ctx.userFunc = handle_new_lock_ctx;
 903                        ctx.userData = lock;
 904                        XML_SetUserData(parser, &ctx);
 905                        XML_SetElementHandler(parser, xml_start_tag,
 906                                              xml_end_tag);
 907                        XML_SetCharacterDataHandler(parser, xml_cdata);
 908                        result = XML_Parse(parser, in_buffer.buf,
 909                                           in_buffer.len, 1);
 910                        free(ctx.name);
 911                        if (result != XML_STATUS_OK) {
 912                                fprintf(stderr, "XML error: %s\n",
 913                                        XML_ErrorString(
 914                                                XML_GetErrorCode(parser)));
 915                                lock->timeout = -1;
 916                        }
 917                        XML_ParserFree(parser);
 918                } else {
 919                        fprintf(stderr,
 920                                "error: curl result=%d, HTTP code=%ld\n",
 921                                results.curl_result, results.http_code);
 922                }
 923        } else {
 924                fprintf(stderr, "Unable to start LOCK request\n");
 925        }
 926
 927        curl_slist_free_all(dav_headers);
 928        strbuf_release(&out_buffer.buf);
 929        strbuf_release(&in_buffer);
 930
 931        if (lock->token == NULL || lock->timeout <= 0) {
 932                free(lock->token);
 933                free(lock->owner);
 934                free(url);
 935                FREE_AND_NULL(lock);
 936        } else {
 937                lock->url = url;
 938                lock->start_time = time(NULL);
 939                lock->next = repo->locks;
 940                repo->locks = lock;
 941        }
 942
 943        return lock;
 944}
 945
 946static int unlock_remote(struct remote_lock *lock)
 947{
 948        struct active_request_slot *slot;
 949        struct slot_results results;
 950        struct remote_lock *prev = repo->locks;
 951        struct curl_slist *dav_headers;
 952        int rc = 0;
 953
 954        dav_headers = get_dav_token_headers(lock, DAV_HEADER_LOCK);
 955
 956        slot = get_active_slot();
 957        slot->results = &results;
 958        curl_setup_http_get(slot->curl, lock->url, DAV_UNLOCK);
 959        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
 960
 961        if (start_active_slot(slot)) {
 962                run_active_slot(slot);
 963                if (results.curl_result == CURLE_OK)
 964                        rc = 1;
 965                else
 966                        fprintf(stderr, "UNLOCK HTTP error %ld\n",
 967                                results.http_code);
 968        } else {
 969                fprintf(stderr, "Unable to start UNLOCK request\n");
 970        }
 971
 972        curl_slist_free_all(dav_headers);
 973
 974        if (repo->locks == lock) {
 975                repo->locks = lock->next;
 976        } else {
 977                while (prev && prev->next != lock)
 978                        prev = prev->next;
 979                if (prev)
 980                        prev->next = prev->next->next;
 981        }
 982
 983        free(lock->owner);
 984        free(lock->url);
 985        free(lock->token);
 986        free(lock);
 987
 988        return rc;
 989}
 990
 991static void remove_locks(void)
 992{
 993        struct remote_lock *lock = repo->locks;
 994
 995        fprintf(stderr, "Removing remote locks...\n");
 996        while (lock) {
 997                struct remote_lock *next = lock->next;
 998                unlock_remote(lock);
 999                lock = next;
1000        }
1001}
1002
1003static void remove_locks_on_signal(int signo)
1004{
1005        remove_locks();
1006        sigchain_pop(signo);
1007        raise(signo);
1008}
1009
1010static void remote_ls(const char *path, int flags,
1011                      void (*userFunc)(struct remote_ls_ctx *ls),
1012                      void *userData);
1013
1014/* extract hex from sharded "xx/x{38}" filename */
1015static int get_oid_hex_from_objpath(const char *path, struct object_id *oid)
1016{
1017        if (strlen(path) != GIT_SHA1_HEXSZ + 1)
1018                return -1;
1019
1020        if (hex_to_bytes(oid->hash, path, 1))
1021                return -1;
1022        path += 2;
1023        path++; /* skip '/' */
1024
1025        return hex_to_bytes(oid->hash + 1, path, GIT_SHA1_RAWSZ - 1);
1026}
1027
1028static void process_ls_object(struct remote_ls_ctx *ls)
1029{
1030        unsigned int *parent = (unsigned int *)ls->userData;
1031        const char *path = ls->dentry_name;
1032        struct object_id oid;
1033
1034        if (!strcmp(ls->path, ls->dentry_name) && (ls->flags & IS_DIR)) {
1035                remote_dir_exists[*parent] = 1;
1036                return;
1037        }
1038
1039        if (!skip_prefix(path, "objects/", &path) ||
1040            get_oid_hex_from_objpath(path, &oid))
1041                return;
1042
1043        one_remote_object(&oid);
1044}
1045
1046static void process_ls_ref(struct remote_ls_ctx *ls)
1047{
1048        if (!strcmp(ls->path, ls->dentry_name) && (ls->dentry_flags & IS_DIR)) {
1049                fprintf(stderr, "  %s\n", ls->dentry_name);
1050                return;
1051        }
1052
1053        if (!(ls->dentry_flags & IS_DIR))
1054                one_remote_ref(ls->dentry_name);
1055}
1056
1057static void handle_remote_ls_ctx(struct xml_ctx *ctx, int tag_closed)
1058{
1059        struct remote_ls_ctx *ls = (struct remote_ls_ctx *)ctx->userData;
1060
1061        if (tag_closed) {
1062                if (!strcmp(ctx->name, DAV_PROPFIND_RESP) && ls->dentry_name) {
1063                        if (ls->dentry_flags & IS_DIR) {
1064
1065                                /* ensure collection names end with slash */
1066                                str_end_url_with_slash(ls->dentry_name, &ls->dentry_name);
1067
1068                                if (ls->flags & PROCESS_DIRS) {
1069                                        ls->userFunc(ls);
1070                                }
1071                                if (strcmp(ls->dentry_name, ls->path) &&
1072                                    ls->flags & RECURSIVE) {
1073                                        remote_ls(ls->dentry_name,
1074                                                  ls->flags,
1075                                                  ls->userFunc,
1076                                                  ls->userData);
1077                                }
1078                        } else if (ls->flags & PROCESS_FILES) {
1079                                ls->userFunc(ls);
1080                        }
1081                } else if (!strcmp(ctx->name, DAV_PROPFIND_NAME) && ctx->cdata) {
1082                        char *path = ctx->cdata;
1083                        if (*ctx->cdata == 'h') {
1084                                path = strstr(path, "//");
1085                                if (path) {
1086                                        path = strchr(path+2, '/');
1087                                }
1088                        }
1089                        if (path) {
1090                                const char *url = repo->url;
1091                                if (repo->path)
1092                                        url = repo->path;
1093                                if (strncmp(path, url, repo->path_len))
1094                                        error("Parsed path '%s' does not match url: '%s'",
1095                                              path, url);
1096                                else {
1097                                        path += repo->path_len;
1098                                        ls->dentry_name = xstrdup(path);
1099                                }
1100                        }
1101                } else if (!strcmp(ctx->name, DAV_PROPFIND_COLLECTION)) {
1102                        ls->dentry_flags |= IS_DIR;
1103                }
1104        } else if (!strcmp(ctx->name, DAV_PROPFIND_RESP)) {
1105                FREE_AND_NULL(ls->dentry_name);
1106                ls->dentry_flags = 0;
1107        }
1108}
1109
1110/*
1111 * NEEDSWORK: remote_ls() ignores info/refs on the remote side.  But it
1112 * should _only_ heed the information from that file, instead of trying to
1113 * determine the refs from the remote file system (badly: it does not even
1114 * know about packed-refs).
1115 */
1116static void remote_ls(const char *path, int flags,
1117                      void (*userFunc)(struct remote_ls_ctx *ls),
1118                      void *userData)
1119{
1120        char *url = xstrfmt("%s%s", repo->url, path);
1121        struct active_request_slot *slot;
1122        struct slot_results results;
1123        struct strbuf in_buffer = STRBUF_INIT;
1124        struct buffer out_buffer = { STRBUF_INIT, 0 };
1125        struct curl_slist *dav_headers = http_copy_default_headers();
1126        struct xml_ctx ctx;
1127        struct remote_ls_ctx ls;
1128
1129        ls.flags = flags;
1130        ls.path = xstrdup(path);
1131        ls.dentry_name = NULL;
1132        ls.dentry_flags = 0;
1133        ls.userData = userData;
1134        ls.userFunc = userFunc;
1135
1136        strbuf_addstr(&out_buffer.buf, PROPFIND_ALL_REQUEST);
1137
1138        dav_headers = curl_slist_append(dav_headers, "Depth: 1");
1139        dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1140
1141        slot = get_active_slot();
1142        slot->results = &results;
1143        curl_setup_http(slot->curl, url, DAV_PROPFIND,
1144                        &out_buffer, fwrite_buffer);
1145        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1146        curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1147
1148        if (start_active_slot(slot)) {
1149                run_active_slot(slot);
1150                if (results.curl_result == CURLE_OK) {
1151                        XML_Parser parser = XML_ParserCreate(NULL);
1152                        enum XML_Status result;
1153                        ctx.name = xcalloc(10, 1);
1154                        ctx.len = 0;
1155                        ctx.cdata = NULL;
1156                        ctx.userFunc = handle_remote_ls_ctx;
1157                        ctx.userData = &ls;
1158                        XML_SetUserData(parser, &ctx);
1159                        XML_SetElementHandler(parser, xml_start_tag,
1160                                              xml_end_tag);
1161                        XML_SetCharacterDataHandler(parser, xml_cdata);
1162                        result = XML_Parse(parser, in_buffer.buf,
1163                                           in_buffer.len, 1);
1164                        free(ctx.name);
1165
1166                        if (result != XML_STATUS_OK) {
1167                                fprintf(stderr, "XML error: %s\n",
1168                                        XML_ErrorString(
1169                                                XML_GetErrorCode(parser)));
1170                        }
1171                        XML_ParserFree(parser);
1172                }
1173        } else {
1174                fprintf(stderr, "Unable to start PROPFIND request\n");
1175        }
1176
1177        free(ls.path);
1178        free(url);
1179        strbuf_release(&out_buffer.buf);
1180        strbuf_release(&in_buffer);
1181        curl_slist_free_all(dav_headers);
1182}
1183
1184static void get_remote_object_list(unsigned char parent)
1185{
1186        char path[] = "objects/XX/";
1187        static const char hex[] = "0123456789abcdef";
1188        unsigned int val = parent;
1189
1190        path[8] = hex[val >> 4];
1191        path[9] = hex[val & 0xf];
1192        remote_dir_exists[val] = 0;
1193        remote_ls(path, (PROCESS_FILES | PROCESS_DIRS),
1194                  process_ls_object, &val);
1195}
1196
1197static int locking_available(void)
1198{
1199        struct active_request_slot *slot;
1200        struct slot_results results;
1201        struct strbuf in_buffer = STRBUF_INIT;
1202        struct buffer out_buffer = { STRBUF_INIT, 0 };
1203        struct curl_slist *dav_headers = http_copy_default_headers();
1204        struct xml_ctx ctx;
1205        int lock_flags = 0;
1206        char *escaped;
1207
1208        escaped = xml_entities(repo->url);
1209        strbuf_addf(&out_buffer.buf, PROPFIND_SUPPORTEDLOCK_REQUEST, escaped);
1210        free(escaped);
1211
1212        dav_headers = curl_slist_append(dav_headers, "Depth: 0");
1213        dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1214
1215        slot = get_active_slot();
1216        slot->results = &results;
1217        curl_setup_http(slot->curl, repo->url, DAV_PROPFIND,
1218                        &out_buffer, fwrite_buffer);
1219        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1220        curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1221
1222        if (start_active_slot(slot)) {
1223                run_active_slot(slot);
1224                if (results.curl_result == CURLE_OK) {
1225                        XML_Parser parser = XML_ParserCreate(NULL);
1226                        enum XML_Status result;
1227                        ctx.name = xcalloc(10, 1);
1228                        ctx.len = 0;
1229                        ctx.cdata = NULL;
1230                        ctx.userFunc = handle_lockprop_ctx;
1231                        ctx.userData = &lock_flags;
1232                        XML_SetUserData(parser, &ctx);
1233                        XML_SetElementHandler(parser, xml_start_tag,
1234                                              xml_end_tag);
1235                        result = XML_Parse(parser, in_buffer.buf,
1236                                           in_buffer.len, 1);
1237                        free(ctx.name);
1238
1239                        if (result != XML_STATUS_OK) {
1240                                fprintf(stderr, "XML error: %s\n",
1241                                        XML_ErrorString(
1242                                                XML_GetErrorCode(parser)));
1243                                lock_flags = 0;
1244                        }
1245                        XML_ParserFree(parser);
1246                        if (!lock_flags)
1247                                error("no DAV locking support on %s",
1248                                      repo->url);
1249
1250                } else {
1251                        error("Cannot access URL %s, return code %d",
1252                              repo->url, results.curl_result);
1253                        lock_flags = 0;
1254                }
1255        } else {
1256                error("Unable to start PROPFIND request on %s", repo->url);
1257        }
1258
1259        strbuf_release(&out_buffer.buf);
1260        strbuf_release(&in_buffer);
1261        curl_slist_free_all(dav_headers);
1262
1263        return lock_flags;
1264}
1265
1266static struct object_list **add_one_object(struct object *obj, struct object_list **p)
1267{
1268        struct object_list *entry = xmalloc(sizeof(struct object_list));
1269        entry->item = obj;
1270        entry->next = *p;
1271        *p = entry;
1272        return &entry->next;
1273}
1274
1275static struct object_list **process_blob(struct blob *blob,
1276                                         struct object_list **p)
1277{
1278        struct object *obj = &blob->object;
1279
1280        obj->flags |= LOCAL;
1281
1282        if (obj->flags & (UNINTERESTING | SEEN))
1283                return p;
1284
1285        obj->flags |= SEEN;
1286        return add_one_object(obj, p);
1287}
1288
1289static struct object_list **process_tree(struct tree *tree,
1290                                         struct object_list **p)
1291{
1292        struct object *obj = &tree->object;
1293        struct tree_desc desc;
1294        struct name_entry entry;
1295
1296        obj->flags |= LOCAL;
1297
1298        if (obj->flags & (UNINTERESTING | SEEN))
1299                return p;
1300        if (parse_tree(tree) < 0)
1301                die("bad tree object %s", oid_to_hex(&obj->oid));
1302
1303        obj->flags |= SEEN;
1304        p = add_one_object(obj, p);
1305
1306        init_tree_desc(&desc, tree->buffer, tree->size);
1307
1308        while (tree_entry(&desc, &entry))
1309                switch (object_type(entry.mode)) {
1310                case OBJ_TREE:
1311                        p = process_tree(lookup_tree(entry.oid), p);
1312                        break;
1313                case OBJ_BLOB:
1314                        p = process_blob(lookup_blob(entry.oid), p);
1315                        break;
1316                default:
1317                        /* Subproject commit - not in this repository */
1318                        break;
1319                }
1320
1321        free_tree_buffer(tree);
1322        return p;
1323}
1324
1325static int get_delta(struct rev_info *revs, struct remote_lock *lock)
1326{
1327        int i;
1328        struct commit *commit;
1329        struct object_list **p = &objects;
1330        int count = 0;
1331
1332        while ((commit = get_revision(revs)) != NULL) {
1333                p = process_tree(commit->tree, p);
1334                commit->object.flags |= LOCAL;
1335                if (!(commit->object.flags & UNINTERESTING))
1336                        count += add_send_request(&commit->object, lock);
1337        }
1338
1339        for (i = 0; i < revs->pending.nr; i++) {
1340                struct object_array_entry *entry = revs->pending.objects + i;
1341                struct object *obj = entry->item;
1342                const char *name = entry->name;
1343
1344                if (obj->flags & (UNINTERESTING | SEEN))
1345                        continue;
1346                if (obj->type == OBJ_TAG) {
1347                        obj->flags |= SEEN;
1348                        p = add_one_object(obj, p);
1349                        continue;
1350                }
1351                if (obj->type == OBJ_TREE) {
1352                        p = process_tree((struct tree *)obj, p);
1353                        continue;
1354                }
1355                if (obj->type == OBJ_BLOB) {
1356                        p = process_blob((struct blob *)obj, p);
1357                        continue;
1358                }
1359                die("unknown pending object %s (%s)", oid_to_hex(&obj->oid), name);
1360        }
1361
1362        while (objects) {
1363                if (!(objects->item->flags & UNINTERESTING))
1364                        count += add_send_request(objects->item, lock);
1365                objects = objects->next;
1366        }
1367
1368        return count;
1369}
1370
1371static int update_remote(unsigned char *sha1, struct remote_lock *lock)
1372{
1373        struct active_request_slot *slot;
1374        struct slot_results results;
1375        struct buffer out_buffer = { STRBUF_INIT, 0 };
1376        struct curl_slist *dav_headers;
1377
1378        dav_headers = get_dav_token_headers(lock, DAV_HEADER_IF);
1379
1380        strbuf_addf(&out_buffer.buf, "%s\n", sha1_to_hex(sha1));
1381
1382        slot = get_active_slot();
1383        slot->results = &results;
1384        curl_setup_http(slot->curl, lock->url, DAV_PUT,
1385                        &out_buffer, fwrite_null);
1386        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1387
1388        if (start_active_slot(slot)) {
1389                run_active_slot(slot);
1390                strbuf_release(&out_buffer.buf);
1391                if (results.curl_result != CURLE_OK) {
1392                        fprintf(stderr,
1393                                "PUT error: curl result=%d, HTTP code=%ld\n",
1394                                results.curl_result, results.http_code);
1395                        /* We should attempt recovery? */
1396                        return 0;
1397                }
1398        } else {
1399                strbuf_release(&out_buffer.buf);
1400                fprintf(stderr, "Unable to start PUT request\n");
1401                return 0;
1402        }
1403
1404        return 1;
1405}
1406
1407static struct ref *remote_refs;
1408
1409static void one_remote_ref(const char *refname)
1410{
1411        struct ref *ref;
1412        struct object *obj;
1413
1414        ref = alloc_ref(refname);
1415
1416        if (http_fetch_ref(repo->url, ref) != 0) {
1417                fprintf(stderr,
1418                        "Unable to fetch ref %s from %s\n",
1419                        refname, repo->url);
1420                free(ref);
1421                return;
1422        }
1423
1424        /*
1425         * Fetch a copy of the object if it doesn't exist locally - it
1426         * may be required for updating server info later.
1427         */
1428        if (repo->can_update_info_refs && !has_object_file(&ref->old_oid)) {
1429                obj = lookup_unknown_object(ref->old_oid.hash);
1430                fprintf(stderr, "  fetch %s for %s\n",
1431                        oid_to_hex(&ref->old_oid), refname);
1432                add_fetch_request(obj);
1433        }
1434
1435        ref->next = remote_refs;
1436        remote_refs = ref;
1437}
1438
1439static void get_dav_remote_heads(void)
1440{
1441        remote_ls("refs/", (PROCESS_FILES | PROCESS_DIRS | RECURSIVE), process_ls_ref, NULL);
1442}
1443
1444static void add_remote_info_ref(struct remote_ls_ctx *ls)
1445{
1446        struct strbuf *buf = (struct strbuf *)ls->userData;
1447        struct object *o;
1448        struct ref *ref;
1449
1450        ref = alloc_ref(ls->dentry_name);
1451
1452        if (http_fetch_ref(repo->url, ref) != 0) {
1453                fprintf(stderr,
1454                        "Unable to fetch ref %s from %s\n",
1455                        ls->dentry_name, repo->url);
1456                aborted = 1;
1457                free(ref);
1458                return;
1459        }
1460
1461        o = parse_object(&ref->old_oid);
1462        if (!o) {
1463                fprintf(stderr,
1464                        "Unable to parse object %s for remote ref %s\n",
1465                        oid_to_hex(&ref->old_oid), ls->dentry_name);
1466                aborted = 1;
1467                free(ref);
1468                return;
1469        }
1470
1471        strbuf_addf(buf, "%s\t%s\n",
1472                    oid_to_hex(&ref->old_oid), ls->dentry_name);
1473
1474        if (o->type == OBJ_TAG) {
1475                o = deref_tag(o, ls->dentry_name, 0);
1476                if (o)
1477                        strbuf_addf(buf, "%s\t%s^{}\n",
1478                                    oid_to_hex(&o->oid), ls->dentry_name);
1479        }
1480        free(ref);
1481}
1482
1483static void update_remote_info_refs(struct remote_lock *lock)
1484{
1485        struct buffer buffer = { STRBUF_INIT, 0 };
1486        struct active_request_slot *slot;
1487        struct slot_results results;
1488        struct curl_slist *dav_headers;
1489
1490        remote_ls("refs/", (PROCESS_FILES | RECURSIVE),
1491                  add_remote_info_ref, &buffer.buf);
1492        if (!aborted) {
1493                dav_headers = get_dav_token_headers(lock, DAV_HEADER_IF);
1494
1495                slot = get_active_slot();
1496                slot->results = &results;
1497                curl_setup_http(slot->curl, lock->url, DAV_PUT,
1498                                &buffer, fwrite_null);
1499                curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1500
1501                if (start_active_slot(slot)) {
1502                        run_active_slot(slot);
1503                        if (results.curl_result != CURLE_OK) {
1504                                fprintf(stderr,
1505                                        "PUT error: curl result=%d, HTTP code=%ld\n",
1506                                        results.curl_result, results.http_code);
1507                        }
1508                }
1509        }
1510        strbuf_release(&buffer.buf);
1511}
1512
1513static int remote_exists(const char *path)
1514{
1515        char *url = xstrfmt("%s%s", repo->url, path);
1516        int ret;
1517
1518
1519        switch (http_get_strbuf(url, NULL, NULL)) {
1520        case HTTP_OK:
1521                ret = 1;
1522                break;
1523        case HTTP_MISSING_TARGET:
1524                ret = 0;
1525                break;
1526        case HTTP_ERROR:
1527                error("unable to access '%s': %s", url, curl_errorstr);
1528                /* fallthrough */
1529        default:
1530                ret = -1;
1531        }
1532        free(url);
1533        return ret;
1534}
1535
1536static void fetch_symref(const char *path, char **symref, struct object_id *oid)
1537{
1538        char *url = xstrfmt("%s%s", repo->url, path);
1539        struct strbuf buffer = STRBUF_INIT;
1540        const char *name;
1541
1542        if (http_get_strbuf(url, &buffer, NULL) != HTTP_OK)
1543                die("Couldn't get %s for remote symref\n%s", url,
1544                    curl_errorstr);
1545        free(url);
1546
1547        FREE_AND_NULL(*symref);
1548        oidclr(oid);
1549
1550        if (buffer.len == 0)
1551                return;
1552
1553        /* Cut off trailing newline. */
1554        strbuf_rtrim(&buffer);
1555
1556        /* If it's a symref, set the refname; otherwise try for a sha1 */
1557        if (skip_prefix(buffer.buf, "ref: ", &name)) {
1558                *symref = xmemdupz(name, buffer.len - (name - buffer.buf));
1559        } else {
1560                get_oid_hex(buffer.buf, oid);
1561        }
1562
1563        strbuf_release(&buffer);
1564}
1565
1566static int verify_merge_base(struct object_id *head_oid, struct ref *remote)
1567{
1568        struct commit *head = lookup_commit_or_die(head_oid, "HEAD");
1569        struct commit *branch = lookup_commit_or_die(&remote->old_oid,
1570                                                     remote->name);
1571
1572        return in_merge_bases(branch, head);
1573}
1574
1575static int delete_remote_branch(const char *pattern, int force)
1576{
1577        struct ref *refs = remote_refs;
1578        struct ref *remote_ref = NULL;
1579        struct object_id head_oid;
1580        char *symref = NULL;
1581        int match;
1582        int patlen = strlen(pattern);
1583        int i;
1584        struct active_request_slot *slot;
1585        struct slot_results results;
1586        char *url;
1587
1588        /* Find the remote branch(es) matching the specified branch name */
1589        for (match = 0; refs; refs = refs->next) {
1590                char *name = refs->name;
1591                int namelen = strlen(name);
1592                if (namelen < patlen ||
1593                    memcmp(name + namelen - patlen, pattern, patlen))
1594                        continue;
1595                if (namelen != patlen && name[namelen - patlen - 1] != '/')
1596                        continue;
1597                match++;
1598                remote_ref = refs;
1599        }
1600        if (match == 0)
1601                return error("No remote branch matches %s", pattern);
1602        if (match != 1)
1603                return error("More than one remote branch matches %s",
1604                             pattern);
1605
1606        /*
1607         * Remote HEAD must be a symref (not exactly foolproof; a remote
1608         * symlink to a symref will look like a symref)
1609         */
1610        fetch_symref("HEAD", &symref, &head_oid);
1611        if (!symref)
1612                return error("Remote HEAD is not a symref");
1613
1614        /* Remote branch must not be the remote HEAD */
1615        for (i = 0; symref && i < MAXDEPTH; i++) {
1616                if (!strcmp(remote_ref->name, symref))
1617                        return error("Remote branch %s is the current HEAD",
1618                                     remote_ref->name);
1619                fetch_symref(symref, &symref, &head_oid);
1620        }
1621
1622        /* Run extra sanity checks if delete is not forced */
1623        if (!force) {
1624                /* Remote HEAD must resolve to a known object */
1625                if (symref)
1626                        return error("Remote HEAD symrefs too deep");
1627                if (is_null_oid(&head_oid))
1628                        return error("Unable to resolve remote HEAD");
1629                if (!has_object_file(&head_oid))
1630                        return error("Remote HEAD resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", oid_to_hex(&head_oid));
1631
1632                /* Remote branch must resolve to a known object */
1633                if (is_null_oid(&remote_ref->old_oid))
1634                        return error("Unable to resolve remote branch %s",
1635                                     remote_ref->name);
1636                if (!has_object_file(&remote_ref->old_oid))
1637                        return error("Remote branch %s resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", remote_ref->name, oid_to_hex(&remote_ref->old_oid));
1638
1639                /* Remote branch must be an ancestor of remote HEAD */
1640                if (!verify_merge_base(&head_oid, remote_ref)) {
1641                        return error("The branch '%s' is not an ancestor "
1642                                     "of your current HEAD.\n"
1643                                     "If you are sure you want to delete it,"
1644                                     " run:\n\t'git http-push -D %s %s'",
1645                                     remote_ref->name, repo->url, pattern);
1646                }
1647        }
1648
1649        /* Send delete request */
1650        fprintf(stderr, "Removing remote branch '%s'\n", remote_ref->name);
1651        if (dry_run)
1652                return 0;
1653        url = xstrfmt("%s%s", repo->url, remote_ref->name);
1654        slot = get_active_slot();
1655        slot->results = &results;
1656        curl_setup_http_get(slot->curl, url, DAV_DELETE);
1657        if (start_active_slot(slot)) {
1658                run_active_slot(slot);
1659                free(url);
1660                if (results.curl_result != CURLE_OK)
1661                        return error("DELETE request failed (%d/%ld)",
1662                                     results.curl_result, results.http_code);
1663        } else {
1664                free(url);
1665                return error("Unable to start DELETE request");
1666        }
1667
1668        return 0;
1669}
1670
1671static void run_request_queue(void)
1672{
1673#ifdef USE_CURL_MULTI
1674        is_running_queue = 1;
1675        fill_active_slots();
1676        add_fill_function(NULL, fill_active_slot);
1677#endif
1678        do {
1679                finish_all_active_slots();
1680#ifdef USE_CURL_MULTI
1681                fill_active_slots();
1682#endif
1683        } while (request_queue_head && !aborted);
1684
1685#ifdef USE_CURL_MULTI
1686        is_running_queue = 0;
1687#endif
1688}
1689
1690int cmd_main(int argc, const char **argv)
1691{
1692        struct transfer_request *request;
1693        struct transfer_request *next_request;
1694        int nr_refspec = 0;
1695        const char **refspec = NULL;
1696        struct remote_lock *ref_lock = NULL;
1697        struct remote_lock *info_ref_lock = NULL;
1698        struct rev_info revs;
1699        int delete_branch = 0;
1700        int force_delete = 0;
1701        int objects_to_send;
1702        int rc = 0;
1703        int i;
1704        int new_refs;
1705        struct ref *ref, *local_refs;
1706
1707        repo = xcalloc(1, sizeof(*repo));
1708
1709        argv++;
1710        for (i = 1; i < argc; i++, argv++) {
1711                const char *arg = *argv;
1712
1713                if (*arg == '-') {
1714                        if (!strcmp(arg, "--all")) {
1715                                push_all = MATCH_REFS_ALL;
1716                                continue;
1717                        }
1718                        if (!strcmp(arg, "--force")) {
1719                                force_all = 1;
1720                                continue;
1721                        }
1722                        if (!strcmp(arg, "--dry-run")) {
1723                                dry_run = 1;
1724                                continue;
1725                        }
1726                        if (!strcmp(arg, "--helper-status")) {
1727                                helper_status = 1;
1728                                continue;
1729                        }
1730                        if (!strcmp(arg, "--verbose")) {
1731                                push_verbosely = 1;
1732                                http_is_verbose = 1;
1733                                continue;
1734                        }
1735                        if (!strcmp(arg, "-d")) {
1736                                delete_branch = 1;
1737                                continue;
1738                        }
1739                        if (!strcmp(arg, "-D")) {
1740                                delete_branch = 1;
1741                                force_delete = 1;
1742                                continue;
1743                        }
1744                        if (!strcmp(arg, "-h"))
1745                                usage(http_push_usage);
1746                }
1747                if (!repo->url) {
1748                        char *path = strstr(arg, "//");
1749                        str_end_url_with_slash(arg, &repo->url);
1750                        repo->path_len = strlen(repo->url);
1751                        if (path) {
1752                                repo->path = strchr(path+2, '/');
1753                                if (repo->path)
1754                                        repo->path_len = strlen(repo->path);
1755                        }
1756                        continue;
1757                }
1758                refspec = argv;
1759                nr_refspec = argc - i;
1760                break;
1761        }
1762
1763#ifndef USE_CURL_MULTI
1764        die("git-push is not available for http/https repository when not compiled with USE_CURL_MULTI");
1765#endif
1766
1767        if (!repo->url)
1768                usage(http_push_usage);
1769
1770        if (delete_branch && nr_refspec != 1)
1771                die("You must specify only one branch name when deleting a remote branch");
1772
1773        setup_git_directory();
1774
1775        memset(remote_dir_exists, -1, 256);
1776
1777        http_init(NULL, repo->url, 1);
1778
1779#ifdef USE_CURL_MULTI
1780        is_running_queue = 0;
1781#endif
1782
1783        /* Verify DAV compliance/lock support */
1784        if (!locking_available()) {
1785                rc = 1;
1786                goto cleanup;
1787        }
1788
1789        sigchain_push_common(remove_locks_on_signal);
1790
1791        /* Check whether the remote has server info files */
1792        repo->can_update_info_refs = 0;
1793        repo->has_info_refs = remote_exists("info/refs");
1794        repo->has_info_packs = remote_exists("objects/info/packs");
1795        if (repo->has_info_refs) {
1796                info_ref_lock = lock_remote("info/refs", LOCK_TIME);
1797                if (info_ref_lock)
1798                        repo->can_update_info_refs = 1;
1799                else {
1800                        error("cannot lock existing info/refs");
1801                        rc = 1;
1802                        goto cleanup;
1803                }
1804        }
1805        if (repo->has_info_packs)
1806                fetch_indices();
1807
1808        /* Get a list of all local and remote heads to validate refspecs */
1809        local_refs = get_local_heads();
1810        fprintf(stderr, "Fetching remote heads...\n");
1811        get_dav_remote_heads();
1812        run_request_queue();
1813
1814        /* Remove a remote branch if -d or -D was specified */
1815        if (delete_branch) {
1816                if (delete_remote_branch(refspec[0], force_delete) == -1) {
1817                        fprintf(stderr, "Unable to delete remote branch %s\n",
1818                                refspec[0]);
1819                        if (helper_status)
1820                                printf("error %s cannot remove\n", refspec[0]);
1821                }
1822                goto cleanup;
1823        }
1824
1825        /* match them up */
1826        if (match_push_refs(local_refs, &remote_refs,
1827                            nr_refspec, (const char **) refspec, push_all)) {
1828                rc = -1;
1829                goto cleanup;
1830        }
1831        if (!remote_refs) {
1832                fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
1833                if (helper_status)
1834                        printf("error null no match\n");
1835                rc = 0;
1836                goto cleanup;
1837        }
1838
1839        new_refs = 0;
1840        for (ref = remote_refs; ref; ref = ref->next) {
1841                struct argv_array commit_argv = ARGV_ARRAY_INIT;
1842
1843                if (!ref->peer_ref)
1844                        continue;
1845
1846                if (is_null_oid(&ref->peer_ref->new_oid)) {
1847                        if (delete_remote_branch(ref->name, 1) == -1) {
1848                                error("Could not remove %s", ref->name);
1849                                if (helper_status)
1850                                        printf("error %s cannot remove\n", ref->name);
1851                                rc = -4;
1852                        }
1853                        else if (helper_status)
1854                                printf("ok %s\n", ref->name);
1855                        new_refs++;
1856                        continue;
1857                }
1858
1859                if (!oidcmp(&ref->old_oid, &ref->peer_ref->new_oid)) {
1860                        if (push_verbosely)
1861                                fprintf(stderr, "'%s': up-to-date\n", ref->name);
1862                        if (helper_status)
1863                                printf("ok %s up to date\n", ref->name);
1864                        continue;
1865                }
1866
1867                if (!force_all &&
1868                    !is_null_oid(&ref->old_oid) &&
1869                    !ref->force) {
1870                        if (!has_object_file(&ref->old_oid) ||
1871                            !ref_newer(&ref->peer_ref->new_oid,
1872                                       &ref->old_oid)) {
1873                                /*
1874                                 * We do not have the remote ref, or
1875                                 * we know that the remote ref is not
1876                                 * an ancestor of what we are trying to
1877                                 * push.  Either way this can be losing
1878                                 * commits at the remote end and likely
1879                                 * we were not up to date to begin with.
1880                                 */
1881                                error("remote '%s' is not an ancestor of\n"
1882                                      "local '%s'.\n"
1883                                      "Maybe you are not up-to-date and "
1884                                      "need to pull first?",
1885                                      ref->name,
1886                                      ref->peer_ref->name);
1887                                if (helper_status)
1888                                        printf("error %s non-fast forward\n", ref->name);
1889                                rc = -2;
1890                                continue;
1891                        }
1892                }
1893                oidcpy(&ref->new_oid, &ref->peer_ref->new_oid);
1894                new_refs++;
1895
1896                fprintf(stderr, "updating '%s'", ref->name);
1897                if (strcmp(ref->name, ref->peer_ref->name))
1898                        fprintf(stderr, " using '%s'", ref->peer_ref->name);
1899                fprintf(stderr, "\n  from %s\n  to   %s\n",
1900                        oid_to_hex(&ref->old_oid), oid_to_hex(&ref->new_oid));
1901                if (dry_run) {
1902                        if (helper_status)
1903                                printf("ok %s\n", ref->name);
1904                        continue;
1905                }
1906
1907                /* Lock remote branch ref */
1908                ref_lock = lock_remote(ref->name, LOCK_TIME);
1909                if (ref_lock == NULL) {
1910                        fprintf(stderr, "Unable to lock remote branch %s\n",
1911                                ref->name);
1912                        if (helper_status)
1913                                printf("error %s lock error\n", ref->name);
1914                        rc = 1;
1915                        continue;
1916                }
1917
1918                /* Set up revision info for this refspec */
1919                argv_array_push(&commit_argv, ""); /* ignored */
1920                argv_array_push(&commit_argv, "--objects");
1921                argv_array_push(&commit_argv, oid_to_hex(&ref->new_oid));
1922                if (!push_all && !is_null_oid(&ref->old_oid))
1923                        argv_array_pushf(&commit_argv, "^%s",
1924                                         oid_to_hex(&ref->old_oid));
1925                init_revisions(&revs, setup_git_directory());
1926                setup_revisions(commit_argv.argc, commit_argv.argv, &revs, NULL);
1927                revs.edge_hint = 0; /* just in case */
1928
1929                /* Generate a list of objects that need to be pushed */
1930                pushing = 0;
1931                if (prepare_revision_walk(&revs))
1932                        die("revision walk setup failed");
1933                mark_edges_uninteresting(&revs, NULL);
1934                objects_to_send = get_delta(&revs, ref_lock);
1935                finish_all_active_slots();
1936
1937                /* Push missing objects to remote, this would be a
1938                   convenient time to pack them first if appropriate. */
1939                pushing = 1;
1940                if (objects_to_send)
1941                        fprintf(stderr, "    sending %d objects\n",
1942                                objects_to_send);
1943
1944                run_request_queue();
1945
1946                /* Update the remote branch if all went well */
1947                if (aborted || !update_remote(ref->new_oid.hash, ref_lock))
1948                        rc = 1;
1949
1950                if (!rc)
1951                        fprintf(stderr, "    done\n");
1952                if (helper_status)
1953                        printf("%s %s\n", !rc ? "ok" : "error", ref->name);
1954                unlock_remote(ref_lock);
1955                check_locks();
1956                argv_array_clear(&commit_argv);
1957        }
1958
1959        /* Update remote server info if appropriate */
1960        if (repo->has_info_refs && new_refs) {
1961                if (info_ref_lock && repo->can_update_info_refs) {
1962                        fprintf(stderr, "Updating remote server info\n");
1963                        if (!dry_run)
1964                                update_remote_info_refs(info_ref_lock);
1965                } else {
1966                        fprintf(stderr, "Unable to update server info\n");
1967                }
1968        }
1969
1970 cleanup:
1971        if (info_ref_lock)
1972                unlock_remote(info_ref_lock);
1973        free(repo);
1974
1975        http_cleanup();
1976
1977        request = request_queue_head;
1978        while (request != NULL) {
1979                next_request = request->next;
1980                release_request(request);
1981                request = next_request;
1982        }
1983
1984        return rc;
1985}