http-push.con commit Merge branch 'master' of git://github.com/git-l10n/git-po (a3c34cb)
   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                }
 919        } else {
 920                fprintf(stderr, "Unable to start LOCK request\n");
 921        }
 922
 923        curl_slist_free_all(dav_headers);
 924        strbuf_release(&out_buffer.buf);
 925        strbuf_release(&in_buffer);
 926
 927        if (lock->token == NULL || lock->timeout <= 0) {
 928                free(lock->token);
 929                free(lock->owner);
 930                free(url);
 931                FREE_AND_NULL(lock);
 932        } else {
 933                lock->url = url;
 934                lock->start_time = time(NULL);
 935                lock->next = repo->locks;
 936                repo->locks = lock;
 937        }
 938
 939        return lock;
 940}
 941
 942static int unlock_remote(struct remote_lock *lock)
 943{
 944        struct active_request_slot *slot;
 945        struct slot_results results;
 946        struct remote_lock *prev = repo->locks;
 947        struct curl_slist *dav_headers;
 948        int rc = 0;
 949
 950        dav_headers = get_dav_token_headers(lock, DAV_HEADER_LOCK);
 951
 952        slot = get_active_slot();
 953        slot->results = &results;
 954        curl_setup_http_get(slot->curl, lock->url, DAV_UNLOCK);
 955        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
 956
 957        if (start_active_slot(slot)) {
 958                run_active_slot(slot);
 959                if (results.curl_result == CURLE_OK)
 960                        rc = 1;
 961                else
 962                        fprintf(stderr, "UNLOCK HTTP error %ld\n",
 963                                results.http_code);
 964        } else {
 965                fprintf(stderr, "Unable to start UNLOCK request\n");
 966        }
 967
 968        curl_slist_free_all(dav_headers);
 969
 970        if (repo->locks == lock) {
 971                repo->locks = lock->next;
 972        } else {
 973                while (prev && prev->next != lock)
 974                        prev = prev->next;
 975                if (prev)
 976                        prev->next = prev->next->next;
 977        }
 978
 979        free(lock->owner);
 980        free(lock->url);
 981        free(lock->token);
 982        free(lock);
 983
 984        return rc;
 985}
 986
 987static void remove_locks(void)
 988{
 989        struct remote_lock *lock = repo->locks;
 990
 991        fprintf(stderr, "Removing remote locks...\n");
 992        while (lock) {
 993                struct remote_lock *next = lock->next;
 994                unlock_remote(lock);
 995                lock = next;
 996        }
 997}
 998
 999static void remove_locks_on_signal(int signo)
1000{
1001        remove_locks();
1002        sigchain_pop(signo);
1003        raise(signo);
1004}
1005
1006static void remote_ls(const char *path, int flags,
1007                      void (*userFunc)(struct remote_ls_ctx *ls),
1008                      void *userData);
1009
1010/* extract hex from sharded "xx/x{40}" filename */
1011static int get_oid_hex_from_objpath(const char *path, struct object_id *oid)
1012{
1013        char hex[GIT_MAX_HEXSZ];
1014
1015        if (strlen(path) != GIT_SHA1_HEXSZ + 1)
1016                return -1;
1017
1018        memcpy(hex, path, 2);
1019        path += 2;
1020        path++; /* skip '/' */
1021        memcpy(hex + 2, path, GIT_SHA1_HEXSZ - 2);
1022
1023        return get_oid_hex(hex, oid);
1024}
1025
1026static void process_ls_object(struct remote_ls_ctx *ls)
1027{
1028        unsigned int *parent = (unsigned int *)ls->userData;
1029        const char *path = ls->dentry_name;
1030        struct object_id oid;
1031
1032        if (!strcmp(ls->path, ls->dentry_name) && (ls->flags & IS_DIR)) {
1033                remote_dir_exists[*parent] = 1;
1034                return;
1035        }
1036
1037        if (!skip_prefix(path, "objects/", &path) ||
1038            get_oid_hex_from_objpath(path, &oid))
1039                return;
1040
1041        one_remote_object(&oid);
1042}
1043
1044static void process_ls_ref(struct remote_ls_ctx *ls)
1045{
1046        if (!strcmp(ls->path, ls->dentry_name) && (ls->dentry_flags & IS_DIR)) {
1047                fprintf(stderr, "  %s\n", ls->dentry_name);
1048                return;
1049        }
1050
1051        if (!(ls->dentry_flags & IS_DIR))
1052                one_remote_ref(ls->dentry_name);
1053}
1054
1055static void handle_remote_ls_ctx(struct xml_ctx *ctx, int tag_closed)
1056{
1057        struct remote_ls_ctx *ls = (struct remote_ls_ctx *)ctx->userData;
1058
1059        if (tag_closed) {
1060                if (!strcmp(ctx->name, DAV_PROPFIND_RESP) && ls->dentry_name) {
1061                        if (ls->dentry_flags & IS_DIR) {
1062
1063                                /* ensure collection names end with slash */
1064                                str_end_url_with_slash(ls->dentry_name, &ls->dentry_name);
1065
1066                                if (ls->flags & PROCESS_DIRS) {
1067                                        ls->userFunc(ls);
1068                                }
1069                                if (strcmp(ls->dentry_name, ls->path) &&
1070                                    ls->flags & RECURSIVE) {
1071                                        remote_ls(ls->dentry_name,
1072                                                  ls->flags,
1073                                                  ls->userFunc,
1074                                                  ls->userData);
1075                                }
1076                        } else if (ls->flags & PROCESS_FILES) {
1077                                ls->userFunc(ls);
1078                        }
1079                } else if (!strcmp(ctx->name, DAV_PROPFIND_NAME) && ctx->cdata) {
1080                        char *path = ctx->cdata;
1081                        if (*ctx->cdata == 'h') {
1082                                path = strstr(path, "//");
1083                                if (path) {
1084                                        path = strchr(path+2, '/');
1085                                }
1086                        }
1087                        if (path) {
1088                                const char *url = repo->url;
1089                                if (repo->path)
1090                                        url = repo->path;
1091                                if (strncmp(path, url, repo->path_len))
1092                                        error("Parsed path '%s' does not match url: '%s'",
1093                                              path, url);
1094                                else {
1095                                        path += repo->path_len;
1096                                        ls->dentry_name = xstrdup(path);
1097                                }
1098                        }
1099                } else if (!strcmp(ctx->name, DAV_PROPFIND_COLLECTION)) {
1100                        ls->dentry_flags |= IS_DIR;
1101                }
1102        } else if (!strcmp(ctx->name, DAV_PROPFIND_RESP)) {
1103                FREE_AND_NULL(ls->dentry_name);
1104                ls->dentry_flags = 0;
1105        }
1106}
1107
1108/*
1109 * NEEDSWORK: remote_ls() ignores info/refs on the remote side.  But it
1110 * should _only_ heed the information from that file, instead of trying to
1111 * determine the refs from the remote file system (badly: it does not even
1112 * know about packed-refs).
1113 */
1114static void remote_ls(const char *path, int flags,
1115                      void (*userFunc)(struct remote_ls_ctx *ls),
1116                      void *userData)
1117{
1118        char *url = xstrfmt("%s%s", repo->url, path);
1119        struct active_request_slot *slot;
1120        struct slot_results results;
1121        struct strbuf in_buffer = STRBUF_INIT;
1122        struct buffer out_buffer = { STRBUF_INIT, 0 };
1123        struct curl_slist *dav_headers = http_copy_default_headers();
1124        struct xml_ctx ctx;
1125        struct remote_ls_ctx ls;
1126
1127        ls.flags = flags;
1128        ls.path = xstrdup(path);
1129        ls.dentry_name = NULL;
1130        ls.dentry_flags = 0;
1131        ls.userData = userData;
1132        ls.userFunc = userFunc;
1133
1134        strbuf_addstr(&out_buffer.buf, PROPFIND_ALL_REQUEST);
1135
1136        dav_headers = curl_slist_append(dav_headers, "Depth: 1");
1137        dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1138
1139        slot = get_active_slot();
1140        slot->results = &results;
1141        curl_setup_http(slot->curl, url, DAV_PROPFIND,
1142                        &out_buffer, fwrite_buffer);
1143        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1144        curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1145
1146        if (start_active_slot(slot)) {
1147                run_active_slot(slot);
1148                if (results.curl_result == CURLE_OK) {
1149                        XML_Parser parser = XML_ParserCreate(NULL);
1150                        enum XML_Status result;
1151                        ctx.name = xcalloc(10, 1);
1152                        ctx.len = 0;
1153                        ctx.cdata = NULL;
1154                        ctx.userFunc = handle_remote_ls_ctx;
1155                        ctx.userData = &ls;
1156                        XML_SetUserData(parser, &ctx);
1157                        XML_SetElementHandler(parser, xml_start_tag,
1158                                              xml_end_tag);
1159                        XML_SetCharacterDataHandler(parser, xml_cdata);
1160                        result = XML_Parse(parser, in_buffer.buf,
1161                                           in_buffer.len, 1);
1162                        free(ctx.name);
1163
1164                        if (result != XML_STATUS_OK) {
1165                                fprintf(stderr, "XML error: %s\n",
1166                                        XML_ErrorString(
1167                                                XML_GetErrorCode(parser)));
1168                        }
1169                        XML_ParserFree(parser);
1170                }
1171        } else {
1172                fprintf(stderr, "Unable to start PROPFIND request\n");
1173        }
1174
1175        free(ls.path);
1176        free(url);
1177        strbuf_release(&out_buffer.buf);
1178        strbuf_release(&in_buffer);
1179        curl_slist_free_all(dav_headers);
1180}
1181
1182static void get_remote_object_list(unsigned char parent)
1183{
1184        char path[] = "objects/XX/";
1185        static const char hex[] = "0123456789abcdef";
1186        unsigned int val = parent;
1187
1188        path[8] = hex[val >> 4];
1189        path[9] = hex[val & 0xf];
1190        remote_dir_exists[val] = 0;
1191        remote_ls(path, (PROCESS_FILES | PROCESS_DIRS),
1192                  process_ls_object, &val);
1193}
1194
1195static int locking_available(void)
1196{
1197        struct active_request_slot *slot;
1198        struct slot_results results;
1199        struct strbuf in_buffer = STRBUF_INIT;
1200        struct buffer out_buffer = { STRBUF_INIT, 0 };
1201        struct curl_slist *dav_headers = http_copy_default_headers();
1202        struct xml_ctx ctx;
1203        int lock_flags = 0;
1204        char *escaped;
1205
1206        escaped = xml_entities(repo->url);
1207        strbuf_addf(&out_buffer.buf, PROPFIND_SUPPORTEDLOCK_REQUEST, escaped);
1208        free(escaped);
1209
1210        dav_headers = curl_slist_append(dav_headers, "Depth: 0");
1211        dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1212
1213        slot = get_active_slot();
1214        slot->results = &results;
1215        curl_setup_http(slot->curl, repo->url, DAV_PROPFIND,
1216                        &out_buffer, fwrite_buffer);
1217        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1218        curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1219
1220        if (start_active_slot(slot)) {
1221                run_active_slot(slot);
1222                if (results.curl_result == CURLE_OK) {
1223                        XML_Parser parser = XML_ParserCreate(NULL);
1224                        enum XML_Status result;
1225                        ctx.name = xcalloc(10, 1);
1226                        ctx.len = 0;
1227                        ctx.cdata = NULL;
1228                        ctx.userFunc = handle_lockprop_ctx;
1229                        ctx.userData = &lock_flags;
1230                        XML_SetUserData(parser, &ctx);
1231                        XML_SetElementHandler(parser, xml_start_tag,
1232                                              xml_end_tag);
1233                        result = XML_Parse(parser, in_buffer.buf,
1234                                           in_buffer.len, 1);
1235                        free(ctx.name);
1236
1237                        if (result != XML_STATUS_OK) {
1238                                fprintf(stderr, "XML error: %s\n",
1239                                        XML_ErrorString(
1240                                                XML_GetErrorCode(parser)));
1241                                lock_flags = 0;
1242                        }
1243                        XML_ParserFree(parser);
1244                        if (!lock_flags)
1245                                error("no DAV locking support on %s",
1246                                      repo->url);
1247
1248                } else {
1249                        error("Cannot access URL %s, return code %d",
1250                              repo->url, results.curl_result);
1251                        lock_flags = 0;
1252                }
1253        } else {
1254                error("Unable to start PROPFIND request on %s", repo->url);
1255        }
1256
1257        strbuf_release(&out_buffer.buf);
1258        strbuf_release(&in_buffer);
1259        curl_slist_free_all(dav_headers);
1260
1261        return lock_flags;
1262}
1263
1264static struct object_list **add_one_object(struct object *obj, struct object_list **p)
1265{
1266        struct object_list *entry = xmalloc(sizeof(struct object_list));
1267        entry->item = obj;
1268        entry->next = *p;
1269        *p = entry;
1270        return &entry->next;
1271}
1272
1273static struct object_list **process_blob(struct blob *blob,
1274                                         struct object_list **p)
1275{
1276        struct object *obj = &blob->object;
1277
1278        obj->flags |= LOCAL;
1279
1280        if (obj->flags & (UNINTERESTING | SEEN))
1281                return p;
1282
1283        obj->flags |= SEEN;
1284        return add_one_object(obj, p);
1285}
1286
1287static struct object_list **process_tree(struct tree *tree,
1288                                         struct object_list **p)
1289{
1290        struct object *obj = &tree->object;
1291        struct tree_desc desc;
1292        struct name_entry entry;
1293
1294        obj->flags |= LOCAL;
1295
1296        if (obj->flags & (UNINTERESTING | SEEN))
1297                return p;
1298        if (parse_tree(tree) < 0)
1299                die("bad tree object %s", oid_to_hex(&obj->oid));
1300
1301        obj->flags |= SEEN;
1302        p = add_one_object(obj, p);
1303
1304        init_tree_desc(&desc, tree->buffer, tree->size);
1305
1306        while (tree_entry(&desc, &entry))
1307                switch (object_type(entry.mode)) {
1308                case OBJ_TREE:
1309                        p = process_tree(lookup_tree(entry.oid), p);
1310                        break;
1311                case OBJ_BLOB:
1312                        p = process_blob(lookup_blob(entry.oid), p);
1313                        break;
1314                default:
1315                        /* Subproject commit - not in this repository */
1316                        break;
1317                }
1318
1319        free_tree_buffer(tree);
1320        return p;
1321}
1322
1323static int get_delta(struct rev_info *revs, struct remote_lock *lock)
1324{
1325        int i;
1326        struct commit *commit;
1327        struct object_list **p = &objects;
1328        int count = 0;
1329
1330        while ((commit = get_revision(revs)) != NULL) {
1331                p = process_tree(commit->tree, p);
1332                commit->object.flags |= LOCAL;
1333                if (!(commit->object.flags & UNINTERESTING))
1334                        count += add_send_request(&commit->object, lock);
1335        }
1336
1337        for (i = 0; i < revs->pending.nr; i++) {
1338                struct object_array_entry *entry = revs->pending.objects + i;
1339                struct object *obj = entry->item;
1340                const char *name = entry->name;
1341
1342                if (obj->flags & (UNINTERESTING | SEEN))
1343                        continue;
1344                if (obj->type == OBJ_TAG) {
1345                        obj->flags |= SEEN;
1346                        p = add_one_object(obj, p);
1347                        continue;
1348                }
1349                if (obj->type == OBJ_TREE) {
1350                        p = process_tree((struct tree *)obj, p);
1351                        continue;
1352                }
1353                if (obj->type == OBJ_BLOB) {
1354                        p = process_blob((struct blob *)obj, p);
1355                        continue;
1356                }
1357                die("unknown pending object %s (%s)", oid_to_hex(&obj->oid), name);
1358        }
1359
1360        while (objects) {
1361                if (!(objects->item->flags & UNINTERESTING))
1362                        count += add_send_request(objects->item, lock);
1363                objects = objects->next;
1364        }
1365
1366        return count;
1367}
1368
1369static int update_remote(unsigned char *sha1, struct remote_lock *lock)
1370{
1371        struct active_request_slot *slot;
1372        struct slot_results results;
1373        struct buffer out_buffer = { STRBUF_INIT, 0 };
1374        struct curl_slist *dav_headers;
1375
1376        dav_headers = get_dav_token_headers(lock, DAV_HEADER_IF);
1377
1378        strbuf_addf(&out_buffer.buf, "%s\n", sha1_to_hex(sha1));
1379
1380        slot = get_active_slot();
1381        slot->results = &results;
1382        curl_setup_http(slot->curl, lock->url, DAV_PUT,
1383                        &out_buffer, fwrite_null);
1384        curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1385
1386        if (start_active_slot(slot)) {
1387                run_active_slot(slot);
1388                strbuf_release(&out_buffer.buf);
1389                if (results.curl_result != CURLE_OK) {
1390                        fprintf(stderr,
1391                                "PUT error: curl result=%d, HTTP code=%ld\n",
1392                                results.curl_result, results.http_code);
1393                        /* We should attempt recovery? */
1394                        return 0;
1395                }
1396        } else {
1397                strbuf_release(&out_buffer.buf);
1398                fprintf(stderr, "Unable to start PUT request\n");
1399                return 0;
1400        }
1401
1402        return 1;
1403}
1404
1405static struct ref *remote_refs;
1406
1407static void one_remote_ref(const char *refname)
1408{
1409        struct ref *ref;
1410        struct object *obj;
1411
1412        ref = alloc_ref(refname);
1413
1414        if (http_fetch_ref(repo->url, ref) != 0) {
1415                fprintf(stderr,
1416                        "Unable to fetch ref %s from %s\n",
1417                        refname, repo->url);
1418                free(ref);
1419                return;
1420        }
1421
1422        /*
1423         * Fetch a copy of the object if it doesn't exist locally - it
1424         * may be required for updating server info later.
1425         */
1426        if (repo->can_update_info_refs && !has_object_file(&ref->old_oid)) {
1427                obj = lookup_unknown_object(ref->old_oid.hash);
1428                fprintf(stderr, "  fetch %s for %s\n",
1429                        oid_to_hex(&ref->old_oid), refname);
1430                add_fetch_request(obj);
1431        }
1432
1433        ref->next = remote_refs;
1434        remote_refs = ref;
1435}
1436
1437static void get_dav_remote_heads(void)
1438{
1439        remote_ls("refs/", (PROCESS_FILES | PROCESS_DIRS | RECURSIVE), process_ls_ref, NULL);
1440}
1441
1442static void add_remote_info_ref(struct remote_ls_ctx *ls)
1443{
1444        struct strbuf *buf = (struct strbuf *)ls->userData;
1445        struct object *o;
1446        struct ref *ref;
1447
1448        ref = alloc_ref(ls->dentry_name);
1449
1450        if (http_fetch_ref(repo->url, ref) != 0) {
1451                fprintf(stderr,
1452                        "Unable to fetch ref %s from %s\n",
1453                        ls->dentry_name, repo->url);
1454                aborted = 1;
1455                free(ref);
1456                return;
1457        }
1458
1459        o = parse_object(&ref->old_oid);
1460        if (!o) {
1461                fprintf(stderr,
1462                        "Unable to parse object %s for remote ref %s\n",
1463                        oid_to_hex(&ref->old_oid), ls->dentry_name);
1464                aborted = 1;
1465                free(ref);
1466                return;
1467        }
1468
1469        strbuf_addf(buf, "%s\t%s\n",
1470                    oid_to_hex(&ref->old_oid), ls->dentry_name);
1471
1472        if (o->type == OBJ_TAG) {
1473                o = deref_tag(o, ls->dentry_name, 0);
1474                if (o)
1475                        strbuf_addf(buf, "%s\t%s^{}\n",
1476                                    oid_to_hex(&o->oid), ls->dentry_name);
1477        }
1478        free(ref);
1479}
1480
1481static void update_remote_info_refs(struct remote_lock *lock)
1482{
1483        struct buffer buffer = { STRBUF_INIT, 0 };
1484        struct active_request_slot *slot;
1485        struct slot_results results;
1486        struct curl_slist *dav_headers;
1487
1488        remote_ls("refs/", (PROCESS_FILES | RECURSIVE),
1489                  add_remote_info_ref, &buffer.buf);
1490        if (!aborted) {
1491                dav_headers = get_dav_token_headers(lock, DAV_HEADER_IF);
1492
1493                slot = get_active_slot();
1494                slot->results = &results;
1495                curl_setup_http(slot->curl, lock->url, DAV_PUT,
1496                                &buffer, fwrite_null);
1497                curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1498
1499                if (start_active_slot(slot)) {
1500                        run_active_slot(slot);
1501                        if (results.curl_result != CURLE_OK) {
1502                                fprintf(stderr,
1503                                        "PUT error: curl result=%d, HTTP code=%ld\n",
1504                                        results.curl_result, results.http_code);
1505                        }
1506                }
1507        }
1508        strbuf_release(&buffer.buf);
1509}
1510
1511static int remote_exists(const char *path)
1512{
1513        char *url = xstrfmt("%s%s", repo->url, path);
1514        int ret;
1515
1516
1517        switch (http_get_strbuf(url, NULL, NULL)) {
1518        case HTTP_OK:
1519                ret = 1;
1520                break;
1521        case HTTP_MISSING_TARGET:
1522                ret = 0;
1523                break;
1524        case HTTP_ERROR:
1525                error("unable to access '%s': %s", url, curl_errorstr);
1526                /* fallthrough */
1527        default:
1528                ret = -1;
1529        }
1530        free(url);
1531        return ret;
1532}
1533
1534static void fetch_symref(const char *path, char **symref, struct object_id *oid)
1535{
1536        char *url = xstrfmt("%s%s", repo->url, path);
1537        struct strbuf buffer = STRBUF_INIT;
1538        const char *name;
1539
1540        if (http_get_strbuf(url, &buffer, NULL) != HTTP_OK)
1541                die("Couldn't get %s for remote symref\n%s", url,
1542                    curl_errorstr);
1543        free(url);
1544
1545        FREE_AND_NULL(*symref);
1546        oidclr(oid);
1547
1548        if (buffer.len == 0)
1549                return;
1550
1551        /* Cut off trailing newline. */
1552        strbuf_rtrim(&buffer);
1553
1554        /* If it's a symref, set the refname; otherwise try for a sha1 */
1555        if (skip_prefix(buffer.buf, "ref: ", &name)) {
1556                *symref = xmemdupz(name, buffer.len - (name - buffer.buf));
1557        } else {
1558                get_oid_hex(buffer.buf, oid);
1559        }
1560
1561        strbuf_release(&buffer);
1562}
1563
1564static int verify_merge_base(struct object_id *head_oid, struct ref *remote)
1565{
1566        struct commit *head = lookup_commit_or_die(head_oid, "HEAD");
1567        struct commit *branch = lookup_commit_or_die(&remote->old_oid,
1568                                                     remote->name);
1569
1570        return in_merge_bases(branch, head);
1571}
1572
1573static int delete_remote_branch(const char *pattern, int force)
1574{
1575        struct ref *refs = remote_refs;
1576        struct ref *remote_ref = NULL;
1577        struct object_id head_oid;
1578        char *symref = NULL;
1579        int match;
1580        int patlen = strlen(pattern);
1581        int i;
1582        struct active_request_slot *slot;
1583        struct slot_results results;
1584        char *url;
1585
1586        /* Find the remote branch(es) matching the specified branch name */
1587        for (match = 0; refs; refs = refs->next) {
1588                char *name = refs->name;
1589                int namelen = strlen(name);
1590                if (namelen < patlen ||
1591                    memcmp(name + namelen - patlen, pattern, patlen))
1592                        continue;
1593                if (namelen != patlen && name[namelen - patlen - 1] != '/')
1594                        continue;
1595                match++;
1596                remote_ref = refs;
1597        }
1598        if (match == 0)
1599                return error("No remote branch matches %s", pattern);
1600        if (match != 1)
1601                return error("More than one remote branch matches %s",
1602                             pattern);
1603
1604        /*
1605         * Remote HEAD must be a symref (not exactly foolproof; a remote
1606         * symlink to a symref will look like a symref)
1607         */
1608        fetch_symref("HEAD", &symref, &head_oid);
1609        if (!symref)
1610                return error("Remote HEAD is not a symref");
1611
1612        /* Remote branch must not be the remote HEAD */
1613        for (i = 0; symref && i < MAXDEPTH; i++) {
1614                if (!strcmp(remote_ref->name, symref))
1615                        return error("Remote branch %s is the current HEAD",
1616                                     remote_ref->name);
1617                fetch_symref(symref, &symref, &head_oid);
1618        }
1619
1620        /* Run extra sanity checks if delete is not forced */
1621        if (!force) {
1622                /* Remote HEAD must resolve to a known object */
1623                if (symref)
1624                        return error("Remote HEAD symrefs too deep");
1625                if (is_null_oid(&head_oid))
1626                        return error("Unable to resolve remote HEAD");
1627                if (!has_object_file(&head_oid))
1628                        return error("Remote HEAD resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", oid_to_hex(&head_oid));
1629
1630                /* Remote branch must resolve to a known object */
1631                if (is_null_oid(&remote_ref->old_oid))
1632                        return error("Unable to resolve remote branch %s",
1633                                     remote_ref->name);
1634                if (!has_object_file(&remote_ref->old_oid))
1635                        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));
1636
1637                /* Remote branch must be an ancestor of remote HEAD */
1638                if (!verify_merge_base(&head_oid, remote_ref)) {
1639                        return error("The branch '%s' is not an ancestor "
1640                                     "of your current HEAD.\n"
1641                                     "If you are sure you want to delete it,"
1642                                     " run:\n\t'git http-push -D %s %s'",
1643                                     remote_ref->name, repo->url, pattern);
1644                }
1645        }
1646
1647        /* Send delete request */
1648        fprintf(stderr, "Removing remote branch '%s'\n", remote_ref->name);
1649        if (dry_run)
1650                return 0;
1651        url = xstrfmt("%s%s", repo->url, remote_ref->name);
1652        slot = get_active_slot();
1653        slot->results = &results;
1654        curl_setup_http_get(slot->curl, url, DAV_DELETE);
1655        if (start_active_slot(slot)) {
1656                run_active_slot(slot);
1657                free(url);
1658                if (results.curl_result != CURLE_OK)
1659                        return error("DELETE request failed (%d/%ld)",
1660                                     results.curl_result, results.http_code);
1661        } else {
1662                free(url);
1663                return error("Unable to start DELETE request");
1664        }
1665
1666        return 0;
1667}
1668
1669static void run_request_queue(void)
1670{
1671#ifdef USE_CURL_MULTI
1672        is_running_queue = 1;
1673        fill_active_slots();
1674        add_fill_function(NULL, fill_active_slot);
1675#endif
1676        do {
1677                finish_all_active_slots();
1678#ifdef USE_CURL_MULTI
1679                fill_active_slots();
1680#endif
1681        } while (request_queue_head && !aborted);
1682
1683#ifdef USE_CURL_MULTI
1684        is_running_queue = 0;
1685#endif
1686}
1687
1688int cmd_main(int argc, const char **argv)
1689{
1690        struct transfer_request *request;
1691        struct transfer_request *next_request;
1692        int nr_refspec = 0;
1693        const char **refspec = NULL;
1694        struct remote_lock *ref_lock = NULL;
1695        struct remote_lock *info_ref_lock = NULL;
1696        struct rev_info revs;
1697        int delete_branch = 0;
1698        int force_delete = 0;
1699        int objects_to_send;
1700        int rc = 0;
1701        int i;
1702        int new_refs;
1703        struct ref *ref, *local_refs;
1704
1705        repo = xcalloc(1, sizeof(*repo));
1706
1707        argv++;
1708        for (i = 1; i < argc; i++, argv++) {
1709                const char *arg = *argv;
1710
1711                if (*arg == '-') {
1712                        if (!strcmp(arg, "--all")) {
1713                                push_all = MATCH_REFS_ALL;
1714                                continue;
1715                        }
1716                        if (!strcmp(arg, "--force")) {
1717                                force_all = 1;
1718                                continue;
1719                        }
1720                        if (!strcmp(arg, "--dry-run")) {
1721                                dry_run = 1;
1722                                continue;
1723                        }
1724                        if (!strcmp(arg, "--helper-status")) {
1725                                helper_status = 1;
1726                                continue;
1727                        }
1728                        if (!strcmp(arg, "--verbose")) {
1729                                push_verbosely = 1;
1730                                http_is_verbose = 1;
1731                                continue;
1732                        }
1733                        if (!strcmp(arg, "-d")) {
1734                                delete_branch = 1;
1735                                continue;
1736                        }
1737                        if (!strcmp(arg, "-D")) {
1738                                delete_branch = 1;
1739                                force_delete = 1;
1740                                continue;
1741                        }
1742                        if (!strcmp(arg, "-h"))
1743                                usage(http_push_usage);
1744                }
1745                if (!repo->url) {
1746                        char *path = strstr(arg, "//");
1747                        str_end_url_with_slash(arg, &repo->url);
1748                        repo->path_len = strlen(repo->url);
1749                        if (path) {
1750                                repo->path = strchr(path+2, '/');
1751                                if (repo->path)
1752                                        repo->path_len = strlen(repo->path);
1753                        }
1754                        continue;
1755                }
1756                refspec = argv;
1757                nr_refspec = argc - i;
1758                break;
1759        }
1760
1761#ifndef USE_CURL_MULTI
1762        die("git-push is not available for http/https repository when not compiled with USE_CURL_MULTI");
1763#endif
1764
1765        if (!repo->url)
1766                usage(http_push_usage);
1767
1768        if (delete_branch && nr_refspec != 1)
1769                die("You must specify only one branch name when deleting a remote branch");
1770
1771        setup_git_directory();
1772
1773        memset(remote_dir_exists, -1, 256);
1774
1775        http_init(NULL, repo->url, 1);
1776
1777#ifdef USE_CURL_MULTI
1778        is_running_queue = 0;
1779#endif
1780
1781        /* Verify DAV compliance/lock support */
1782        if (!locking_available()) {
1783                rc = 1;
1784                goto cleanup;
1785        }
1786
1787        sigchain_push_common(remove_locks_on_signal);
1788
1789        /* Check whether the remote has server info files */
1790        repo->can_update_info_refs = 0;
1791        repo->has_info_refs = remote_exists("info/refs");
1792        repo->has_info_packs = remote_exists("objects/info/packs");
1793        if (repo->has_info_refs) {
1794                info_ref_lock = lock_remote("info/refs", LOCK_TIME);
1795                if (info_ref_lock)
1796                        repo->can_update_info_refs = 1;
1797                else {
1798                        error("cannot lock existing info/refs");
1799                        rc = 1;
1800                        goto cleanup;
1801                }
1802        }
1803        if (repo->has_info_packs)
1804                fetch_indices();
1805
1806        /* Get a list of all local and remote heads to validate refspecs */
1807        local_refs = get_local_heads();
1808        fprintf(stderr, "Fetching remote heads...\n");
1809        get_dav_remote_heads();
1810        run_request_queue();
1811
1812        /* Remove a remote branch if -d or -D was specified */
1813        if (delete_branch) {
1814                if (delete_remote_branch(refspec[0], force_delete) == -1) {
1815                        fprintf(stderr, "Unable to delete remote branch %s\n",
1816                                refspec[0]);
1817                        if (helper_status)
1818                                printf("error %s cannot remove\n", refspec[0]);
1819                }
1820                goto cleanup;
1821        }
1822
1823        /* match them up */
1824        if (match_push_refs(local_refs, &remote_refs,
1825                            nr_refspec, (const char **) refspec, push_all)) {
1826                rc = -1;
1827                goto cleanup;
1828        }
1829        if (!remote_refs) {
1830                fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
1831                if (helper_status)
1832                        printf("error null no match\n");
1833                rc = 0;
1834                goto cleanup;
1835        }
1836
1837        new_refs = 0;
1838        for (ref = remote_refs; ref; ref = ref->next) {
1839                struct argv_array commit_argv = ARGV_ARRAY_INIT;
1840
1841                if (!ref->peer_ref)
1842                        continue;
1843
1844                if (is_null_oid(&ref->peer_ref->new_oid)) {
1845                        if (delete_remote_branch(ref->name, 1) == -1) {
1846                                error("Could not remove %s", ref->name);
1847                                if (helper_status)
1848                                        printf("error %s cannot remove\n", ref->name);
1849                                rc = -4;
1850                        }
1851                        else if (helper_status)
1852                                printf("ok %s\n", ref->name);
1853                        new_refs++;
1854                        continue;
1855                }
1856
1857                if (!oidcmp(&ref->old_oid, &ref->peer_ref->new_oid)) {
1858                        if (push_verbosely)
1859                                fprintf(stderr, "'%s': up-to-date\n", ref->name);
1860                        if (helper_status)
1861                                printf("ok %s up to date\n", ref->name);
1862                        continue;
1863                }
1864
1865                if (!force_all &&
1866                    !is_null_oid(&ref->old_oid) &&
1867                    !ref->force) {
1868                        if (!has_object_file(&ref->old_oid) ||
1869                            !ref_newer(&ref->peer_ref->new_oid,
1870                                       &ref->old_oid)) {
1871                                /*
1872                                 * We do not have the remote ref, or
1873                                 * we know that the remote ref is not
1874                                 * an ancestor of what we are trying to
1875                                 * push.  Either way this can be losing
1876                                 * commits at the remote end and likely
1877                                 * we were not up to date to begin with.
1878                                 */
1879                                error("remote '%s' is not an ancestor of\n"
1880                                      "local '%s'.\n"
1881                                      "Maybe you are not up-to-date and "
1882                                      "need to pull first?",
1883                                      ref->name,
1884                                      ref->peer_ref->name);
1885                                if (helper_status)
1886                                        printf("error %s non-fast forward\n", ref->name);
1887                                rc = -2;
1888                                continue;
1889                        }
1890                }
1891                oidcpy(&ref->new_oid, &ref->peer_ref->new_oid);
1892                new_refs++;
1893
1894                fprintf(stderr, "updating '%s'", ref->name);
1895                if (strcmp(ref->name, ref->peer_ref->name))
1896                        fprintf(stderr, " using '%s'", ref->peer_ref->name);
1897                fprintf(stderr, "\n  from %s\n  to   %s\n",
1898                        oid_to_hex(&ref->old_oid), oid_to_hex(&ref->new_oid));
1899                if (dry_run) {
1900                        if (helper_status)
1901                                printf("ok %s\n", ref->name);
1902                        continue;
1903                }
1904
1905                /* Lock remote branch ref */
1906                ref_lock = lock_remote(ref->name, LOCK_TIME);
1907                if (ref_lock == NULL) {
1908                        fprintf(stderr, "Unable to lock remote branch %s\n",
1909                                ref->name);
1910                        if (helper_status)
1911                                printf("error %s lock error\n", ref->name);
1912                        rc = 1;
1913                        continue;
1914                }
1915
1916                /* Set up revision info for this refspec */
1917                argv_array_push(&commit_argv, ""); /* ignored */
1918                argv_array_push(&commit_argv, "--objects");
1919                argv_array_push(&commit_argv, oid_to_hex(&ref->new_oid));
1920                if (!push_all && !is_null_oid(&ref->old_oid))
1921                        argv_array_pushf(&commit_argv, "^%s",
1922                                         oid_to_hex(&ref->old_oid));
1923                init_revisions(&revs, setup_git_directory());
1924                setup_revisions(commit_argv.argc, commit_argv.argv, &revs, NULL);
1925                revs.edge_hint = 0; /* just in case */
1926
1927                /* Generate a list of objects that need to be pushed */
1928                pushing = 0;
1929                if (prepare_revision_walk(&revs))
1930                        die("revision walk setup failed");
1931                mark_edges_uninteresting(&revs, NULL);
1932                objects_to_send = get_delta(&revs, ref_lock);
1933                finish_all_active_slots();
1934
1935                /* Push missing objects to remote, this would be a
1936                   convenient time to pack them first if appropriate. */
1937                pushing = 1;
1938                if (objects_to_send)
1939                        fprintf(stderr, "    sending %d objects\n",
1940                                objects_to_send);
1941
1942                run_request_queue();
1943
1944                /* Update the remote branch if all went well */
1945                if (aborted || !update_remote(ref->new_oid.hash, ref_lock))
1946                        rc = 1;
1947
1948                if (!rc)
1949                        fprintf(stderr, "    done\n");
1950                if (helper_status)
1951                        printf("%s %s\n", !rc ? "ok" : "error", ref->name);
1952                unlock_remote(ref_lock);
1953                check_locks();
1954                argv_array_clear(&commit_argv);
1955        }
1956
1957        /* Update remote server info if appropriate */
1958        if (repo->has_info_refs && new_refs) {
1959                if (info_ref_lock && repo->can_update_info_refs) {
1960                        fprintf(stderr, "Updating remote server info\n");
1961                        if (!dry_run)
1962                                update_remote_info_refs(info_ref_lock);
1963                } else {
1964                        fprintf(stderr, "Unable to update server info\n");
1965                }
1966        }
1967
1968 cleanup:
1969        if (info_ref_lock)
1970                unlock_remote(info_ref_lock);
1971        free(repo);
1972
1973        http_cleanup();
1974
1975        request = request_queue_head;
1976        while (request != NULL) {
1977                next_request = request->next;
1978                release_request(request);
1979                request = next_request;
1980        }
1981
1982        return rc;
1983}