12 #include "list-objects.h"
16 static const char http_push_usage
[] =
17 "git http-push [--all] [--dry-run] [--force] [--verbose] <remote> [<head>...]\n";
24 #define XML_STATUS_OK 1
25 #define XML_STATUS_ERROR 0
28 #define PREV_BUF_SIZE 4096
29 #define RANGE_HEADER_SIZE 30
32 #define DAV_LOCK "LOCK"
33 #define DAV_MKCOL "MKCOL"
34 #define DAV_MOVE "MOVE"
35 #define DAV_PROPFIND "PROPFIND"
37 #define DAV_UNLOCK "UNLOCK"
38 #define DAV_DELETE "DELETE"
41 #define DAV_PROP_LOCKWR (1u << 0)
42 #define DAV_PROP_LOCKEX (1u << 1)
43 #define DAV_LOCK_OK (1u << 2)
45 /* DAV XML properties */
46 #define DAV_CTX_LOCKENTRY ".multistatus.response.propstat.prop.supportedlock.lockentry"
47 #define DAV_CTX_LOCKTYPE_WRITE ".multistatus.response.propstat.prop.supportedlock.lockentry.locktype.write"
48 #define DAV_CTX_LOCKTYPE_EXCLUSIVE ".multistatus.response.propstat.prop.supportedlock.lockentry.lockscope.exclusive"
49 #define DAV_ACTIVELOCK_OWNER ".prop.lockdiscovery.activelock.owner.href"
50 #define DAV_ACTIVELOCK_TIMEOUT ".prop.lockdiscovery.activelock.timeout"
51 #define DAV_ACTIVELOCK_TOKEN ".prop.lockdiscovery.activelock.locktoken.href"
52 #define DAV_PROPFIND_RESP ".multistatus.response"
53 #define DAV_PROPFIND_NAME ".multistatus.response.href"
54 #define DAV_PROPFIND_COLLECTION ".multistatus.response.propstat.prop.resourcetype.collection"
56 /* DAV request body templates */
57 #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>"
58 #define PROPFIND_ALL_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/>\n</D:propfind>"
59 #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>"
62 #define LOCK_REFRESH 30
64 /* bits #0-15 in revision.h */
66 #define LOCAL (1u<<16)
67 #define REMOTE (1u<<17)
68 #define FETCHING (1u<<18)
69 #define PUSHING (1u<<19)
71 /* We allow "recursive" symbolic refs. Only within reason, though */
76 static signed char remote_dir_exists
[256];
78 static struct curl_slist
*no_pragma_header
;
80 static int push_verbosely
;
81 static int push_all
= MATCH_REFS_NONE
;
85 static struct object_list
*objects
;
93 int can_update_info_refs
;
95 struct packed_git
*packs
;
96 struct remote_lock
*locks
;
99 static struct repo
*remote
;
101 enum transfer_state
{
113 struct transfer_request
118 struct remote_lock
*lock
;
119 struct curl_slist
*headers
;
120 struct buffer buffer
;
121 char filename
[PATH_MAX
];
122 char tmpfile
[PATH_MAX
];
125 enum transfer_state state
;
126 CURLcode curl_result
;
127 char errorstr
[CURL_ERROR_SIZE
];
129 unsigned char real_sha1
[20];
135 struct active_request_slot
*slot
;
136 struct transfer_request
*next
;
139 static struct transfer_request
*request_queue_head
;
146 void (*userFunc
)(struct xml_ctx
*ctx
, int tag_closed
);
158 struct remote_lock
*next
;
161 /* Flags that control remote_ls processing */
162 #define PROCESS_FILES (1u << 0)
163 #define PROCESS_DIRS (1u << 1)
164 #define RECURSIVE (1u << 2)
166 /* Flags that remote_ls passes to callback functions */
167 #define IS_DIR (1u << 0)
172 void (*userFunc
)(struct remote_ls_ctx
*ls
);
177 struct remote_ls_ctx
*parent
;
180 static void finish_request(struct transfer_request
*request
);
181 static void release_request(struct transfer_request
*request
);
183 static void process_response(void *callback_data
)
185 struct transfer_request
*request
=
186 (struct transfer_request
*)callback_data
;
188 finish_request(request
);
191 #ifdef USE_CURL_MULTI
192 static size_t fwrite_sha1_file(void *ptr
, size_t eltsize
, size_t nmemb
,
195 unsigned char expn
[4096];
196 size_t size
= eltsize
* nmemb
;
198 struct transfer_request
*request
= (struct transfer_request
*)data
;
200 ssize_t retval
= xwrite(request
->local_fileno
,
201 (char *) ptr
+ posn
, size
- posn
);
205 } while (posn
< size
);
207 request
->stream
.avail_in
= size
;
208 request
->stream
.next_in
= ptr
;
210 request
->stream
.next_out
= expn
;
211 request
->stream
.avail_out
= sizeof(expn
);
212 request
->zret
= git_inflate(&request
->stream
, Z_SYNC_FLUSH
);
213 git_SHA1_Update(&request
->c
, expn
,
214 sizeof(expn
) - request
->stream
.avail_out
);
215 } while (request
->stream
.avail_in
&& request
->zret
== Z_OK
);
220 static void start_fetch_loose(struct transfer_request
*request
)
222 char *hex
= sha1_to_hex(request
->obj
->sha1
);
224 char prevfile
[PATH_MAX
];
228 unsigned char prev_buf
[PREV_BUF_SIZE
];
229 ssize_t prev_read
= 0;
231 char range
[RANGE_HEADER_SIZE
];
232 struct curl_slist
*range_header
= NULL
;
233 struct active_request_slot
*slot
;
235 filename
= sha1_file_name(request
->obj
->sha1
);
236 snprintf(request
->filename
, sizeof(request
->filename
), "%s", filename
);
237 snprintf(request
->tmpfile
, sizeof(request
->tmpfile
),
238 "%s.temp", filename
);
240 snprintf(prevfile
, sizeof(prevfile
), "%s.prev", request
->filename
);
242 rename(request
->tmpfile
, prevfile
);
243 unlink(request
->tmpfile
);
245 if (request
->local_fileno
!= -1)
246 error("fd leakage in start: %d", request
->local_fileno
);
247 request
->local_fileno
= open(request
->tmpfile
,
248 O_WRONLY
| O_CREAT
| O_EXCL
, 0666);
249 /* This could have failed due to the "lazy directory creation";
250 * try to mkdir the last path component.
252 if (request
->local_fileno
< 0 && errno
== ENOENT
) {
253 char *dir
= strrchr(request
->tmpfile
, '/');
256 mkdir(request
->tmpfile
, 0777);
259 request
->local_fileno
= open(request
->tmpfile
,
260 O_WRONLY
| O_CREAT
| O_EXCL
, 0666);
263 if (request
->local_fileno
< 0) {
264 request
->state
= ABORTED
;
265 error("Couldn't create temporary file %s for %s: %s",
266 request
->tmpfile
, request
->filename
, strerror(errno
));
270 memset(&request
->stream
, 0, sizeof(request
->stream
));
272 git_inflate_init(&request
->stream
);
274 git_SHA1_Init(&request
->c
);
276 url
= xmalloc(strlen(remote
->url
) + 50);
277 request
->url
= xmalloc(strlen(remote
->url
) + 50);
278 strcpy(url
, remote
->url
);
279 posn
= url
+ strlen(remote
->url
);
280 strcpy(posn
, "objects/");
282 memcpy(posn
, hex
, 2);
285 strcpy(posn
, hex
+ 2);
286 strcpy(request
->url
, url
);
288 /* If a previous temp file is present, process what was already
290 prevlocal
= open(prevfile
, O_RDONLY
);
291 if (prevlocal
!= -1) {
293 prev_read
= xread(prevlocal
, prev_buf
, PREV_BUF_SIZE
);
295 if (fwrite_sha1_file(prev_buf
,
298 request
) == prev_read
) {
299 prev_posn
+= prev_read
;
304 } while (prev_read
> 0);
309 /* Reset inflate/SHA1 if there was an error reading the previous temp
310 file; also rewind to the beginning of the local file. */
311 if (prev_read
== -1) {
312 memset(&request
->stream
, 0, sizeof(request
->stream
));
313 git_inflate_init(&request
->stream
);
314 git_SHA1_Init(&request
->c
);
317 lseek(request
->local_fileno
, 0, SEEK_SET
);
318 ftruncate(request
->local_fileno
, 0);
322 slot
= get_active_slot();
323 slot
->callback_func
= process_response
;
324 slot
->callback_data
= request
;
325 request
->slot
= slot
;
327 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, request
);
328 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_sha1_file
);
329 curl_easy_setopt(slot
->curl
, CURLOPT_ERRORBUFFER
, request
->errorstr
);
330 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
331 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, no_pragma_header
);
333 /* If we have successfully processed data from a previous fetch
334 attempt, only fetch the data we don't already have. */
338 "Resuming fetch of object %s at byte %ld\n",
340 sprintf(range
, "Range: bytes=%ld-", prev_posn
);
341 range_header
= curl_slist_append(range_header
, range
);
342 curl_easy_setopt(slot
->curl
,
343 CURLOPT_HTTPHEADER
, range_header
);
346 /* Try to get the request started, abort the request on error */
347 request
->state
= RUN_FETCH_LOOSE
;
348 if (!start_active_slot(slot
)) {
349 fprintf(stderr
, "Unable to start GET request\n");
350 remote
->can_update_info_refs
= 0;
351 release_request(request
);
355 static void start_mkcol(struct transfer_request
*request
)
357 char *hex
= sha1_to_hex(request
->obj
->sha1
);
358 struct active_request_slot
*slot
;
361 request
->url
= xmalloc(strlen(remote
->url
) + 13);
362 strcpy(request
->url
, remote
->url
);
363 posn
= request
->url
+ strlen(remote
->url
);
364 strcpy(posn
, "objects/");
366 memcpy(posn
, hex
, 2);
370 slot
= get_active_slot();
371 slot
->callback_func
= process_response
;
372 slot
->callback_data
= request
;
373 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPGET
, 1); /* undo PUT setup */
374 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, request
->url
);
375 curl_easy_setopt(slot
->curl
, CURLOPT_ERRORBUFFER
, request
->errorstr
);
376 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_MKCOL
);
377 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
379 if (start_active_slot(slot
)) {
380 request
->slot
= slot
;
381 request
->state
= RUN_MKCOL
;
383 request
->state
= ABORTED
;
390 static void start_fetch_packed(struct transfer_request
*request
)
393 struct packed_git
*target
;
397 char range
[RANGE_HEADER_SIZE
];
398 struct curl_slist
*range_header
= NULL
;
400 struct transfer_request
*check_request
= request_queue_head
;
401 struct active_request_slot
*slot
;
403 target
= find_sha1_pack(request
->obj
->sha1
, remote
->packs
);
405 fprintf(stderr
, "Unable to fetch %s, will not be able to update server info refs\n", sha1_to_hex(request
->obj
->sha1
));
406 remote
->can_update_info_refs
= 0;
407 release_request(request
);
411 fprintf(stderr
, "Fetching pack %s\n", sha1_to_hex(target
->sha1
));
412 fprintf(stderr
, " which contains %s\n", sha1_to_hex(request
->obj
->sha1
));
414 filename
= sha1_pack_name(target
->sha1
);
415 snprintf(request
->filename
, sizeof(request
->filename
), "%s", filename
);
416 snprintf(request
->tmpfile
, sizeof(request
->tmpfile
),
417 "%s.temp", filename
);
419 url
= xmalloc(strlen(remote
->url
) + 64);
420 sprintf(url
, "%sobjects/pack/pack-%s.pack",
421 remote
->url
, sha1_to_hex(target
->sha1
));
423 /* Make sure there isn't another open request for this pack */
424 while (check_request
) {
425 if (check_request
->state
== RUN_FETCH_PACKED
&&
426 !strcmp(check_request
->url
, url
)) {
428 release_request(request
);
431 check_request
= check_request
->next
;
434 packfile
= fopen(request
->tmpfile
, "a");
436 fprintf(stderr
, "Unable to open local file %s for pack",
438 remote
->can_update_info_refs
= 0;
443 slot
= get_active_slot();
444 slot
->callback_func
= process_response
;
445 slot
->callback_data
= request
;
446 request
->slot
= slot
;
447 request
->local_stream
= packfile
;
448 request
->userData
= target
;
451 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, packfile
);
452 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite
);
453 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
454 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, no_pragma_header
);
455 slot
->local
= packfile
;
457 /* If there is data present from a previous transfer attempt,
458 resume where it left off */
459 prev_posn
= ftell(packfile
);
463 "Resuming fetch of pack %s at byte %ld\n",
464 sha1_to_hex(target
->sha1
), prev_posn
);
465 sprintf(range
, "Range: bytes=%ld-", prev_posn
);
466 range_header
= curl_slist_append(range_header
, range
);
467 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, range_header
);
470 /* Try to get the request started, abort the request on error */
471 request
->state
= RUN_FETCH_PACKED
;
472 if (!start_active_slot(slot
)) {
473 fprintf(stderr
, "Unable to start GET request\n");
474 remote
->can_update_info_refs
= 0;
475 release_request(request
);
479 static void start_put(struct transfer_request
*request
)
481 char *hex
= sha1_to_hex(request
->obj
->sha1
);
482 struct active_request_slot
*slot
;
484 enum object_type type
;
492 unpacked
= read_sha1_file(request
->obj
->sha1
, &type
, &len
);
493 hdrlen
= sprintf(hdr
, "%s %lu", typename(type
), len
) + 1;
496 memset(&stream
, 0, sizeof(stream
));
497 deflateInit(&stream
, zlib_compression_level
);
498 size
= deflateBound(&stream
, len
+ hdrlen
);
499 strbuf_init(&request
->buffer
.buf
, size
);
500 request
->buffer
.posn
= 0;
503 stream
.next_out
= (unsigned char *)request
->buffer
.buf
.buf
;
504 stream
.avail_out
= size
;
507 stream
.next_in
= (void *)hdr
;
508 stream
.avail_in
= hdrlen
;
509 while (deflate(&stream
, 0) == Z_OK
)
512 /* Then the data itself.. */
513 stream
.next_in
= unpacked
;
514 stream
.avail_in
= len
;
515 while (deflate(&stream
, Z_FINISH
) == Z_OK
)
520 request
->buffer
.buf
.len
= stream
.total_out
;
522 request
->url
= xmalloc(strlen(remote
->url
) +
523 strlen(request
->lock
->token
) + 51);
524 strcpy(request
->url
, remote
->url
);
525 posn
= request
->url
+ strlen(remote
->url
);
526 strcpy(posn
, "objects/");
528 memcpy(posn
, hex
, 2);
531 strcpy(posn
, hex
+ 2);
532 request
->dest
= xmalloc(strlen(request
->url
) + 14);
533 sprintf(request
->dest
, "Destination: %s", request
->url
);
536 strcpy(posn
, request
->lock
->token
);
538 slot
= get_active_slot();
539 slot
->callback_func
= process_response
;
540 slot
->callback_data
= request
;
541 curl_easy_setopt(slot
->curl
, CURLOPT_INFILE
, &request
->buffer
);
542 curl_easy_setopt(slot
->curl
, CURLOPT_INFILESIZE
, request
->buffer
.buf
.len
);
543 curl_easy_setopt(slot
->curl
, CURLOPT_READFUNCTION
, fread_buffer
);
544 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
545 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_PUT
);
546 curl_easy_setopt(slot
->curl
, CURLOPT_UPLOAD
, 1);
547 curl_easy_setopt(slot
->curl
, CURLOPT_PUT
, 1);
548 curl_easy_setopt(slot
->curl
, CURLOPT_NOBODY
, 0);
549 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, request
->url
);
551 if (start_active_slot(slot
)) {
552 request
->slot
= slot
;
553 request
->state
= RUN_PUT
;
555 request
->state
= ABORTED
;
561 static void start_move(struct transfer_request
*request
)
563 struct active_request_slot
*slot
;
564 struct curl_slist
*dav_headers
= NULL
;
566 slot
= get_active_slot();
567 slot
->callback_func
= process_response
;
568 slot
->callback_data
= request
;
569 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPGET
, 1); /* undo PUT setup */
570 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_MOVE
);
571 dav_headers
= curl_slist_append(dav_headers
, request
->dest
);
572 dav_headers
= curl_slist_append(dav_headers
, "Overwrite: T");
573 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, dav_headers
);
574 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
575 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, request
->url
);
577 if (start_active_slot(slot
)) {
578 request
->slot
= slot
;
579 request
->state
= RUN_MOVE
;
581 request
->state
= ABORTED
;
587 static int refresh_lock(struct remote_lock
*lock
)
589 struct active_request_slot
*slot
;
590 struct slot_results results
;
592 char timeout_header
[25];
593 struct curl_slist
*dav_headers
= NULL
;
596 lock
->refreshing
= 1;
598 if_header
= xmalloc(strlen(lock
->token
) + 25);
599 sprintf(if_header
, "If: (<%s>)", lock
->token
);
600 sprintf(timeout_header
, "Timeout: Second-%ld", lock
->timeout
);
601 dav_headers
= curl_slist_append(dav_headers
, if_header
);
602 dav_headers
= curl_slist_append(dav_headers
, timeout_header
);
604 slot
= get_active_slot();
605 slot
->results
= &results
;
606 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPGET
, 1);
607 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
608 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, lock
->url
);
609 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_LOCK
);
610 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, dav_headers
);
612 if (start_active_slot(slot
)) {
613 run_active_slot(slot
);
614 if (results
.curl_result
!= CURLE_OK
) {
615 fprintf(stderr
, "LOCK HTTP error %ld\n",
618 lock
->start_time
= time(NULL
);
623 lock
->refreshing
= 0;
624 curl_slist_free_all(dav_headers
);
630 static void check_locks(void)
632 struct remote_lock
*lock
= remote
->locks
;
633 time_t current_time
= time(NULL
);
637 time_remaining
= lock
->start_time
+ lock
->timeout
-
639 if (!lock
->refreshing
&& time_remaining
< LOCK_REFRESH
) {
640 if (!refresh_lock(lock
)) {
642 "Unable to refresh lock for %s\n",
652 static void release_request(struct transfer_request
*request
)
654 struct transfer_request
*entry
= request_queue_head
;
656 if (request
== request_queue_head
) {
657 request_queue_head
= request
->next
;
659 while (entry
->next
!= NULL
&& entry
->next
!= request
)
661 if (entry
->next
== request
)
662 entry
->next
= entry
->next
->next
;
665 if (request
->local_fileno
!= -1)
666 close(request
->local_fileno
);
667 if (request
->local_stream
)
668 fclose(request
->local_stream
);
673 static void finish_request(struct transfer_request
*request
)
676 struct packed_git
*target
;
677 struct packed_git
**lst
;
679 request
->curl_result
= request
->slot
->curl_result
;
680 request
->http_code
= request
->slot
->http_code
;
681 request
->slot
= NULL
;
683 /* Keep locks active */
686 if (request
->headers
!= NULL
)
687 curl_slist_free_all(request
->headers
);
689 /* URL is reused for MOVE after PUT */
690 if (request
->state
!= RUN_PUT
) {
695 if (request
->state
== RUN_MKCOL
) {
696 if (request
->curl_result
== CURLE_OK
||
697 request
->http_code
== 405) {
698 remote_dir_exists
[request
->obj
->sha1
[0]] = 1;
701 fprintf(stderr
, "MKCOL %s failed, aborting (%d/%ld)\n",
702 sha1_to_hex(request
->obj
->sha1
),
703 request
->curl_result
, request
->http_code
);
704 request
->state
= ABORTED
;
707 } else if (request
->state
== RUN_PUT
) {
708 if (request
->curl_result
== CURLE_OK
) {
711 fprintf(stderr
, "PUT %s failed, aborting (%d/%ld)\n",
712 sha1_to_hex(request
->obj
->sha1
),
713 request
->curl_result
, request
->http_code
);
714 request
->state
= ABORTED
;
717 } else if (request
->state
== RUN_MOVE
) {
718 if (request
->curl_result
== CURLE_OK
) {
720 fprintf(stderr
, " sent %s\n",
721 sha1_to_hex(request
->obj
->sha1
));
722 request
->obj
->flags
|= REMOTE
;
723 release_request(request
);
725 fprintf(stderr
, "MOVE %s failed, aborting (%d/%ld)\n",
726 sha1_to_hex(request
->obj
->sha1
),
727 request
->curl_result
, request
->http_code
);
728 request
->state
= ABORTED
;
731 } else if (request
->state
== RUN_FETCH_LOOSE
) {
732 fchmod(request
->local_fileno
, 0444);
733 close(request
->local_fileno
); request
->local_fileno
= -1;
735 if (request
->curl_result
!= CURLE_OK
&&
736 request
->http_code
!= 416) {
737 if (stat(request
->tmpfile
, &st
) == 0) {
739 unlink(request
->tmpfile
);
742 if (request
->http_code
== 416)
743 fprintf(stderr
, "Warning: requested range invalid; we may already have all the data.\n");
745 git_inflate_end(&request
->stream
);
746 git_SHA1_Final(request
->real_sha1
, &request
->c
);
747 if (request
->zret
!= Z_STREAM_END
) {
748 unlink(request
->tmpfile
);
749 } else if (hashcmp(request
->obj
->sha1
, request
->real_sha1
)) {
750 unlink(request
->tmpfile
);
756 if (request
->rename
== 0) {
757 request
->obj
->flags
|= (LOCAL
| REMOTE
);
762 /* Try fetching packed if necessary */
763 if (request
->obj
->flags
& LOCAL
)
764 release_request(request
);
766 start_fetch_packed(request
);
768 } else if (request
->state
== RUN_FETCH_PACKED
) {
769 if (request
->curl_result
!= CURLE_OK
) {
770 fprintf(stderr
, "Unable to get pack file %s\n%s",
771 request
->url
, curl_errorstr
);
772 remote
->can_update_info_refs
= 0;
774 off_t pack_size
= ftell(request
->local_stream
);
776 fclose(request
->local_stream
);
777 request
->local_stream
= NULL
;
778 if (!move_temp_to_file(request
->tmpfile
,
779 request
->filename
)) {
780 target
= (struct packed_git
*)request
->userData
;
781 target
->pack_size
= pack_size
;
782 lst
= &remote
->packs
;
783 while (*lst
!= target
)
784 lst
= &((*lst
)->next
);
787 if (!verify_pack(target
))
788 install_packed_git(target
);
790 remote
->can_update_info_refs
= 0;
793 release_request(request
);
797 #ifdef USE_CURL_MULTI
798 static int fill_active_slot(void *unused
)
800 struct transfer_request
*request
= request_queue_head
;
805 for (request
= request_queue_head
; request
; request
= request
->next
) {
806 if (request
->state
== NEED_FETCH
) {
807 start_fetch_loose(request
);
809 } else if (pushing
&& request
->state
== NEED_PUSH
) {
810 if (remote_dir_exists
[request
->obj
->sha1
[0]] == 1) {
813 start_mkcol(request
);
822 static void get_remote_object_list(unsigned char parent
);
824 static void add_fetch_request(struct object
*obj
)
826 struct transfer_request
*request
;
831 * Don't fetch the object if it's known to exist locally
832 * or is already in the request queue
834 if (remote_dir_exists
[obj
->sha1
[0]] == -1)
835 get_remote_object_list(obj
->sha1
[0]);
836 if (obj
->flags
& (LOCAL
| FETCHING
))
839 obj
->flags
|= FETCHING
;
840 request
= xmalloc(sizeof(*request
));
843 request
->lock
= NULL
;
844 request
->headers
= NULL
;
845 request
->local_fileno
= -1;
846 request
->local_stream
= NULL
;
847 request
->state
= NEED_FETCH
;
848 request
->next
= request_queue_head
;
849 request_queue_head
= request
;
851 #ifdef USE_CURL_MULTI
857 static int add_send_request(struct object
*obj
, struct remote_lock
*lock
)
859 struct transfer_request
*request
= request_queue_head
;
860 struct packed_git
*target
;
862 /* Keep locks active */
866 * Don't push the object if it's known to exist on the remote
867 * or is already in the request queue
869 if (remote_dir_exists
[obj
->sha1
[0]] == -1)
870 get_remote_object_list(obj
->sha1
[0]);
871 if (obj
->flags
& (REMOTE
| PUSHING
))
873 target
= find_sha1_pack(obj
->sha1
, remote
->packs
);
875 obj
->flags
|= REMOTE
;
879 obj
->flags
|= PUSHING
;
880 request
= xmalloc(sizeof(*request
));
883 request
->lock
= lock
;
884 request
->headers
= NULL
;
885 request
->local_fileno
= -1;
886 request
->local_stream
= NULL
;
887 request
->state
= NEED_PUSH
;
888 request
->next
= request_queue_head
;
889 request_queue_head
= request
;
891 #ifdef USE_CURL_MULTI
899 static int fetch_index(unsigned char *sha1
)
901 char *hex
= sha1_to_hex(sha1
);
904 char tmpfile
[PATH_MAX
];
906 char range
[RANGE_HEADER_SIZE
];
907 struct curl_slist
*range_header
= NULL
;
910 struct active_request_slot
*slot
;
911 struct slot_results results
;
913 /* Don't use the index if the pack isn't there */
914 url
= xmalloc(strlen(remote
->url
) + 64);
915 sprintf(url
, "%sobjects/pack/pack-%s.pack", remote
->url
, hex
);
916 slot
= get_active_slot();
917 slot
->results
= &results
;
918 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
919 curl_easy_setopt(slot
->curl
, CURLOPT_NOBODY
, 1);
920 if (start_active_slot(slot
)) {
921 run_active_slot(slot
);
922 if (results
.curl_result
!= CURLE_OK
) {
924 return error("Unable to verify pack %s is available",
929 return error("Unable to start request");
932 if (has_pack_index(sha1
)) {
938 fprintf(stderr
, "Getting index for pack %s\n", hex
);
940 sprintf(url
, "%sobjects/pack/pack-%s.idx", remote
->url
, hex
);
942 filename
= sha1_pack_index_name(sha1
);
943 snprintf(tmpfile
, sizeof(tmpfile
), "%s.temp", filename
);
944 indexfile
= fopen(tmpfile
, "a");
947 return error("Unable to open local file %s for pack index",
951 slot
= get_active_slot();
952 slot
->results
= &results
;
953 curl_easy_setopt(slot
->curl
, CURLOPT_NOBODY
, 0);
954 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPGET
, 1);
955 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, indexfile
);
956 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite
);
957 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
958 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, no_pragma_header
);
959 slot
->local
= indexfile
;
961 /* If there is data present from a previous transfer attempt,
962 resume where it left off */
963 prev_posn
= ftell(indexfile
);
967 "Resuming fetch of index for pack %s at byte %ld\n",
969 sprintf(range
, "Range: bytes=%ld-", prev_posn
);
970 range_header
= curl_slist_append(range_header
, range
);
971 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, range_header
);
974 if (start_active_slot(slot
)) {
975 run_active_slot(slot
);
976 if (results
.curl_result
!= CURLE_OK
) {
979 return error("Unable to get pack index %s\n%s", url
,
985 return error("Unable to start request");
991 return move_temp_to_file(tmpfile
, filename
);
994 static int setup_index(unsigned char *sha1
)
996 struct packed_git
*new_pack
;
998 if (fetch_index(sha1
))
1001 new_pack
= parse_pack_index(sha1
);
1002 new_pack
->next
= remote
->packs
;
1003 remote
->packs
= new_pack
;
1007 static int fetch_indices(void)
1009 unsigned char sha1
[20];
1011 struct strbuf buffer
= STRBUF_INIT
;
1015 struct active_request_slot
*slot
;
1016 struct slot_results results
;
1019 fprintf(stderr
, "Getting pack list\n");
1021 url
= xmalloc(strlen(remote
->url
) + 20);
1022 sprintf(url
, "%sobjects/info/packs", remote
->url
);
1024 slot
= get_active_slot();
1025 slot
->results
= &results
;
1026 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &buffer
);
1027 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
1028 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
1029 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, NULL
);
1030 if (start_active_slot(slot
)) {
1031 run_active_slot(slot
);
1032 if (results
.curl_result
!= CURLE_OK
) {
1033 strbuf_release(&buffer
);
1035 if (results
.http_code
== 404)
1038 return error("%s", curl_errorstr
);
1041 strbuf_release(&buffer
);
1043 return error("Unable to start request");
1048 while (i
< buffer
.len
) {
1052 if (i
+ 52 < buffer
.len
&&
1053 !prefixcmp(data
+ i
, " pack-") &&
1054 !prefixcmp(data
+ i
+ 46, ".pack\n")) {
1055 get_sha1_hex(data
+ i
+ 6, sha1
);
1061 while (data
[i
] != '\n')
1067 strbuf_release(&buffer
);
1071 static void one_remote_object(const char *hex
)
1073 unsigned char sha1
[20];
1076 if (get_sha1_hex(hex
, sha1
) != 0)
1079 obj
= lookup_object(sha1
);
1081 obj
= parse_object(sha1
);
1083 /* Ignore remote objects that don't exist locally */
1087 obj
->flags
|= REMOTE
;
1088 if (!object_list_contains(objects
, obj
))
1089 object_list_insert(obj
, &objects
);
1092 static void handle_lockprop_ctx(struct xml_ctx
*ctx
, int tag_closed
)
1094 int *lock_flags
= (int *)ctx
->userData
;
1097 if (!strcmp(ctx
->name
, DAV_CTX_LOCKENTRY
)) {
1098 if ((*lock_flags
& DAV_PROP_LOCKEX
) &&
1099 (*lock_flags
& DAV_PROP_LOCKWR
)) {
1100 *lock_flags
|= DAV_LOCK_OK
;
1102 *lock_flags
&= DAV_LOCK_OK
;
1103 } else if (!strcmp(ctx
->name
, DAV_CTX_LOCKTYPE_WRITE
)) {
1104 *lock_flags
|= DAV_PROP_LOCKWR
;
1105 } else if (!strcmp(ctx
->name
, DAV_CTX_LOCKTYPE_EXCLUSIVE
)) {
1106 *lock_flags
|= DAV_PROP_LOCKEX
;
1111 static void handle_new_lock_ctx(struct xml_ctx
*ctx
, int tag_closed
)
1113 struct remote_lock
*lock
= (struct remote_lock
*)ctx
->userData
;
1115 if (tag_closed
&& ctx
->cdata
) {
1116 if (!strcmp(ctx
->name
, DAV_ACTIVELOCK_OWNER
)) {
1117 lock
->owner
= xmalloc(strlen(ctx
->cdata
) + 1);
1118 strcpy(lock
->owner
, ctx
->cdata
);
1119 } else if (!strcmp(ctx
->name
, DAV_ACTIVELOCK_TIMEOUT
)) {
1120 if (!prefixcmp(ctx
->cdata
, "Second-"))
1122 strtol(ctx
->cdata
+ 7, NULL
, 10);
1123 } else if (!strcmp(ctx
->name
, DAV_ACTIVELOCK_TOKEN
)) {
1124 lock
->token
= xmalloc(strlen(ctx
->cdata
) + 1);
1125 strcpy(lock
->token
, ctx
->cdata
);
1130 static void one_remote_ref(char *refname
);
1133 xml_start_tag(void *userData
, const char *name
, const char **atts
)
1135 struct xml_ctx
*ctx
= (struct xml_ctx
*)userData
;
1136 const char *c
= strchr(name
, ':');
1144 new_len
= strlen(ctx
->name
) + strlen(c
) + 2;
1146 if (new_len
> ctx
->len
) {
1147 ctx
->name
= xrealloc(ctx
->name
, new_len
);
1150 strcat(ctx
->name
, ".");
1151 strcat(ctx
->name
, c
);
1156 ctx
->userFunc(ctx
, 0);
1160 xml_end_tag(void *userData
, const char *name
)
1162 struct xml_ctx
*ctx
= (struct xml_ctx
*)userData
;
1163 const char *c
= strchr(name
, ':');
1166 ctx
->userFunc(ctx
, 1);
1173 ep
= ctx
->name
+ strlen(ctx
->name
) - strlen(c
) - 1;
1178 xml_cdata(void *userData
, const XML_Char
*s
, int len
)
1180 struct xml_ctx
*ctx
= (struct xml_ctx
*)userData
;
1182 ctx
->cdata
= xmemdupz(s
, len
);
1185 static struct remote_lock
*lock_remote(const char *path
, long timeout
)
1187 struct active_request_slot
*slot
;
1188 struct slot_results results
;
1189 struct buffer out_buffer
= { STRBUF_INIT
, 0 };
1190 struct strbuf in_buffer
= STRBUF_INIT
;
1193 char timeout_header
[25];
1194 struct remote_lock
*lock
= NULL
;
1195 struct curl_slist
*dav_headers
= NULL
;
1198 url
= xmalloc(strlen(remote
->url
) + strlen(path
) + 1);
1199 sprintf(url
, "%s%s", remote
->url
, path
);
1201 /* Make sure leading directories exist for the remote ref */
1202 ep
= strchr(url
+ strlen(remote
->url
) + 1, '/');
1204 char saved_character
= ep
[1];
1206 slot
= get_active_slot();
1207 slot
->results
= &results
;
1208 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPGET
, 1);
1209 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
1210 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_MKCOL
);
1211 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
1212 if (start_active_slot(slot
)) {
1213 run_active_slot(slot
);
1214 if (results
.curl_result
!= CURLE_OK
&&
1215 results
.http_code
!= 405) {
1217 "Unable to create branch path %s\n",
1223 fprintf(stderr
, "Unable to start MKCOL request\n");
1227 ep
[1] = saved_character
;
1228 ep
= strchr(ep
+ 1, '/');
1231 strbuf_addf(&out_buffer
.buf
, LOCK_REQUEST
, git_default_email
);
1233 sprintf(timeout_header
, "Timeout: Second-%ld", timeout
);
1234 dav_headers
= curl_slist_append(dav_headers
, timeout_header
);
1235 dav_headers
= curl_slist_append(dav_headers
, "Content-Type: text/xml");
1237 slot
= get_active_slot();
1238 slot
->results
= &results
;
1239 curl_easy_setopt(slot
->curl
, CURLOPT_INFILE
, &out_buffer
);
1240 curl_easy_setopt(slot
->curl
, CURLOPT_INFILESIZE
, out_buffer
.buf
.len
);
1241 curl_easy_setopt(slot
->curl
, CURLOPT_READFUNCTION
, fread_buffer
);
1242 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &in_buffer
);
1243 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
1244 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
1245 curl_easy_setopt(slot
->curl
, CURLOPT_UPLOAD
, 1);
1246 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_LOCK
);
1247 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, dav_headers
);
1249 lock
= xcalloc(1, sizeof(*lock
));
1252 if (start_active_slot(slot
)) {
1253 run_active_slot(slot
);
1254 if (results
.curl_result
== CURLE_OK
) {
1255 XML_Parser parser
= XML_ParserCreate(NULL
);
1256 enum XML_Status result
;
1257 ctx
.name
= xcalloc(10, 1);
1260 ctx
.userFunc
= handle_new_lock_ctx
;
1261 ctx
.userData
= lock
;
1262 XML_SetUserData(parser
, &ctx
);
1263 XML_SetElementHandler(parser
, xml_start_tag
,
1265 XML_SetCharacterDataHandler(parser
, xml_cdata
);
1266 result
= XML_Parse(parser
, in_buffer
.buf
,
1269 if (result
!= XML_STATUS_OK
) {
1270 fprintf(stderr
, "XML error: %s\n",
1272 XML_GetErrorCode(parser
)));
1275 XML_ParserFree(parser
);
1278 fprintf(stderr
, "Unable to start LOCK request\n");
1281 curl_slist_free_all(dav_headers
);
1282 strbuf_release(&out_buffer
.buf
);
1283 strbuf_release(&in_buffer
);
1285 if (lock
->token
== NULL
|| lock
->timeout
<= 0) {
1293 lock
->start_time
= time(NULL
);
1294 lock
->next
= remote
->locks
;
1295 remote
->locks
= lock
;
1301 static int unlock_remote(struct remote_lock
*lock
)
1303 struct active_request_slot
*slot
;
1304 struct slot_results results
;
1305 struct remote_lock
*prev
= remote
->locks
;
1306 char *lock_token_header
;
1307 struct curl_slist
*dav_headers
= NULL
;
1310 lock_token_header
= xmalloc(strlen(lock
->token
) + 31);
1311 sprintf(lock_token_header
, "Lock-Token: <%s>",
1313 dav_headers
= curl_slist_append(dav_headers
, lock_token_header
);
1315 slot
= get_active_slot();
1316 slot
->results
= &results
;
1317 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
1318 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, lock
->url
);
1319 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_UNLOCK
);
1320 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, dav_headers
);
1322 if (start_active_slot(slot
)) {
1323 run_active_slot(slot
);
1324 if (results
.curl_result
== CURLE_OK
)
1327 fprintf(stderr
, "UNLOCK HTTP error %ld\n",
1330 fprintf(stderr
, "Unable to start UNLOCK request\n");
1333 curl_slist_free_all(dav_headers
);
1334 free(lock_token_header
);
1336 if (remote
->locks
== lock
) {
1337 remote
->locks
= lock
->next
;
1339 while (prev
&& prev
->next
!= lock
)
1342 prev
->next
= prev
->next
->next
;
1353 static void remove_locks(void)
1355 struct remote_lock
*lock
= remote
->locks
;
1357 fprintf(stderr
, "Removing remote locks...\n");
1359 struct remote_lock
*next
= lock
->next
;
1360 unlock_remote(lock
);
1365 static void remove_locks_on_signal(int signo
)
1368 signal(signo
, SIG_DFL
);
1372 static void remote_ls(const char *path
, int flags
,
1373 void (*userFunc
)(struct remote_ls_ctx
*ls
),
1376 static void process_ls_object(struct remote_ls_ctx
*ls
)
1378 unsigned int *parent
= (unsigned int *)ls
->userData
;
1379 char *path
= ls
->dentry_name
;
1382 if (!strcmp(ls
->path
, ls
->dentry_name
) && (ls
->flags
& IS_DIR
)) {
1383 remote_dir_exists
[*parent
] = 1;
1387 if (strlen(path
) != 49)
1390 obj_hex
= xmalloc(strlen(path
));
1391 /* NB: path is not null-terminated, can not use strlcpy here */
1392 memcpy(obj_hex
, path
, 2);
1393 strcpy(obj_hex
+ 2, path
+ 3);
1394 one_remote_object(obj_hex
);
1398 static void process_ls_ref(struct remote_ls_ctx
*ls
)
1400 if (!strcmp(ls
->path
, ls
->dentry_name
) && (ls
->dentry_flags
& IS_DIR
)) {
1401 fprintf(stderr
, " %s\n", ls
->dentry_name
);
1405 if (!(ls
->dentry_flags
& IS_DIR
))
1406 one_remote_ref(ls
->dentry_name
);
1409 static void handle_remote_ls_ctx(struct xml_ctx
*ctx
, int tag_closed
)
1411 struct remote_ls_ctx
*ls
= (struct remote_ls_ctx
*)ctx
->userData
;
1414 if (!strcmp(ctx
->name
, DAV_PROPFIND_RESP
) && ls
->dentry_name
) {
1415 if (ls
->dentry_flags
& IS_DIR
) {
1416 if (ls
->flags
& PROCESS_DIRS
) {
1419 if (strcmp(ls
->dentry_name
, ls
->path
) &&
1420 ls
->flags
& RECURSIVE
) {
1421 remote_ls(ls
->dentry_name
,
1426 } else if (ls
->flags
& PROCESS_FILES
) {
1429 } else if (!strcmp(ctx
->name
, DAV_PROPFIND_NAME
) && ctx
->cdata
) {
1430 char *path
= ctx
->cdata
;
1431 if (*ctx
->cdata
== 'h') {
1432 path
= strstr(path
, "//");
1434 path
= strchr(path
+2, '/');
1438 path
+= remote
->path_len
;
1439 ls
->dentry_name
= xstrdup(path
);
1441 } else if (!strcmp(ctx
->name
, DAV_PROPFIND_COLLECTION
)) {
1442 ls
->dentry_flags
|= IS_DIR
;
1444 } else if (!strcmp(ctx
->name
, DAV_PROPFIND_RESP
)) {
1445 free(ls
->dentry_name
);
1446 ls
->dentry_name
= NULL
;
1447 ls
->dentry_flags
= 0;
1452 * NEEDSWORK: remote_ls() ignores info/refs on the remote side. But it
1453 * should _only_ heed the information from that file, instead of trying to
1454 * determine the refs from the remote file system (badly: it does not even
1455 * know about packed-refs).
1457 static void remote_ls(const char *path
, int flags
,
1458 void (*userFunc
)(struct remote_ls_ctx
*ls
),
1461 char *url
= xmalloc(strlen(remote
->url
) + strlen(path
) + 1);
1462 struct active_request_slot
*slot
;
1463 struct slot_results results
;
1464 struct strbuf in_buffer
= STRBUF_INIT
;
1465 struct buffer out_buffer
= { STRBUF_INIT
, 0 };
1466 struct curl_slist
*dav_headers
= NULL
;
1468 struct remote_ls_ctx ls
;
1471 ls
.path
= xstrdup(path
);
1472 ls
.dentry_name
= NULL
;
1473 ls
.dentry_flags
= 0;
1474 ls
.userData
= userData
;
1475 ls
.userFunc
= userFunc
;
1477 sprintf(url
, "%s%s", remote
->url
, path
);
1479 strbuf_addf(&out_buffer
.buf
, PROPFIND_ALL_REQUEST
);
1481 dav_headers
= curl_slist_append(dav_headers
, "Depth: 1");
1482 dav_headers
= curl_slist_append(dav_headers
, "Content-Type: text/xml");
1484 slot
= get_active_slot();
1485 slot
->results
= &results
;
1486 curl_easy_setopt(slot
->curl
, CURLOPT_INFILE
, &out_buffer
);
1487 curl_easy_setopt(slot
->curl
, CURLOPT_INFILESIZE
, out_buffer
.buf
.len
);
1488 curl_easy_setopt(slot
->curl
, CURLOPT_READFUNCTION
, fread_buffer
);
1489 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &in_buffer
);
1490 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
1491 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
1492 curl_easy_setopt(slot
->curl
, CURLOPT_UPLOAD
, 1);
1493 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_PROPFIND
);
1494 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, dav_headers
);
1496 if (start_active_slot(slot
)) {
1497 run_active_slot(slot
);
1498 if (results
.curl_result
== CURLE_OK
) {
1499 XML_Parser parser
= XML_ParserCreate(NULL
);
1500 enum XML_Status result
;
1501 ctx
.name
= xcalloc(10, 1);
1504 ctx
.userFunc
= handle_remote_ls_ctx
;
1506 XML_SetUserData(parser
, &ctx
);
1507 XML_SetElementHandler(parser
, xml_start_tag
,
1509 XML_SetCharacterDataHandler(parser
, xml_cdata
);
1510 result
= XML_Parse(parser
, in_buffer
.buf
,
1514 if (result
!= XML_STATUS_OK
) {
1515 fprintf(stderr
, "XML error: %s\n",
1517 XML_GetErrorCode(parser
)));
1519 XML_ParserFree(parser
);
1522 fprintf(stderr
, "Unable to start PROPFIND request\n");
1527 strbuf_release(&out_buffer
.buf
);
1528 strbuf_release(&in_buffer
);
1529 curl_slist_free_all(dav_headers
);
1532 static void get_remote_object_list(unsigned char parent
)
1534 char path
[] = "objects/XX/";
1535 static const char hex
[] = "0123456789abcdef";
1536 unsigned int val
= parent
;
1538 path
[8] = hex
[val
>> 4];
1539 path
[9] = hex
[val
& 0xf];
1540 remote_dir_exists
[val
] = 0;
1541 remote_ls(path
, (PROCESS_FILES
| PROCESS_DIRS
),
1542 process_ls_object
, &val
);
1545 static int locking_available(void)
1547 struct active_request_slot
*slot
;
1548 struct slot_results results
;
1549 struct strbuf in_buffer
= STRBUF_INIT
;
1550 struct buffer out_buffer
= { STRBUF_INIT
, 0 };
1551 struct curl_slist
*dav_headers
= NULL
;
1555 strbuf_addf(&out_buffer
.buf
, PROPFIND_SUPPORTEDLOCK_REQUEST
, remote
->url
);
1557 dav_headers
= curl_slist_append(dav_headers
, "Depth: 0");
1558 dav_headers
= curl_slist_append(dav_headers
, "Content-Type: text/xml");
1560 slot
= get_active_slot();
1561 slot
->results
= &results
;
1562 curl_easy_setopt(slot
->curl
, CURLOPT_INFILE
, &out_buffer
);
1563 curl_easy_setopt(slot
->curl
, CURLOPT_INFILESIZE
, out_buffer
.buf
.len
);
1564 curl_easy_setopt(slot
->curl
, CURLOPT_READFUNCTION
, fread_buffer
);
1565 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &in_buffer
);
1566 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
1567 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, remote
->url
);
1568 curl_easy_setopt(slot
->curl
, CURLOPT_UPLOAD
, 1);
1569 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_PROPFIND
);
1570 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, dav_headers
);
1572 if (start_active_slot(slot
)) {
1573 run_active_slot(slot
);
1574 if (results
.curl_result
== CURLE_OK
) {
1575 XML_Parser parser
= XML_ParserCreate(NULL
);
1576 enum XML_Status result
;
1577 ctx
.name
= xcalloc(10, 1);
1580 ctx
.userFunc
= handle_lockprop_ctx
;
1581 ctx
.userData
= &lock_flags
;
1582 XML_SetUserData(parser
, &ctx
);
1583 XML_SetElementHandler(parser
, xml_start_tag
,
1585 result
= XML_Parse(parser
, in_buffer
.buf
,
1589 if (result
!= XML_STATUS_OK
) {
1590 fprintf(stderr
, "XML error: %s\n",
1592 XML_GetErrorCode(parser
)));
1595 XML_ParserFree(parser
);
1597 error("Error: no DAV locking support on %s",
1601 error("Cannot access URL %s, return code %d",
1602 remote
->url
, results
.curl_result
);
1606 error("Unable to start PROPFIND request on %s", remote
->url
);
1609 strbuf_release(&out_buffer
.buf
);
1610 strbuf_release(&in_buffer
);
1611 curl_slist_free_all(dav_headers
);
1616 static struct object_list
**add_one_object(struct object
*obj
, struct object_list
**p
)
1618 struct object_list
*entry
= xmalloc(sizeof(struct object_list
));
1622 return &entry
->next
;
1625 static struct object_list
**process_blob(struct blob
*blob
,
1626 struct object_list
**p
,
1627 struct name_path
*path
,
1630 struct object
*obj
= &blob
->object
;
1632 obj
->flags
|= LOCAL
;
1634 if (obj
->flags
& (UNINTERESTING
| SEEN
))
1638 return add_one_object(obj
, p
);
1641 static struct object_list
**process_tree(struct tree
*tree
,
1642 struct object_list
**p
,
1643 struct name_path
*path
,
1646 struct object
*obj
= &tree
->object
;
1647 struct tree_desc desc
;
1648 struct name_entry entry
;
1649 struct name_path me
;
1651 obj
->flags
|= LOCAL
;
1653 if (obj
->flags
& (UNINTERESTING
| SEEN
))
1655 if (parse_tree(tree
) < 0)
1656 die("bad tree object %s", sha1_to_hex(obj
->sha1
));
1659 name
= xstrdup(name
);
1660 p
= add_one_object(obj
, p
);
1663 me
.elem_len
= strlen(name
);
1665 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
1667 while (tree_entry(&desc
, &entry
))
1668 switch (object_type(entry
.mode
)) {
1670 p
= process_tree(lookup_tree(entry
.sha1
), p
, &me
, name
);
1673 p
= process_blob(lookup_blob(entry
.sha1
), p
, &me
, name
);
1676 /* Subproject commit - not in this repository */
1681 tree
->buffer
= NULL
;
1685 static int get_delta(struct rev_info
*revs
, struct remote_lock
*lock
)
1688 struct commit
*commit
;
1689 struct object_list
**p
= &objects
;
1692 while ((commit
= get_revision(revs
)) != NULL
) {
1693 p
= process_tree(commit
->tree
, p
, NULL
, "");
1694 commit
->object
.flags
|= LOCAL
;
1695 if (!(commit
->object
.flags
& UNINTERESTING
))
1696 count
+= add_send_request(&commit
->object
, lock
);
1699 for (i
= 0; i
< revs
->pending
.nr
; i
++) {
1700 struct object_array_entry
*entry
= revs
->pending
.objects
+ i
;
1701 struct object
*obj
= entry
->item
;
1702 const char *name
= entry
->name
;
1704 if (obj
->flags
& (UNINTERESTING
| SEEN
))
1706 if (obj
->type
== OBJ_TAG
) {
1708 p
= add_one_object(obj
, p
);
1711 if (obj
->type
== OBJ_TREE
) {
1712 p
= process_tree((struct tree
*)obj
, p
, NULL
, name
);
1715 if (obj
->type
== OBJ_BLOB
) {
1716 p
= process_blob((struct blob
*)obj
, p
, NULL
, name
);
1719 die("unknown pending object %s (%s)", sha1_to_hex(obj
->sha1
), name
);
1723 if (!(objects
->item
->flags
& UNINTERESTING
))
1724 count
+= add_send_request(objects
->item
, lock
);
1725 objects
= objects
->next
;
1731 static int update_remote(unsigned char *sha1
, struct remote_lock
*lock
)
1733 struct active_request_slot
*slot
;
1734 struct slot_results results
;
1736 struct buffer out_buffer
= { STRBUF_INIT
, 0 };
1737 struct curl_slist
*dav_headers
= NULL
;
1739 if_header
= xmalloc(strlen(lock
->token
) + 25);
1740 sprintf(if_header
, "If: (<%s>)", lock
->token
);
1741 dav_headers
= curl_slist_append(dav_headers
, if_header
);
1743 strbuf_addf(&out_buffer
.buf
, "%s\n", sha1_to_hex(sha1
));
1745 slot
= get_active_slot();
1746 slot
->results
= &results
;
1747 curl_easy_setopt(slot
->curl
, CURLOPT_INFILE
, &out_buffer
);
1748 curl_easy_setopt(slot
->curl
, CURLOPT_INFILESIZE
, out_buffer
.buf
.len
);
1749 curl_easy_setopt(slot
->curl
, CURLOPT_READFUNCTION
, fread_buffer
);
1750 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
1751 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_PUT
);
1752 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, dav_headers
);
1753 curl_easy_setopt(slot
->curl
, CURLOPT_UPLOAD
, 1);
1754 curl_easy_setopt(slot
->curl
, CURLOPT_PUT
, 1);
1755 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, lock
->url
);
1757 if (start_active_slot(slot
)) {
1758 run_active_slot(slot
);
1759 strbuf_release(&out_buffer
.buf
);
1761 if (results
.curl_result
!= CURLE_OK
) {
1763 "PUT error: curl result=%d, HTTP code=%ld\n",
1764 results
.curl_result
, results
.http_code
);
1765 /* We should attempt recovery? */
1769 strbuf_release(&out_buffer
.buf
);
1771 fprintf(stderr
, "Unable to start PUT request\n");
1778 static struct ref
*local_refs
, **local_tail
;
1779 static struct ref
*remote_refs
, **remote_tail
;
1781 static int one_local_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
1784 int len
= strlen(refname
) + 1;
1785 ref
= xcalloc(1, sizeof(*ref
) + len
);
1786 hashcpy(ref
->new_sha1
, sha1
);
1787 memcpy(ref
->name
, refname
, len
);
1789 local_tail
= &ref
->next
;
1793 static void one_remote_ref(char *refname
)
1798 ref
= alloc_ref(refname
);
1800 if (http_fetch_ref(remote
->url
, ref
) != 0) {
1802 "Unable to fetch ref %s from %s\n",
1803 refname
, remote
->url
);
1809 * Fetch a copy of the object if it doesn't exist locally - it
1810 * may be required for updating server info later.
1812 if (remote
->can_update_info_refs
&& !has_sha1_file(ref
->old_sha1
)) {
1813 obj
= lookup_unknown_object(ref
->old_sha1
);
1815 fprintf(stderr
, " fetch %s for %s\n",
1816 sha1_to_hex(ref
->old_sha1
), refname
);
1817 add_fetch_request(obj
);
1822 remote_tail
= &ref
->next
;
1825 static void get_local_heads(void)
1827 local_tail
= &local_refs
;
1828 for_each_ref(one_local_ref
, NULL
);
1831 static void get_dav_remote_heads(void)
1833 remote_tail
= &remote_refs
;
1834 remote_ls("refs/", (PROCESS_FILES
| PROCESS_DIRS
| RECURSIVE
), process_ls_ref
, NULL
);
1837 static int is_zero_sha1(const unsigned char *sha1
)
1841 for (i
= 0; i
< 20; i
++) {
1848 static void unmark_and_free(struct commit_list
*list
, unsigned int mark
)
1851 struct commit_list
*temp
= list
;
1852 temp
->item
->object
.flags
&= ~mark
;
1858 static int ref_newer(const unsigned char *new_sha1
,
1859 const unsigned char *old_sha1
)
1862 struct commit
*old
, *new;
1863 struct commit_list
*list
, *used
;
1866 /* Both new and old must be commit-ish and new is descendant of
1867 * old. Otherwise we require --force.
1869 o
= deref_tag(parse_object(old_sha1
), NULL
, 0);
1870 if (!o
|| o
->type
!= OBJ_COMMIT
)
1872 old
= (struct commit
*) o
;
1874 o
= deref_tag(parse_object(new_sha1
), NULL
, 0);
1875 if (!o
|| o
->type
!= OBJ_COMMIT
)
1877 new = (struct commit
*) o
;
1879 if (parse_commit(new) < 0)
1883 commit_list_insert(new, &list
);
1885 new = pop_most_recent_commit(&list
, TMP_MARK
);
1886 commit_list_insert(new, &used
);
1892 unmark_and_free(list
, TMP_MARK
);
1893 unmark_and_free(used
, TMP_MARK
);
1897 static void add_remote_info_ref(struct remote_ls_ctx
*ls
)
1899 struct strbuf
*buf
= (struct strbuf
*)ls
->userData
;
1905 ref
= alloc_ref(ls
->dentry_name
);
1907 if (http_fetch_ref(remote
->url
, ref
) != 0) {
1909 "Unable to fetch ref %s from %s\n",
1910 ls
->dentry_name
, remote
->url
);
1916 o
= parse_object(ref
->old_sha1
);
1919 "Unable to parse object %s for remote ref %s\n",
1920 sha1_to_hex(ref
->old_sha1
), ls
->dentry_name
);
1926 len
= strlen(ls
->dentry_name
) + 42;
1927 ref_info
= xcalloc(len
+ 1, 1);
1928 sprintf(ref_info
, "%s %s\n",
1929 sha1_to_hex(ref
->old_sha1
), ls
->dentry_name
);
1930 fwrite_buffer(ref_info
, 1, len
, buf
);
1933 if (o
->type
== OBJ_TAG
) {
1934 o
= deref_tag(o
, ls
->dentry_name
, 0);
1936 len
= strlen(ls
->dentry_name
) + 45;
1937 ref_info
= xcalloc(len
+ 1, 1);
1938 sprintf(ref_info
, "%s %s^{}\n",
1939 sha1_to_hex(o
->sha1
), ls
->dentry_name
);
1940 fwrite_buffer(ref_info
, 1, len
, buf
);
1947 static void update_remote_info_refs(struct remote_lock
*lock
)
1949 struct buffer buffer
= { STRBUF_INIT
, 0 };
1950 struct active_request_slot
*slot
;
1951 struct slot_results results
;
1953 struct curl_slist
*dav_headers
= NULL
;
1955 remote_ls("refs/", (PROCESS_FILES
| RECURSIVE
),
1956 add_remote_info_ref
, &buffer
.buf
);
1958 if_header
= xmalloc(strlen(lock
->token
) + 25);
1959 sprintf(if_header
, "If: (<%s>)", lock
->token
);
1960 dav_headers
= curl_slist_append(dav_headers
, if_header
);
1962 slot
= get_active_slot();
1963 slot
->results
= &results
;
1964 curl_easy_setopt(slot
->curl
, CURLOPT_INFILE
, &buffer
);
1965 curl_easy_setopt(slot
->curl
, CURLOPT_INFILESIZE
, buffer
.buf
.len
);
1966 curl_easy_setopt(slot
->curl
, CURLOPT_READFUNCTION
, fread_buffer
);
1967 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
1968 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_PUT
);
1969 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, dav_headers
);
1970 curl_easy_setopt(slot
->curl
, CURLOPT_UPLOAD
, 1);
1971 curl_easy_setopt(slot
->curl
, CURLOPT_PUT
, 1);
1972 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, lock
->url
);
1974 if (start_active_slot(slot
)) {
1975 run_active_slot(slot
);
1976 if (results
.curl_result
!= CURLE_OK
) {
1978 "PUT error: curl result=%d, HTTP code=%ld\n",
1979 results
.curl_result
, results
.http_code
);
1984 strbuf_release(&buffer
.buf
);
1987 static int remote_exists(const char *path
)
1989 char *url
= xmalloc(strlen(remote
->url
) + strlen(path
) + 1);
1990 struct active_request_slot
*slot
;
1991 struct slot_results results
;
1994 sprintf(url
, "%s%s", remote
->url
, path
);
1996 slot
= get_active_slot();
1997 slot
->results
= &results
;
1998 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
1999 curl_easy_setopt(slot
->curl
, CURLOPT_NOBODY
, 1);
2001 if (start_active_slot(slot
)) {
2002 run_active_slot(slot
);
2003 if (results
.http_code
== 404)
2005 else if (results
.curl_result
== CURLE_OK
)
2008 fprintf(stderr
, "HEAD HTTP error %ld\n", results
.http_code
);
2010 fprintf(stderr
, "Unable to start HEAD request\n");
2017 static void fetch_symref(const char *path
, char **symref
, unsigned char *sha1
)
2020 struct strbuf buffer
= STRBUF_INIT
;
2021 struct active_request_slot
*slot
;
2022 struct slot_results results
;
2024 url
= xmalloc(strlen(remote
->url
) + strlen(path
) + 1);
2025 sprintf(url
, "%s%s", remote
->url
, path
);
2027 slot
= get_active_slot();
2028 slot
->results
= &results
;
2029 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &buffer
);
2030 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
2031 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, NULL
);
2032 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
2033 if (start_active_slot(slot
)) {
2034 run_active_slot(slot
);
2035 if (results
.curl_result
!= CURLE_OK
) {
2036 die("Couldn't get %s for remote symref\n%s",
2037 url
, curl_errorstr
);
2040 die("Unable to start remote symref request");
2048 if (buffer
.len
== 0)
2051 /* If it's a symref, set the refname; otherwise try for a sha1 */
2052 if (!prefixcmp((char *)buffer
.buf
, "ref: ")) {
2053 *symref
= xmemdupz((char *)buffer
.buf
+ 5, buffer
.len
- 6);
2055 get_sha1_hex(buffer
.buf
, sha1
);
2058 strbuf_release(&buffer
);
2061 static int verify_merge_base(unsigned char *head_sha1
, unsigned char *branch_sha1
)
2063 struct commit
*head
= lookup_commit(head_sha1
);
2064 struct commit
*branch
= lookup_commit(branch_sha1
);
2065 struct commit_list
*merge_bases
= get_merge_bases(head
, branch
, 1);
2067 return (merge_bases
&& !merge_bases
->next
&& merge_bases
->item
== branch
);
2070 static int delete_remote_branch(char *pattern
, int force
)
2072 struct ref
*refs
= remote_refs
;
2073 struct ref
*remote_ref
= NULL
;
2074 unsigned char head_sha1
[20];
2075 char *symref
= NULL
;
2077 int patlen
= strlen(pattern
);
2079 struct active_request_slot
*slot
;
2080 struct slot_results results
;
2083 /* Find the remote branch(es) matching the specified branch name */
2084 for (match
= 0; refs
; refs
= refs
->next
) {
2085 char *name
= refs
->name
;
2086 int namelen
= strlen(name
);
2087 if (namelen
< patlen
||
2088 memcmp(name
+ namelen
- patlen
, pattern
, patlen
))
2090 if (namelen
!= patlen
&& name
[namelen
- patlen
- 1] != '/')
2096 return error("No remote branch matches %s", pattern
);
2098 return error("More than one remote branch matches %s",
2102 * Remote HEAD must be a symref (not exactly foolproof; a remote
2103 * symlink to a symref will look like a symref)
2105 fetch_symref("HEAD", &symref
, head_sha1
);
2107 return error("Remote HEAD is not a symref");
2109 /* Remote branch must not be the remote HEAD */
2110 for (i
=0; symref
&& i
<MAXDEPTH
; i
++) {
2111 if (!strcmp(remote_ref
->name
, symref
))
2112 return error("Remote branch %s is the current HEAD",
2114 fetch_symref(symref
, &symref
, head_sha1
);
2117 /* Run extra sanity checks if delete is not forced */
2119 /* Remote HEAD must resolve to a known object */
2121 return error("Remote HEAD symrefs too deep");
2122 if (is_zero_sha1(head_sha1
))
2123 return error("Unable to resolve remote HEAD");
2124 if (!has_sha1_file(head_sha1
))
2125 return error("Remote HEAD resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", sha1_to_hex(head_sha1
));
2127 /* Remote branch must resolve to a known object */
2128 if (is_zero_sha1(remote_ref
->old_sha1
))
2129 return error("Unable to resolve remote branch %s",
2131 if (!has_sha1_file(remote_ref
->old_sha1
))
2132 return error("Remote branch %s resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", remote_ref
->name
, sha1_to_hex(remote_ref
->old_sha1
));
2134 /* Remote branch must be an ancestor of remote HEAD */
2135 if (!verify_merge_base(head_sha1
, remote_ref
->old_sha1
)) {
2136 return error("The branch '%s' is not an ancestor "
2137 "of your current HEAD.\n"
2138 "If you are sure you want to delete it,"
2139 " run:\n\t'git http-push -D %s %s'",
2140 remote_ref
->name
, remote
->url
, pattern
);
2144 /* Send delete request */
2145 fprintf(stderr
, "Removing remote branch '%s'\n", remote_ref
->name
);
2148 url
= xmalloc(strlen(remote
->url
) + strlen(remote_ref
->name
) + 1);
2149 sprintf(url
, "%s%s", remote
->url
, remote_ref
->name
);
2150 slot
= get_active_slot();
2151 slot
->results
= &results
;
2152 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPGET
, 1);
2153 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_null
);
2154 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, url
);
2155 curl_easy_setopt(slot
->curl
, CURLOPT_CUSTOMREQUEST
, DAV_DELETE
);
2156 if (start_active_slot(slot
)) {
2157 run_active_slot(slot
);
2159 if (results
.curl_result
!= CURLE_OK
)
2160 return error("DELETE request failed (%d/%ld)\n",
2161 results
.curl_result
, results
.http_code
);
2164 return error("Unable to start DELETE request");
2170 int main(int argc
, char **argv
)
2172 struct transfer_request
*request
;
2173 struct transfer_request
*next_request
;
2175 char **refspec
= NULL
;
2176 struct remote_lock
*ref_lock
= NULL
;
2177 struct remote_lock
*info_ref_lock
= NULL
;
2178 struct rev_info revs
;
2179 int delete_branch
= 0;
2180 int force_delete
= 0;
2181 int objects_to_send
;
2186 char *rewritten_url
= NULL
;
2188 setup_git_directory();
2190 remote
= xcalloc(sizeof(*remote
), 1);
2193 for (i
= 1; i
< argc
; i
++, argv
++) {
2197 if (!strcmp(arg
, "--all")) {
2198 push_all
= MATCH_REFS_ALL
;
2201 if (!strcmp(arg
, "--force")) {
2205 if (!strcmp(arg
, "--dry-run")) {
2209 if (!strcmp(arg
, "--verbose")) {
2213 if (!strcmp(arg
, "-d")) {
2217 if (!strcmp(arg
, "-D")) {
2224 char *path
= strstr(arg
, "//");
2226 remote
->path_len
= strlen(arg
);
2228 remote
->path
= strchr(path
+2, '/');
2230 remote
->path_len
= strlen(remote
->path
);
2235 nr_refspec
= argc
- i
;
2239 #ifndef USE_CURL_MULTI
2240 die("git-push is not available for http/https repository when not compiled with USE_CURL_MULTI");
2244 usage(http_push_usage
);
2246 if (delete_branch
&& nr_refspec
!= 1)
2247 die("You must specify only one branch name when deleting a remote branch");
2249 memset(remote_dir_exists
, -1, 256);
2253 no_pragma_header
= curl_slist_append(no_pragma_header
, "Pragma:");
2255 if (remote
->url
&& remote
->url
[strlen(remote
->url
)-1] != '/') {
2256 rewritten_url
= xmalloc(strlen(remote
->url
)+2);
2257 strcpy(rewritten_url
, remote
->url
);
2258 strcat(rewritten_url
, "/");
2259 remote
->path
= rewritten_url
+ (remote
->path
- remote
->url
);
2261 remote
->url
= rewritten_url
;
2264 /* Verify DAV compliance/lock support */
2265 if (!locking_available()) {
2270 signal(SIGINT
, remove_locks_on_signal
);
2271 signal(SIGHUP
, remove_locks_on_signal
);
2272 signal(SIGQUIT
, remove_locks_on_signal
);
2273 signal(SIGTERM
, remove_locks_on_signal
);
2275 /* Check whether the remote has server info files */
2276 remote
->can_update_info_refs
= 0;
2277 remote
->has_info_refs
= remote_exists("info/refs");
2278 remote
->has_info_packs
= remote_exists("objects/info/packs");
2279 if (remote
->has_info_refs
) {
2280 info_ref_lock
= lock_remote("info/refs", LOCK_TIME
);
2282 remote
->can_update_info_refs
= 1;
2284 fprintf(stderr
, "Error: cannot lock existing info/refs\n");
2289 if (remote
->has_info_packs
)
2292 /* Get a list of all local and remote heads to validate refspecs */
2294 fprintf(stderr
, "Fetching remote heads...\n");
2295 get_dav_remote_heads();
2297 /* Remove a remote branch if -d or -D was specified */
2298 if (delete_branch
) {
2299 if (delete_remote_branch(refspec
[0], force_delete
) == -1)
2300 fprintf(stderr
, "Unable to delete remote branch %s\n",
2307 remote_tail
= &remote_refs
;
2308 if (match_refs(local_refs
, remote_refs
, &remote_tail
,
2309 nr_refspec
, (const char **) refspec
, push_all
)) {
2314 fprintf(stderr
, "No refs in common and none specified; doing nothing.\n");
2320 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
2321 char old_hex
[60], *new_hex
;
2322 const char *commit_argv
[4];
2324 char *new_sha1_hex
, *old_sha1_hex
;
2329 if (is_zero_sha1(ref
->peer_ref
->new_sha1
)) {
2330 if (delete_remote_branch(ref
->name
, 1) == -1) {
2331 error("Could not remove %s", ref
->name
);
2338 if (!hashcmp(ref
->old_sha1
, ref
->peer_ref
->new_sha1
)) {
2339 if (push_verbosely
|| 1)
2340 fprintf(stderr
, "'%s': up-to-date\n", ref
->name
);
2345 !is_zero_sha1(ref
->old_sha1
) &&
2347 if (!has_sha1_file(ref
->old_sha1
) ||
2348 !ref_newer(ref
->peer_ref
->new_sha1
,
2351 * We do not have the remote ref, or
2352 * we know that the remote ref is not
2353 * an ancestor of what we are trying to
2354 * push. Either way this can be losing
2355 * commits at the remote end and likely
2356 * we were not up to date to begin with.
2358 error("remote '%s' is not an ancestor of\n"
2360 "Maybe you are not up-to-date and "
2361 "need to pull first?",
2363 ref
->peer_ref
->name
);
2368 hashcpy(ref
->new_sha1
, ref
->peer_ref
->new_sha1
);
2370 strcpy(old_hex
, sha1_to_hex(ref
->old_sha1
));
2371 new_hex
= sha1_to_hex(ref
->new_sha1
);
2373 fprintf(stderr
, "updating '%s'", ref
->name
);
2374 if (strcmp(ref
->name
, ref
->peer_ref
->name
))
2375 fprintf(stderr
, " using '%s'", ref
->peer_ref
->name
);
2376 fprintf(stderr
, "\n from %s\n to %s\n", old_hex
, new_hex
);
2380 /* Lock remote branch ref */
2381 ref_lock
= lock_remote(ref
->name
, LOCK_TIME
);
2382 if (ref_lock
== NULL
) {
2383 fprintf(stderr
, "Unable to lock remote branch %s\n",
2389 /* Set up revision info for this refspec */
2391 new_sha1_hex
= xstrdup(sha1_to_hex(ref
->new_sha1
));
2392 old_sha1_hex
= NULL
;
2393 commit_argv
[1] = "--objects";
2394 commit_argv
[2] = new_sha1_hex
;
2395 if (!push_all
&& !is_zero_sha1(ref
->old_sha1
)) {
2396 old_sha1_hex
= xmalloc(42);
2397 sprintf(old_sha1_hex
, "^%s",
2398 sha1_to_hex(ref
->old_sha1
));
2399 commit_argv
[3] = old_sha1_hex
;
2402 init_revisions(&revs
, setup_git_directory());
2403 setup_revisions(commit_argc
, commit_argv
, &revs
, NULL
);
2404 revs
.edge_hint
= 0; /* just in case */
2408 commit_argv
[1] = NULL
;
2411 /* Generate a list of objects that need to be pushed */
2413 if (prepare_revision_walk(&revs
))
2414 die("revision walk setup failed");
2415 mark_edges_uninteresting(revs
.commits
, &revs
, NULL
);
2416 objects_to_send
= get_delta(&revs
, ref_lock
);
2417 finish_all_active_slots();
2419 /* Push missing objects to remote, this would be a
2420 convenient time to pack them first if appropriate. */
2422 if (objects_to_send
)
2423 fprintf(stderr
, " sending %d objects\n",
2425 #ifdef USE_CURL_MULTI
2426 fill_active_slots();
2427 add_fill_function(NULL
, fill_active_slot
);
2430 finish_all_active_slots();
2431 #ifdef USE_CURL_MULTI
2432 fill_active_slots();
2434 } while (request_queue_head
&& !aborted
);
2436 /* Update the remote branch if all went well */
2437 if (aborted
|| !update_remote(ref
->new_sha1
, ref_lock
))
2441 fprintf(stderr
, " done\n");
2442 unlock_remote(ref_lock
);
2446 /* Update remote server info if appropriate */
2447 if (remote
->has_info_refs
&& new_refs
) {
2448 if (info_ref_lock
&& remote
->can_update_info_refs
) {
2449 fprintf(stderr
, "Updating remote server info\n");
2451 update_remote_info_refs(info_ref_lock
);
2453 fprintf(stderr
, "Unable to update server info\n");
2458 free(rewritten_url
);
2460 unlock_remote(info_ref_lock
);
2463 curl_slist_free_all(no_pragma_header
);
2467 request
= request_queue_head
;
2468 while (request
!= NULL
) {
2469 next_request
= request
->next
;
2470 release_request(request
);
2471 request
= next_request
;