@matheusbsbs / matheus-bagliano / commits / 58e60dd203
Fork 0

Add support for pushing to a remote repository using HTTP/DAV

Add support for pushing to a remote repository using HTTP/DAV Signed-off-by: Nick Hengeveld <nickh@reactrix.com> Signed-off-by: Junio C Hamano <junkio@cox.net>

Nick Hengeveld committed Nov 2, 2005 at 11:19 UTC 58e60dd203362ecb9fdea765dcc2eb573892dbaf
3 files changed +1725 -2
Documentation/git-http-push.txt new
+89
@@ -0,0 +1,89 @@
1 +git-http-push(1)
2 +================
3 +
4 +NAME
5 +----
6 +git-http-push - Push missing objects using HTTP/DAV.
7 +
8 +
9 +SYNOPSIS
10 +--------
11 +'git-http-push' [--complete] [--force] [--verbose] <url> <ref> [<ref>...]
12 +
13 +DESCRIPTION
14 +-----------
15 +Sends missing objects to remote repository, and updates the
16 +remote branch.
17 +
18 +
19 +OPTIONS
20 +-------
21 +--complete::
22 + Do not assume that the remote repository is complete in its
23 + current state, and verify all objects in the entire local
24 + ref's history exist in the remote repository.
25 +
26 +--force::
27 + Usually, the command refuses to update a remote ref that
28 + is not an ancestor of the local ref used to overwrite it.
29 + This flag disables the check. What this means is that
30 + the remote repository can lose commits; use it with
31 + care.
32 +
33 +--verbose::
34 + Report the list of objects being walked locally and the
35 + list of objects successfully sent to the remote repository.
36 +
37 +<ref>...:
38 + The remote refs to update.
39 +
40 +
41 +Specifying the Refs
42 +-------------------
43 +
44 +A '<ref>' specification can be either a single pattern, or a pair
45 +of such patterns separated by a colon ":" (this means that a ref name
46 +cannot have a colon in it). A single pattern '<name>' is just a
47 +shorthand for '<name>:<name>'.
48 +
49 +Each pattern pair consists of the source side (before the colon)
50 +and the destination side (after the colon). The ref to be
51 +pushed is determined by finding a match that matches the source
52 +side, and where it is pushed is determined by using the
53 +destination side.
54 +
55 + - It is an error if <src> does not match exactly one of the
56 + local refs.
57 +
58 + - If <dst> does not match any remote ref, either
59 +
60 + * it has to start with "refs/"; <dst> is used as the
61 + destination literally in this case.
62 +
63 + * <src> == <dst> and the ref that matched the <src> must not
64 + exist in the set of remote refs; the ref matched <src>
65 + locally is used as the name of the destination.
66 +
67 +Without '--force', the <src> ref is stored at the remote only if
68 +<dst> does not exist, or <dst> is a proper subset (i.e. an
69 +ancestor) of <src>. This check, known as "fast forward check",
70 +is performed in order to avoid accidentally overwriting the
71 +remote ref and lose other peoples' commits from there.
72 +
73 +With '--force', the fast forward check is disabled for all refs.
74 +
75 +Optionally, a <ref> parameter can be prefixed with a plus '+' sign
76 +to disable the fast-forward check only on that ref.
77 +
78 +
79 +Author
80 +------
81 +Written by Nick Hengeveld <nickh@reactrix.com>
82 +
83 +Documentation
84 +--------------
85 +Documentation by Nick Hengeveld
86 +
87 +GIT
88 +---
89 +Part of the gitlink:git[7] suite
Makefile
+11 -2
@@ -6,12 +6,16 @@
6 # Define NO_OPENSSL environment variable if you do not have OpenSSL. You will
7 # miss out git-rev-list --merge-order. This also implies MOZILLA_SHA1.
8 #
9 -# Define NO_CURL if you do not have curl installed. git-http-pull is not
10 -# built, and you cannot use http:// and https:// transports.
9 +# Define NO_CURL if you do not have curl installed. git-http-pull and
10 +# git-http-push are not built, and you cannot use http:// and https://
11 +# transports.
12 #
13 # Define CURLDIR=/foo/bar if your curl header and library files are in
14 # /foo/bar/include and /foo/bar/lib directories.
15 #
16 +# Define NO_EXPAT if you do not have expat installed. git-http-push is
17 +# not built, and you cannot push using http:// and https:// transports.
18 +#
19 # Define NO_STRCASESTR if you don't have strcasestr.
20 #
21 # Define PPC_SHA1 environment variable when running make to make use of
@@ -223,6 +227,10 @@ ifndef NO_CURL
227 CURL_LIBCURL = -lcurl
228 endif
229 PROGRAMS += git-http-fetch$X
230 + ifndef NO_EXPAT
231 + EXPAT_LIBEXPAT = -lexpat
232 + PROGRAMS += git-http-push$X
233 + endif
234 endif
235
236 ifndef SHELL_PATH
@@ -375,6 +383,7 @@ git-ssh-pull$X: rsh.o fetch.o
383 git-ssh-push$X: rsh.o
384
385 git-http-fetch$X: LIBS += $(CURL_LIBCURL)
386 +git-http-push$X: LIBS += $(CURL_LIBCURL) $(EXPAT_LIBEXPAT)
387 git-rev-list$X: LIBS += $(OPENSSL_LIBSSL)
388
389 init-db.o: init-db.c
http-push.c new
+1625
@@ -0,0 +1,1625 @@
1 +#include "cache.h"
2 +#include "commit.h"
3 +#include "pack.h"
4 +#include "fetch.h"
5 +#include "tag.h"
6 +#include "blob.h"
7 +
8 +#include <curl/curl.h>
9 +#include <curl/easy.h>
10 +#include "expat.h"
11 +
12 +static const char http_push_usage[] =
13 +"git-http-push [--complete] [--force] [--verbose] <url> <ref> [<ref>...]\n";
14 +
15 +#if LIBCURL_VERSION_NUM >= 0x070908
16 +#define USE_CURL_MULTI
17 +#define DEFAULT_MAX_REQUESTS 5
18 +#endif
19 +
20 +#if LIBCURL_VERSION_NUM < 0x070704
21 +#define curl_global_cleanup() do { /* nothing */ } while(0)
22 +#endif
23 +#if LIBCURL_VERSION_NUM < 0x070800
24 +#define curl_global_init(a) do { /* nothing */ } while(0)
25 +#endif
26 +
27 +#if LIBCURL_VERSION_NUM < 0x070c04
28 +#define NO_CURL_EASY_DUPHANDLE
29 +#endif
30 +
31 +#define RANGE_HEADER_SIZE 30
32 +
33 +/* DAV method names and request body templates */
34 +#define DAV_LOCK "LOCK"
35 +#define DAV_MKCOL "MKCOL"
36 +#define DAV_MOVE "MOVE"
37 +#define DAV_PROPFIND "PROPFIND"
38 +#define DAV_PUT "PUT"
39 +#define DAV_UNLOCK "UNLOCK"
40 +#define PROPFIND_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>"
41 +#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>"
42 +
43 +static int active_requests = 0;
44 +static int data_received;
45 +static int pushing = 0;
46 +static int aborted = 0;
47 +
48 +#ifdef USE_CURL_MULTI
49 +static int max_requests = -1;
50 +static CURLM *curlm;
51 +#endif
52 +#ifndef NO_CURL_EASY_DUPHANDLE
53 +static CURL *curl_default;
54 +#endif
55 +static struct curl_slist *no_pragma_header;
56 +static struct curl_slist *default_headers;
57 +static char curl_errorstr[CURL_ERROR_SIZE];
58 +static char *lock_token = NULL;
59 +
60 +static int push_verbosely = 0;
61 +static int push_all = 0;
62 +static int force_all = 0;
63 +
64 +struct buffer
65 +{
66 + size_t posn;
67 + size_t size;
68 + void *buffer;
69 +};
70 +
71 +struct repo
72 +{
73 + char *url;
74 + struct packed_git *packs;
75 +};
76 +
77 +static struct repo *remote = NULL;
78 +
79 +enum transfer_state {
80 + NEED_CHECK,
81 + RUN_HEAD,
82 + NEED_PUSH,
83 + RUN_MKCOL,
84 + RUN_PUT,
85 + RUN_MOVE,
86 + ABORTED,
87 + COMPLETE,
88 +};
89 +
90 +struct transfer_request
91 +{
92 + unsigned char sha1[20];
93 + char *url;
94 + char *dest;
95 + char *lock_token;
96 + struct curl_slist *headers;
97 + struct buffer buffer;
98 + char filename[PATH_MAX];
99 + char tmpfile[PATH_MAX];
100 + enum transfer_state state;
101 + CURLcode curl_result;
102 + char errorstr[CURL_ERROR_SIZE];
103 + long http_code;
104 + unsigned char real_sha1[20];
105 + SHA_CTX c;
106 + z_stream stream;
107 + int zret;
108 + int rename;
109 + struct active_request_slot *slot;
110 + struct transfer_request *next;
111 +};
112 +
113 +struct active_request_slot
114 +{
115 + CURL *curl;
116 + FILE *local;
117 + int in_use;
118 + int done;
119 + CURLcode curl_result;
120 + long http_code;
121 + struct active_request_slot *next;
122 +};
123 +
124 +static struct transfer_request *request_queue_head = NULL;
125 +static struct active_request_slot *active_queue_head = NULL;
126 +
127 +static int curl_ssl_verify = -1;
128 +static char *ssl_cert = NULL;
129 +#if LIBCURL_VERSION_NUM >= 0x070902
130 +static char *ssl_key = NULL;
131 +#endif
132 +#if LIBCURL_VERSION_NUM >= 0x070908
133 +static char *ssl_capath = NULL;
134 +#endif
135 +static char *ssl_cainfo = NULL;
136 +static long curl_low_speed_limit = -1;
137 +static long curl_low_speed_time = -1;
138 +
139 +struct lockprop
140 +{
141 + int supported_lock;
142 + int lock_entry;
143 + int lock_scope;
144 + int lock_type;
145 + int lock_exclusive;
146 + int lock_exclusive_write;
147 +};
148 +
149 +static int http_options(const char *var, const char *value)
150 +{
151 + if (!strcmp("http.sslverify", var)) {
152 + if (curl_ssl_verify == -1) {
153 + curl_ssl_verify = git_config_bool(var, value);
154 + }
155 + return 0;
156 + }
157 +
158 + if (!strcmp("http.sslcert", var)) {
159 + if (ssl_cert == NULL) {
160 + ssl_cert = xmalloc(strlen(value)+1);
161 + strcpy(ssl_cert, value);
162 + }
163 + return 0;
164 + }
165 +#if LIBCURL_VERSION_NUM >= 0x070902
166 + if (!strcmp("http.sslkey", var)) {
167 + if (ssl_key == NULL) {
168 + ssl_key = xmalloc(strlen(value)+1);
169 + strcpy(ssl_key, value);
170 + }
171 + return 0;
172 + }
173 +#endif
174 +#if LIBCURL_VERSION_NUM >= 0x070908
175 + if (!strcmp("http.sslcapath", var)) {
176 + if (ssl_capath == NULL) {
177 + ssl_capath = xmalloc(strlen(value)+1);
178 + strcpy(ssl_capath, value);
179 + }
180 + return 0;
181 + }
182 +#endif
183 + if (!strcmp("http.sslcainfo", var)) {
184 + if (ssl_cainfo == NULL) {
185 + ssl_cainfo = xmalloc(strlen(value)+1);
186 + strcpy(ssl_cainfo, value);
187 + }
188 + return 0;
189 + }
190 +
191 +#ifdef USE_CURL_MULTI
192 + if (!strcmp("http.maxrequests", var)) {
193 + if (max_requests == -1)
194 + max_requests = git_config_int(var, value);
195 + return 0;
196 + }
197 +#endif
198 +
199 + if (!strcmp("http.lowspeedlimit", var)) {
200 + if (curl_low_speed_limit == -1)
201 + curl_low_speed_limit = (long)git_config_int(var, value);
202 + return 0;
203 + }
204 + if (!strcmp("http.lowspeedtime", var)) {
205 + if (curl_low_speed_time == -1)
206 + curl_low_speed_time = (long)git_config_int(var, value);
207 + return 0;
208 + }
209 +
210 + /* Fall back on the default ones */
211 + return git_default_config(var, value);
212 +}
213 +
214 +static size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb,
215 + struct buffer *buffer)
216 +{
217 + size_t size = eltsize * nmemb;
218 + if (size > buffer->size - buffer->posn)
219 + size = buffer->size - buffer->posn;
220 + memcpy(ptr, buffer->buffer + buffer->posn, size);
221 + buffer->posn += size;
222 + return size;
223 +}
224 +
225 +static size_t fwrite_buffer_dynamic(const void *ptr, size_t eltsize,
226 + size_t nmemb, struct buffer *buffer)
227 +{
228 + size_t size = eltsize * nmemb;
229 + if (size > buffer->size - buffer->posn) {
230 + buffer->size = buffer->size * 3 / 2;
231 + if (buffer->size < buffer->posn + size)
232 + buffer->size = buffer->posn + size;
233 + buffer->buffer = xrealloc(buffer->buffer, buffer->size);
234 + }
235 + memcpy(buffer->buffer + buffer->posn, ptr, size);
236 + buffer->posn += size;
237 + data_received++;
238 + return size;
239 +}
240 +
241 +static size_t fwrite_null(const void *ptr, size_t eltsize,
242 + size_t nmemb, struct buffer *buffer)
243 +{
244 + data_received++;
245 + return eltsize * nmemb;
246 +}
247 +
248 +#ifdef USE_CURL_MULTI
249 +static void process_curl_messages(void);
250 +static void process_request_queue(void);
251 +#endif
252 +
253 +static CURL* get_curl_handle(void)
254 +{
255 + CURL* result = curl_easy_init();
256 +
257 + curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, curl_ssl_verify);
258 +#if LIBCURL_VERSION_NUM >= 0x070907
259 + curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
260 +#endif
261 +
262 + if (ssl_cert != NULL)
263 + curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert);
264 +#if LIBCURL_VERSION_NUM >= 0x070902
265 + if (ssl_key != NULL)
266 + curl_easy_setopt(result, CURLOPT_SSLKEY, ssl_key);
267 +#endif
268 +#if LIBCURL_VERSION_NUM >= 0x070908
269 + if (ssl_capath != NULL)
270 + curl_easy_setopt(result, CURLOPT_CAPATH, ssl_capath);
271 +#endif
272 + if (ssl_cainfo != NULL)
273 + curl_easy_setopt(result, CURLOPT_CAINFO, ssl_cainfo);
274 + curl_easy_setopt(result, CURLOPT_FAILONERROR, 1);
275 +
276 + if (curl_low_speed_limit > 0 && curl_low_speed_time > 0) {
277 + curl_easy_setopt(result, CURLOPT_LOW_SPEED_LIMIT,
278 + curl_low_speed_limit);
279 + curl_easy_setopt(result, CURLOPT_LOW_SPEED_TIME,
280 + curl_low_speed_time);
281 + }
282 +
283 + return result;
284 +}
285 +
286 +static struct active_request_slot *get_active_slot(void)
287 +{
288 + struct active_request_slot *slot = active_queue_head;
289 + struct active_request_slot *newslot;
290 +
291 +#ifdef USE_CURL_MULTI
292 + int num_transfers;
293 +
294 + /* Wait for a slot to open up if the queue is full */
295 + while (active_requests >= max_requests) {
296 + curl_multi_perform(curlm, &num_transfers);
297 + if (num_transfers < active_requests) {
298 + process_curl_messages();
299 + }
300 + }
301 +#endif
302 +
303 + while (slot != NULL && slot->in_use) {
304 + slot = slot->next;
305 + }
306 + if (slot == NULL) {
307 + newslot = xmalloc(sizeof(*newslot));
308 + newslot->curl = NULL;
309 + newslot->in_use = 0;
310 + newslot->next = NULL;
311 +
312 + slot = active_queue_head;
313 + if (slot == NULL) {
314 + active_queue_head = newslot;
315 + } else {
316 + while (slot->next != NULL) {
317 + slot = slot->next;
318 + }
319 + slot->next = newslot;
320 + }
321 + slot = newslot;
322 + }
323 +
324 + if (slot->curl == NULL) {
325 +#ifdef NO_CURL_EASY_DUPHANDLE
326 + slot->curl = get_curl_handle();
327 +#else
328 + slot->curl = curl_easy_duphandle(curl_default);
329 +#endif
330 + }
331 +
332 + active_requests++;
333 + slot->in_use = 1;
334 + slot->done = 0;
335 + slot->local = NULL;
336 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, default_headers);
337 + curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, curl_errorstr);
338 +
339 + return slot;
340 +}
341 +
342 +static int start_active_slot(struct active_request_slot *slot)
343 +{
344 +#ifdef USE_CURL_MULTI
345 + CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl);
346 +
347 + if (curlm_result != CURLM_OK &&
348 + curlm_result != CURLM_CALL_MULTI_PERFORM) {
349 + active_requests--;
350 + slot->in_use = 0;
351 + return 0;
352 + }
353 +#endif
354 + return 1;
355 +}
356 +
357 +static void run_active_slot(struct active_request_slot *slot)
358 +{
359 +#ifdef USE_CURL_MULTI
360 + int num_transfers;
361 + long last_pos = 0;
362 + long current_pos;
363 + fd_set readfds;
364 + fd_set writefds;
365 + fd_set excfds;
366 + int max_fd;
367 + struct timeval select_timeout;
368 + CURLMcode curlm_result;
369 +
370 + while (!slot->done) {
371 + data_received = 0;
372 + do {
373 + curlm_result = curl_multi_perform(curlm,
374 + &num_transfers);
375 + } while (curlm_result == CURLM_CALL_MULTI_PERFORM);
376 + if (num_transfers < active_requests) {
377 + process_curl_messages();
378 + process_request_queue();
379 + }
380 +
381 + if (!data_received && slot->local != NULL) {
382 + current_pos = ftell(slot->local);
383 + if (current_pos > last_pos)
384 + data_received++;
385 + last_pos = current_pos;
386 + }
387 +
388 + if (!slot->done && !data_received) {
389 + max_fd = 0;
390 + FD_ZERO(&readfds);
391 + FD_ZERO(&writefds);
392 + FD_ZERO(&excfds);
393 + select_timeout.tv_sec = 0;
394 + select_timeout.tv_usec = 50000;
395 + select(max_fd, &readfds, &writefds,
396 + &excfds, &select_timeout);
397 + }
398 + }
399 +#else
400 + slot->curl_result = curl_easy_perform(slot->curl);
401 + active_requests--;
402 +#endif
403 +}
404 +
405 +static void start_check(struct transfer_request *request)
406 +{
407 + char *hex = sha1_to_hex(request->sha1);
408 + struct active_request_slot *slot;
409 + char *posn;
410 +
411 + request->url = xmalloc(strlen(remote->url) + 55);
412 + strcpy(request->url, remote->url);
413 + posn = request->url + strlen(remote->url);
414 + strcpy(posn, "objects/");
415 + posn += 8;
416 + memcpy(posn, hex, 2);
417 + posn += 2;
418 + *(posn++) = '/';
419 + strcpy(posn, hex + 2);
420 +
421 + slot = get_active_slot();
422 + curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
423 + curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
424 + curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
425 +
426 + if (start_active_slot(slot)) {
427 + request->slot = slot;
428 + request->state = RUN_HEAD;
429 + } else {
430 + request->state = ABORTED;
431 + free(request->url);
432 + }
433 +}
434 +
435 +static void start_mkcol(struct transfer_request *request)
436 +{
437 + char *hex = sha1_to_hex(request->sha1);
438 + struct active_request_slot *slot;
439 + char *posn;
440 +
441 + request->url = xmalloc(strlen(remote->url) + 13);
442 + strcpy(request->url, remote->url);
443 + posn = request->url + strlen(remote->url);
444 + strcpy(posn, "objects/");
445 + posn += 8;
446 + memcpy(posn, hex, 2);
447 + posn += 2;
448 + strcpy(posn, "/");
449 +
450 + slot = get_active_slot();
451 + curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
452 + curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
453 + curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
454 + curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MKCOL);
455 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
456 +
457 + if (start_active_slot(slot)) {
458 + request->slot = slot;
459 + request->state = RUN_MKCOL;
460 + } else {
461 + request->state = ABORTED;
462 + free(request->url);
463 + }
464 +}
465 +
466 +static void start_put(struct transfer_request *request)
467 +{
468 + char *hex = sha1_to_hex(request->sha1);
469 + struct active_request_slot *slot;
470 + char *posn;
471 + char type[20];
472 + char hdr[50];
473 + void *unpacked;
474 + unsigned long len;
475 + int hdrlen;
476 + ssize_t size;
477 + z_stream stream;
478 +
479 + unpacked = read_sha1_file(request->sha1, type, &len);
480 + hdrlen = sprintf(hdr, "%s %lu", type, len) + 1;
481 +
482 + /* Set it up */
483 + memset(&stream, 0, sizeof(stream));
484 + deflateInit(&stream, Z_BEST_COMPRESSION);
485 + size = deflateBound(&stream, len + hdrlen);
486 + request->buffer.buffer = xmalloc(size);
487 +
488 + /* Compress it */
489 + stream.next_out = request->buffer.buffer;
490 + stream.avail_out = size;
491 +
492 + /* First header.. */
493 + stream.next_in = (void *)hdr;
494 + stream.avail_in = hdrlen;
495 + while (deflate(&stream, 0) == Z_OK)
496 + /* nothing */;
497 +
498 + /* Then the data itself.. */
499 + stream.next_in = unpacked;
500 + stream.avail_in = len;
501 + while (deflate(&stream, Z_FINISH) == Z_OK)
502 + /* nothing */;
503 + deflateEnd(&stream);
504 + free(unpacked);
505 +
506 + request->buffer.size = stream.total_out;
507 + request->buffer.posn = 0;
508 +
509 + if (request->url != NULL)
510 + free(request->url);
511 + request->url = xmalloc(strlen(remote->url) +
512 + strlen(request->lock_token) + 51);
513 + strcpy(request->url, remote->url);
514 + posn = request->url + strlen(remote->url);
515 + strcpy(posn, "objects/");
516 + posn += 8;
517 + memcpy(posn, hex, 2);
518 + posn += 2;
519 + *(posn++) = '/';
520 + strcpy(posn, hex + 2);
521 + request->dest = xmalloc(strlen(request->url) + 14);
522 + sprintf(request->dest, "Destination: %s", request->url);
523 + posn += 38;
524 + *(posn++) = '.';
525 + strcpy(posn, request->lock_token);
526 +
527 + slot = get_active_slot();
528 + curl_easy_setopt(slot->curl, CURLOPT_INFILE, &request->buffer);
529 + curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, request->buffer.size);
530 + curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
531 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
532 + curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
533 + curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
534 + curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
535 + curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
536 + curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
537 +
538 + if (start_active_slot(slot)) {
539 + request->slot = slot;
540 + request->state = RUN_PUT;
541 + } else {
542 + request->state = ABORTED;
543 + free(request->url);
544 + }
545 +}
546 +
547 +static void start_move(struct transfer_request *request)
548 +{
549 + struct active_request_slot *slot;
550 + struct curl_slist *dav_headers = NULL;
551 +
552 + slot = get_active_slot();
553 + curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
554 + curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MOVE);
555 + dav_headers = curl_slist_append(dav_headers, request->dest);
556 + dav_headers = curl_slist_append(dav_headers, "Overwrite: T");
557 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
558 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
559 + curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
560 +
561 + if (start_active_slot(slot)) {
562 + request->slot = slot;
563 + request->state = RUN_MOVE;
564 + } else {
565 + request->state = ABORTED;
566 + free(request->url);
567 + }
568 +}
569 +
570 +static void finish_request(struct transfer_request *request)
571 +{
572 + request->curl_result = request->slot->curl_result;
573 + request->http_code = request->slot->http_code;
574 + request->slot = NULL;
575 + if (request->headers != NULL)
576 + curl_slist_free_all(request->headers);
577 + if (request->state == RUN_HEAD) {
578 + if (request->http_code == 404) {
579 + request->state = NEED_PUSH;
580 + } else if (request->curl_result == CURLE_OK) {
581 + request->state = COMPLETE;
582 + } else {
583 + fprintf(stderr, "HEAD %s failed, aborting (%d/%ld)\n",
584 + sha1_to_hex(request->sha1),
585 + request->curl_result, request->http_code);
586 + request->state = ABORTED;
587 + aborted = 1;
588 + }
589 + } else if (request->state == RUN_MKCOL) {
590 + if (request->curl_result == CURLE_OK ||
591 + request->http_code == 405) {
592 + start_put(request);
593 + } else {
594 + fprintf(stderr, "MKCOL %s failed, aborting (%d/%ld)\n",
595 + sha1_to_hex(request->sha1),
596 + request->curl_result, request->http_code);
597 + request->state = ABORTED;
598 + aborted = 1;
599 + }
600 + } else if (request->state == RUN_PUT) {
601 + if (request->curl_result == CURLE_OK) {
602 + start_move(request);
603 + } else {
604 + fprintf(stderr, "PUT %s failed, aborting (%d/%ld)\n",
605 + sha1_to_hex(request->sha1),
606 + request->curl_result, request->http_code);
607 + request->state = ABORTED;
608 + aborted = 1;
609 + }
610 + } else if (request->state == RUN_MOVE) {
611 + if (request->curl_result == CURLE_OK) {
612 + if (push_verbosely)
613 + fprintf(stderr,
614 + "sent %s\n",
615 + sha1_to_hex(request->sha1));
616 + request->state = COMPLETE;
617 + } else {
618 + fprintf(stderr, "MOVE %s failed, aborting (%d/%ld)\n",
619 + sha1_to_hex(request->sha1),
620 + request->curl_result, request->http_code);
621 + request->state = ABORTED;
622 + aborted = 1;
623 + }
624 + }
625 +}
626 +
627 +static void release_request(struct transfer_request *request)
628 +{
629 + struct transfer_request *entry = request_queue_head;
630 +
631 + if (request == request_queue_head) {
632 + request_queue_head = request->next;
633 + } else {
634 + while (entry->next != NULL && entry->next != request)
635 + entry = entry->next;
636 + if (entry->next == request)
637 + entry->next = entry->next->next;
638 + }
639 +
640 + free(request->url);
641 + free(request);
642 +}
643 +
644 +#ifdef USE_CURL_MULTI
645 +void process_curl_messages(void)
646 +{
647 + int num_messages;
648 + struct active_request_slot *slot;
649 + struct transfer_request *request = NULL;
650 + CURLMsg *curl_message = curl_multi_info_read(curlm, &num_messages);
651 +
652 + while (curl_message != NULL) {
653 + if (curl_message->msg == CURLMSG_DONE) {
654 + slot = active_queue_head;
655 + while (slot != NULL &&
656 + slot->curl != curl_message->easy_handle)
657 + slot = slot->next;
658 + if (slot != NULL) {
659 + curl_multi_remove_handle(curlm, slot->curl);
660 + active_requests--;
661 + slot->done = 1;
662 + slot->in_use = 0;
663 + slot->curl_result = curl_message->data.result;
664 + curl_easy_getinfo(slot->curl,
665 + CURLINFO_HTTP_CODE,
666 + &slot->http_code);
667 + request = request_queue_head;
668 + while (request != NULL &&
669 + request->slot != slot)
670 + request = request->next;
671 + if (request != NULL)
672 + finish_request(request);
673 + } else {
674 + fprintf(stderr, "Received DONE message for unknown request!\n");
675 + }
676 + } else {
677 + fprintf(stderr, "Unknown CURL message received: %d\n",
678 + (int)curl_message->msg);
679 + }
680 + curl_message = curl_multi_info_read(curlm, &num_messages);
681 + }
682 +}
683 +
684 +void process_request_queue(void)
685 +{
686 + struct transfer_request *request = request_queue_head;
687 + struct active_request_slot *slot = active_queue_head;
688 + int num_transfers;
689 +
690 + if (aborted)
691 + return;
692 +
693 + while (active_requests < max_requests && request != NULL) {
694 + if (!pushing && request->state == NEED_CHECK) {
695 + start_check(request);
696 + curl_multi_perform(curlm, &num_transfers);
697 + } else if (pushing && request->state == NEED_PUSH) {
698 + start_mkcol(request);
699 + curl_multi_perform(curlm, &num_transfers);
700 + }
701 + request = request->next;
702 + }
703 +
704 + while (slot != NULL) {
705 + if (!slot->in_use && slot->curl != NULL) {
706 + curl_easy_cleanup(slot->curl);
707 + slot->curl = NULL;
708 + }
709 + slot = slot->next;
710 + }
711 +}
712 +#endif
713 +
714 +void process_waiting_requests(void)
715 +{
716 + struct active_request_slot *slot = active_queue_head;
717 +
718 + while (slot != NULL)
719 + if (slot->in_use) {
720 + run_active_slot(slot);
721 + slot = active_queue_head;
722 + } else {
723 + slot = slot->next;
724 + }
725 +}
726 +
727 +void add_request(unsigned char *sha1, char *lock_token)
728 +{
729 + struct transfer_request *request = request_queue_head;
730 + struct transfer_request *tail;
731 + struct packed_git *target;
732 +
733 + while (request != NULL && memcmp(request->sha1, sha1, 20))
734 + request = request->next;
735 + if (request != NULL)
736 + return;
737 +
738 + target = find_sha1_pack(sha1, remote->packs);
739 + if (target)
740 + return;
741 +
742 + request = xmalloc(sizeof(*request));
743 + memcpy(request->sha1, sha1, 20);
744 + request->url = NULL;
745 + request->lock_token = lock_token;
746 + request->headers = NULL;
747 + request->state = NEED_CHECK;
748 + request->next = NULL;
749 +
750 + if (request_queue_head == NULL) {
751 + request_queue_head = request;
752 + } else {
753 + tail = request_queue_head;
754 + while (tail->next != NULL) {
755 + tail = tail->next;
756 + }
757 + tail->next = request;
758 + }
759 +#ifdef USE_CURL_MULTI
760 + process_request_queue();
761 + process_curl_messages();
762 +#endif
763 +}
764 +
765 +static int fetch_index(unsigned char *sha1)
766 +{
767 + char *hex = sha1_to_hex(sha1);
768 + char *filename;
769 + char *url;
770 + char tmpfile[PATH_MAX];
771 + long prev_posn = 0;
772 + char range[RANGE_HEADER_SIZE];
773 + struct curl_slist *range_header = NULL;
774 +
775 + FILE *indexfile;
776 + struct active_request_slot *slot;
777 +
778 + if (has_pack_index(sha1))
779 + return 0;
780 +
781 + if (push_verbosely)
782 + fprintf(stderr, "Getting index for pack %s\n", hex);
783 +
784 + url = xmalloc(strlen(remote->url) + 64);
785 + sprintf(url, "%s/objects/pack/pack-%s.idx", remote->url, hex);
786 +
787 + filename = sha1_pack_index_name(sha1);
788 + snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
789 + indexfile = fopen(tmpfile, "a");
790 + if (!indexfile)
791 + return error("Unable to open local file %s for pack index",
792 + filename);
793 +
794 + slot = get_active_slot();
795 + curl_easy_setopt(slot->curl, CURLOPT_FILE, indexfile);
796 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
797 + curl_easy_setopt(slot->curl, CURLOPT_URL, url);
798 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
799 + slot->local = indexfile;
800 +
801 + /* If there is data present from a previous transfer attempt,
802 + resume where it left off */
803 + prev_posn = ftell(indexfile);
804 + if (prev_posn>0) {
805 + if (push_verbosely)
806 + fprintf(stderr,
807 + "Resuming fetch of index for pack %s at byte %ld\n",
808 + hex, prev_posn);
809 + sprintf(range, "Range: bytes=%ld-", prev_posn);
810 + range_header = curl_slist_append(range_header, range);
811 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
812 + }
813 +
814 + if (start_active_slot(slot)) {
815 + run_active_slot(slot);
816 + if (slot->curl_result != CURLE_OK) {
817 + free(url);
818 + fclose(indexfile);
819 + return error("Unable to get pack index %s\n%s", url,
820 + curl_errorstr);
821 + }
822 + } else {
823 + free(url);
824 + return error("Unable to start request");
825 + }
826 +
827 + free(url);
828 + fclose(indexfile);
829 +
830 + return move_temp_to_file(tmpfile, filename);
831 +}
832 +
833 +static int setup_index(unsigned char *sha1)
834 +{
835 + struct packed_git *new_pack;
836 + if (has_pack_file(sha1))
837 + return 0; // don't list this as something we can get
838 +
839 + if (fetch_index(sha1))
840 + return -1;
841 +
842 + new_pack = parse_pack_index(sha1);
843 + new_pack->next = remote->packs;
844 + remote->packs = new_pack;
845 + return 0;
846 +}
847 +
848 +static int fetch_indices()
849 +{
850 + unsigned char sha1[20];
851 + char *url;
852 + struct buffer buffer;
853 + char *data;
854 + int i = 0;
855 +
856 + struct active_request_slot *slot;
857 +
858 + data = xmalloc(4096);
859 + memset(data, 0, 4096);
860 + buffer.size = 4096;
861 + buffer.posn = 0;
862 + buffer.buffer = data;
863 +
864 + if (push_verbosely)
865 + fprintf(stderr, "Getting pack list\n");
866 +
867 + url = xmalloc(strlen(remote->url) + 21);
868 + sprintf(url, "%s/objects/info/packs", remote->url);
869 +
870 + slot = get_active_slot();
871 + curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
872 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
873 + fwrite_buffer_dynamic);
874 + curl_easy_setopt(slot->curl, CURLOPT_URL, url);
875 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
876 + if (start_active_slot(slot)) {
877 + run_active_slot(slot);
878 + if (slot->curl_result != CURLE_OK) {
879 + free(buffer.buffer);
880 + free(url);
881 + if (slot->http_code == 404)
882 + return 0;
883 + else
884 + return error("%s", curl_errorstr);
885 + }
886 + } else {
887 + free(buffer.buffer);
888 + free(url);
889 + return error("Unable to start request");
890 + }
891 + free(url);
892 +
893 + data = buffer.buffer;
894 + while (i < buffer.posn) {
895 + switch (data[i]) {
896 + case 'P':
897 + i++;
898 + if (i + 52 < buffer.posn &&
899 + !strncmp(data + i, " pack-", 6) &&
900 + !strncmp(data + i + 46, ".pack\n", 6)) {
901 + get_sha1_hex(data + i + 6, sha1);
902 + setup_index(sha1);
903 + i += 51;
904 + break;
905 + }
906 + default:
907 + while (data[i] != '\n')
908 + i++;
909 + }
910 + i++;
911 + }
912 +
913 + free(buffer.buffer);
914 + return 0;
915 +}
916 +
917 +static inline int needs_quote(int ch)
918 +{
919 + switch (ch) {
920 + case '/': case '-': case '.':
921 + case 'A'...'Z': case 'a'...'z': case '0'...'9':
922 + return 0;
923 + default:
924 + return 1;
925 + }
926 +}
927 +
928 +static inline int hex(int v)
929 +{
930 + if (v < 10) return '0' + v;
931 + else return 'A' + v - 10;
932 +}
933 +
934 +static char *quote_ref_url(const char *base, const char *ref)
935 +{
936 + const char *cp;
937 + char *dp, *qref;
938 + int len, baselen, ch;
939 +
940 + baselen = strlen(base);
941 + len = baselen + 12; /* "refs/heads/" + NUL */
942 + for (cp = ref; (ch = *cp) != 0; cp++, len++)
943 + if (needs_quote(ch))
944 + len += 2; /* extra two hex plus replacement % */
945 + qref = xmalloc(len);
946 + memcpy(qref, base, baselen);
947 + memcpy(qref + baselen, "refs/heads/", 11);
948 + for (cp = ref, dp = qref + baselen + 11; (ch = *cp) != 0; cp++) {
949 + if (needs_quote(ch)) {
950 + *dp++ = '%';
951 + *dp++ = hex((ch >> 4) & 0xF);
952 + *dp++ = hex(ch & 0xF);
953 + }
954 + else
955 + *dp++ = ch;
956 + }
957 + *dp = 0;
958 +
959 + return qref;
960 +}
961 +
962 +int fetch_ref(char *ref, unsigned char *sha1)
963 +{
964 + char *url;
965 + char hex[42];
966 + struct buffer buffer;
967 + char *base = remote->url;
968 + struct active_request_slot *slot;
969 + buffer.size = 41;
970 + buffer.posn = 0;
971 + buffer.buffer = hex;
972 + hex[41] = '\0';
973 +
974 + url = quote_ref_url(base, ref);
975 + slot = get_active_slot();
976 + curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
977 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
978 + fwrite_buffer_dynamic);
979 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
980 + curl_easy_setopt(slot->curl, CURLOPT_URL, url);
981 + if (start_active_slot(slot)) {
982 + run_active_slot(slot);
983 + if (slot->curl_result != CURLE_OK)
984 + return error("Couldn't get %s for %s\n%s",
985 + url, ref, curl_errorstr);
986 + } else {
987 + return error("Unable to start request");
988 + }
989 +
990 + hex[40] = '\0';
991 + get_sha1_hex(hex, sha1);
992 + return 0;
993 +}
994 +
995 +static void
996 +start_lockprop_element(void *userData, const char *name, const char **atts)
997 +{
998 + struct lockprop *prop = (struct lockprop *)userData;
999 +
1000 + if (prop->lock_type && !strcmp(name, "D:write")) {
1001 + if (prop->lock_exclusive) {
1002 + prop->lock_exclusive_write = 1;
1003 + }
1004 + } else if (prop->lock_scope && !strcmp(name, "D:exclusive")) {
1005 + prop->lock_exclusive = 1;
1006 + } else if (prop->lock_entry) {
1007 + if (!strcmp(name, "D:lockscope")) {
1008 + prop->lock_scope = 1;
1009 + } else if (!strcmp(name, "D:locktype")) {
1010 + prop->lock_type = 1;
1011 + }
1012 + } else if (prop->supported_lock) {
1013 + if (!strcmp(name, "D:lockentry")) {
1014 + prop->lock_entry = 1;
1015 + }
1016 + } else if (!strcmp(name, "D:supportedlock")) {
1017 + prop->supported_lock = 1;
1018 + }
1019 +}
1020 +
1021 +static void
1022 +end_lockprop_element(void *userData, const char *name)
1023 +{
1024 + struct lockprop *prop = (struct lockprop *)userData;
1025 +
1026 + if (!strcmp(name, "D:lockentry")) {
1027 + prop->lock_entry = 0;
1028 + prop->lock_scope = 0;
1029 + prop->lock_type = 0;
1030 + prop->lock_exclusive = 0;
1031 + } else if (!strcmp(name, "D:supportedlock")) {
1032 + prop->supported_lock = 0;
1033 + }
1034 +}
1035 +
1036 +size_t process_lock_header( void *ptr, size_t size, size_t nmemb, void *stream)
1037 +{
1038 + size_t header_size = size*nmemb;
1039 + char *start;
1040 + char *end;
1041 +
1042 + if (!strncmp(ptr, "Lock-Token: <opaquelocktoken:", 29)) {
1043 + start = ptr + 29;
1044 + for (end = ptr + header_size;
1045 + *(end - 1) == '\r' || *(end - 1) == '\n' || *(end - 1) == '>';
1046 + end--) {}
1047 + if (end > start) {
1048 + lock_token = xmalloc(end - start + 1);
1049 + memcpy(lock_token, start, end - start);
1050 + lock_token[end - start] = 0;
1051 + }
1052 + }
1053 +
1054 + return header_size;
1055 +}
1056 +
1057 +char *lock_remote(char *file, int timeout)
1058 +{
1059 + struct active_request_slot *slot;
1060 + struct buffer out_buffer;
1061 + char *out_data;
1062 + char *url;
1063 + char timeout_header[25];
1064 + struct curl_slist *dav_headers = NULL;
1065 +
1066 + if (lock_token != NULL)
1067 + free(lock_token);
1068 +
1069 + out_buffer.size = strlen(LOCK_REQUEST) + strlen(git_default_email) - 2;
1070 + out_data = xmalloc(out_buffer.size + 1);
1071 + snprintf(out_data, out_buffer.size + 1, LOCK_REQUEST, git_default_email);
1072 + out_buffer.posn = 0;
1073 + out_buffer.buffer = out_data;
1074 +
1075 + sprintf(timeout_header, "Timeout: Second-%d", timeout);
1076 + url = xmalloc(strlen(remote->url) + strlen(file) + 1);
1077 + sprintf(url, "%s%s", remote->url, file);
1078 + dav_headers = curl_slist_append(dav_headers, timeout_header);
1079 + dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1080 +
1081 + slot = get_active_slot();
1082 + curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1083 + curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1084 + curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1085 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1086 + curl_easy_setopt(slot->curl, CURLOPT_HEADERFUNCTION,
1087 + process_lock_header);
1088 + curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1089 + curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1090 + curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
1091 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1092 +
1093 + if (start_active_slot(slot)) {
1094 + run_active_slot(slot);
1095 + free(out_data);
1096 + if (slot->curl_result != CURLE_OK) {
1097 + fprintf(stderr, "Got HTTP error %ld\n", slot->http_code);
1098 + return NULL;
1099 + }
1100 + } else {
1101 + free(out_data);
1102 + fprintf(stderr, "Unable to start request\n");
1103 + }
1104 +
1105 + return strdup(lock_token);
1106 +}
1107 +
1108 +int unlock_remote(char *file, char *lock_token)
1109 +{
1110 + struct active_request_slot *slot;
1111 + char *url;
1112 + char *lock_token_header;
1113 + struct curl_slist *dav_headers = NULL;
1114 + int rc = 0;
1115 +
1116 + if (lock_token == NULL) {
1117 + fprintf(stderr, "Unable to unlock, no lock token");
1118 + return 0;
1119 + }
1120 +
1121 + lock_token_header = xmalloc(strlen(lock_token) + 31);
1122 + sprintf(lock_token_header, "Lock-Token: <opaquelocktoken:%s>",
1123 + lock_token);
1124 + url = xmalloc(strlen(remote->url) + strlen(file) + 1);
1125 + sprintf(url, "%s%s", remote->url, file);
1126 + dav_headers = curl_slist_append(dav_headers, lock_token_header);
1127 +
1128 + slot = get_active_slot();
1129 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1130 + curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1131 + curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_UNLOCK);
1132 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1133 +
1134 + if (start_active_slot(slot)) {
1135 + run_active_slot(slot);
1136 + if (slot->curl_result == CURLE_OK)
1137 + rc = 1;
1138 + else
1139 + fprintf(stderr, "Got HTTP error %ld\n",
1140 + slot->http_code);
1141 + } else {
1142 + fprintf(stderr, "Unable to start request\n");
1143 + }
1144 +
1145 + curl_slist_free_all(dav_headers);
1146 + free(lock_token_header);
1147 + free(url);
1148 +
1149 + return rc;
1150 +}
1151 +
1152 +int check_locking()
1153 +{
1154 + struct active_request_slot *slot;
1155 + struct buffer in_buffer;
1156 + struct buffer out_buffer;
1157 + char *in_data;
1158 + char *out_data;
1159 + XML_Parser parser = XML_ParserCreate(NULL);
1160 + enum XML_Status result;
1161 + struct lockprop supported_lock;
1162 + struct curl_slist *dav_headers = NULL;
1163 +
1164 + out_buffer.size = strlen(PROPFIND_REQUEST) + strlen(remote->url) - 2;
1165 + out_data = xmalloc(out_buffer.size + 1);
1166 + snprintf(out_data, out_buffer.size + 1, PROPFIND_REQUEST, remote->url);
1167 + out_buffer.posn = 0;
1168 + out_buffer.buffer = out_data;
1169 +
1170 + in_buffer.size = 4096;
1171 + in_data = xmalloc(in_buffer.size);
1172 + in_buffer.posn = 0;
1173 + in_buffer.buffer = in_data;
1174 +
1175 + dav_headers = curl_slist_append(dav_headers, "Depth: 0");
1176 + dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
1177 +
1178 + slot = get_active_slot();
1179 + curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1180 + curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1181 + curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1182 + curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1183 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
1184 + fwrite_buffer_dynamic);
1185 + curl_easy_setopt(slot->curl, CURLOPT_URL, remote->url);
1186 + curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1187 + curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
1188 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1189 +
1190 + if (start_active_slot(slot)) {
1191 + run_active_slot(slot);
1192 + free(out_data);
1193 + if (slot->curl_result != CURLE_OK) {
1194 + free(in_buffer.buffer);
1195 + return -1;
1196 + }
1197 +
1198 + XML_SetUserData(parser, &supported_lock);
1199 + XML_SetElementHandler(parser, start_lockprop_element,
1200 + end_lockprop_element);
1201 + result = XML_Parse(parser, in_buffer.buffer, in_buffer.posn, 1);
1202 + free(in_buffer.buffer);
1203 + if (result != XML_STATUS_OK)
1204 + return error("%s", XML_ErrorString(
1205 + XML_GetErrorCode(parser)));
1206 + } else {
1207 + free(out_data);
1208 + free(in_buffer.buffer);
1209 + return error("Unable to start request");
1210 + }
1211 +
1212 + if (supported_lock.lock_exclusive_write)
1213 + return 0;
1214 + else
1215 + return 1;
1216 +}
1217 +
1218 +int is_ancestor(unsigned char *sha1, struct commit *commit)
1219 +{
1220 + struct commit_list *parents;
1221 +
1222 + if (parse_commit(commit))
1223 + return 0;
1224 + parents = commit->parents;
1225 + for (; parents; parents = parents->next) {
1226 + if (!memcmp(sha1, parents->item->object.sha1, 20)) {
1227 + return 1;
1228 + } else if (parents->item->object.type == commit_type) {
1229 + if (is_ancestor(
1230 + sha1,
1231 + (struct commit *)&parents->item->object
1232 + ))
1233 + return 1;
1234 + }
1235 + }
1236 + return 0;
1237 +}
1238 +
1239 +void get_delta(unsigned char *sha1, struct object *obj, char *lock_token)
1240 +{
1241 + struct commit *commit;
1242 + struct commit_list *parents;
1243 + struct tree *tree;
1244 + struct tree_entry_list *entry;
1245 +
1246 + if (sha1 && !memcmp(sha1, obj->sha1, 20))
1247 + return;
1248 +
1249 + if (aborted)
1250 + return;
1251 +
1252 + if (obj->type == commit_type) {
1253 + if (push_verbosely)
1254 + fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
1255 + add_request(obj->sha1, lock_token);
1256 + commit = (struct commit *)obj;
1257 + if (parse_commit(commit)) {
1258 + fprintf(stderr, "Error parsing commit %s\n",
1259 + sha1_to_hex(obj->sha1));
1260 + aborted = 1;
1261 + return;
1262 + }
1263 + parents = commit->parents;
1264 + for (; parents; parents = parents->next)
1265 + if (sha1 == NULL ||
1266 + memcmp(sha1, parents->item->object.sha1, 20))
1267 + get_delta(sha1, &parents->item->object,
1268 + lock_token);
1269 + get_delta(sha1, &commit->tree->object, lock_token);
1270 + } else if (obj->type == tree_type) {
1271 + if (push_verbosely)
1272 + fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
1273 + add_request(obj->sha1, lock_token);
1274 + tree = (struct tree *)obj;
1275 + if (parse_tree(tree)) {
1276 + fprintf(stderr, "Error parsing tree %s\n",
1277 + sha1_to_hex(obj->sha1));
1278 + aborted = 1;
1279 + return;
1280 + }
1281 + entry = tree->entries;
1282 + tree->entries = NULL;
1283 + while (entry) {
1284 + struct tree_entry_list *next = entry->next;
1285 + get_delta(sha1, entry->item.any, lock_token);
1286 + free(entry->name);
1287 + free(entry);
1288 + entry = next;
1289 + }
1290 + } else if (obj->type == blob_type || obj->type == tag_type) {
1291 + add_request(obj->sha1, lock_token);
1292 + }
1293 +}
1294 +
1295 +int update_remote(char *remote_path, unsigned char *sha1, char *lock_token)
1296 +{
1297 + struct active_request_slot *slot;
1298 + char *url;
1299 + char *out_data;
1300 + char *if_header;
1301 + struct buffer out_buffer;
1302 + struct curl_slist *dav_headers = NULL;
1303 + int i;
1304 +
1305 + url = xmalloc(strlen(remote->url) + strlen(remote_path) + 1);
1306 + sprintf(url, "%s%s", remote->url, remote_path);
1307 +
1308 + if_header = xmalloc(strlen(lock_token) + 25);
1309 + sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock_token);
1310 + dav_headers = curl_slist_append(dav_headers, if_header);
1311 +
1312 + out_buffer.size = 41;
1313 + out_data = xmalloc(out_buffer.size + 1);
1314 + i = snprintf(out_data, out_buffer.size + 1, "%s\n", sha1_to_hex(sha1));
1315 + if (i != out_buffer.size) {
1316 + fprintf(stderr, "Unable to initialize PUT request body\n");
1317 + return 0;
1318 + }
1319 + out_buffer.posn = 0;
1320 + out_buffer.buffer = out_data;
1321 +
1322 + slot = get_active_slot();
1323 + curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1324 + curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1325 + curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1326 + curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1327 + curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
1328 + curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
1329 + curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
1330 + curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
1331 + curl_easy_setopt(slot->curl, CURLOPT_URL, url);
1332 +
1333 + if (start_active_slot(slot)) {
1334 + run_active_slot(slot);
1335 + free(out_data);
1336 + free(if_header);
1337 + free(url);
1338 + if (slot->curl_result != CURLE_OK) {
1339 + fprintf(stderr,
1340 + "PUT error: curl result=%d, HTTP code=%ld\n",
1341 + slot->curl_result, slot->http_code);
1342 + /* We should attempt recovery? */
1343 + return 0;
1344 + }
1345 + } else {
1346 + free(out_data);
1347 + free(if_header);
1348 + free(url);
1349 + fprintf(stderr, "Unable to start PUT request\n");
1350 + return 0;
1351 + }
1352 +
1353 + return 1;
1354 +}
1355 +
1356 +int main(int argc, char **argv)
1357 +{
1358 + struct active_request_slot *slot;
1359 + struct active_request_slot *next_slot;
1360 + struct transfer_request *request;
1361 + struct transfer_request *next_request;
1362 + int nr_refspec = 0;
1363 + char **refspec = NULL;
1364 + int do_remote_update;
1365 + int new_branch;
1366 + int force_this;
1367 + char *local_ref;
1368 + unsigned char local_sha1[20];
1369 + struct object *local_object = NULL;
1370 + char *remote_ref = NULL;
1371 + unsigned char remote_sha1[20];
1372 + char *remote_lock = NULL;
1373 + char *remote_path = NULL;
1374 + char *low_speed_limit;
1375 + char *low_speed_time;
1376 + int rc = 0;
1377 + int i;
1378 +
1379 + setup_ident();
1380 +
1381 + remote = xmalloc(sizeof(*remote));
1382 + remote->url = NULL;
1383 + remote->packs = NULL;
1384 +
1385 + argv++;
1386 + for (i = 1; i < argc; i++, argv++) {
1387 + char *arg = *argv;
1388 +
1389 + if (*arg == '-') {
1390 + if (!strcmp(arg, "--complete")) {
1391 + push_all = 1;
1392 + continue;
1393 + }
1394 + if (!strcmp(arg, "--force")) {
1395 + force_all = 1;
1396 + continue;
1397 + }
1398 + if (!strcmp(arg, "--verbose")) {
1399 + push_verbosely = 1;
1400 + continue;
1401 + }
1402 + usage(http_push_usage);
1403 + }
1404 + if (!remote->url) {
1405 + remote->url = arg;
1406 + continue;
1407 + }
1408 + refspec = argv;
1409 + nr_refspec = argc - i;
1410 + break;
1411 + }
1412 +
1413 + curl_global_init(CURL_GLOBAL_ALL);
1414 +
1415 +#ifdef USE_CURL_MULTI
1416 + {
1417 + char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
1418 + if (http_max_requests != NULL)
1419 + max_requests = atoi(http_max_requests);
1420 + }
1421 +
1422 + curlm = curl_multi_init();
1423 + if (curlm == NULL) {
1424 + fprintf(stderr, "Error creating curl multi handle.\n");
1425 + return 1;
1426 + }
1427 +#endif
1428 +
1429 + if (getenv("GIT_SSL_NO_VERIFY"))
1430 + curl_ssl_verify = 0;
1431 +
1432 + ssl_cert = getenv("GIT_SSL_CERT");
1433 +#if LIBCURL_VERSION_NUM >= 0x070902
1434 + ssl_key = getenv("GIT_SSL_KEY");
1435 +#endif
1436 +#if LIBCURL_VERSION_NUM >= 0x070908
1437 + ssl_capath = getenv("GIT_SSL_CAPATH");
1438 +#endif
1439 + ssl_cainfo = getenv("GIT_SSL_CAINFO");
1440 +
1441 + low_speed_limit = getenv("GIT_HTTP_LOW_SPEED_LIMIT");
1442 + if (low_speed_limit != NULL)
1443 + curl_low_speed_limit = strtol(low_speed_limit, NULL, 10);
1444 + low_speed_time = getenv("GIT_HTTP_LOW_SPEED_TIME");
1445 + if (low_speed_time != NULL)
1446 + curl_low_speed_time = strtol(low_speed_time, NULL, 10);
1447 +
1448 + git_config(http_options);
1449 +
1450 + if (curl_ssl_verify == -1)
1451 + curl_ssl_verify = 1;
1452 +
1453 +#ifdef USE_CURL_MULTI
1454 + if (max_requests < 1)
1455 + max_requests = DEFAULT_MAX_REQUESTS;
1456 +#endif
1457 +
1458 + no_pragma_header = curl_slist_append(no_pragma_header, "Pragma:");
1459 + default_headers = curl_slist_append(default_headers, "Range:");
1460 + default_headers = curl_slist_append(default_headers, "Destination:");
1461 + default_headers = curl_slist_append(default_headers, "If:");
1462 + default_headers = curl_slist_append(default_headers,
1463 + "Pragma: no-cache");
1464 +
1465 +#ifndef NO_CURL_EASY_DUPHANDLE
1466 + curl_default = get_curl_handle();
1467 +#endif
1468 +
1469 + /* Verify DAV compliance/lock support */
1470 + if (check_locking() != 0) {
1471 + fprintf(stderr, "Error: no DAV locking support on remote repo %s\n", remote->url);
1472 + rc = 1;
1473 + goto cleanup;
1474 + }
1475 +
1476 + /* Process each refspec */
1477 + for (i = 0; i < nr_refspec; i++) {
1478 + char *ep;
1479 + force_this = 0;
1480 + do_remote_update = 0;
1481 + new_branch = 0;
1482 + local_ref = refspec[i];
1483 + if (*local_ref == '+') {
1484 + force_this = 1;
1485 + local_ref++;
1486 + }
1487 + ep = strchr(local_ref, ':');
1488 + if (ep) {
1489 + remote_ref = ep + 1;
1490 + *ep = 0;
1491 + }
1492 + else
1493 + remote_ref = local_ref;
1494 +
1495 + /* Lock remote branch ref */
1496 + if (remote_path)
1497 + free(remote_path);
1498 + remote_path = xmalloc(strlen(remote_ref) + 12);
1499 + sprintf(remote_path, "refs/heads/%s", remote_ref);
1500 + remote_lock = lock_remote(remote_path, 3600);
1501 + if (remote_lock == NULL) {
1502 + fprintf(stderr, "Unable to lock remote branch %s\n",
1503 + remote_ref);
1504 + rc = 1;
1505 + continue;
1506 + }
1507 +
1508 + /* Resolve local and remote refs */
1509 + if (fetch_ref(remote_ref, remote_sha1) != 0) {
1510 + fprintf(stderr,
1511 + "Remote branch %s does not exist on %s\n",
1512 + remote_ref, remote->url);
1513 + new_branch = 1;
1514 + }
1515 + if (get_sha1(local_ref, local_sha1) != 0) {
1516 + fprintf(stderr, "Error resolving local branch %s\n",
1517 + local_ref);
1518 + rc = 1;
1519 + goto unlock;
1520 + }
1521 +
1522 + /* Find relationship between local and remote */
1523 + local_object = parse_object(local_sha1);
1524 + if (!local_object) {
1525 + fprintf(stderr, "Unable to parse local object %s\n",
1526 + sha1_to_hex(local_sha1));
1527 + rc = 1;
1528 + goto unlock;
1529 + } else if (new_branch) {
1530 + do_remote_update = 1;
1531 + } else {
1532 + if (!memcmp(local_sha1, remote_sha1, 20)) {
1533 + fprintf(stderr,
1534 + "* %s: same as branch '%s' of %s\n",
1535 + local_ref, remote_ref, remote->url);
1536 + } else if (is_ancestor(remote_sha1,
1537 + (struct commit *)local_object)) {
1538 + fprintf(stderr,
1539 + "Remote %s will fast-forward to local %s\n",
1540 + remote_ref, local_ref);
1541 + do_remote_update = 1;
1542 + } else if (force_all || force_this) {
1543 + fprintf(stderr,
1544 + "* %s on %s does not fast forward to local branch '%s', overwriting\n",
1545 + remote_ref, remote->url, local_ref);
1546 + do_remote_update = 1;
1547 + } else {
1548 + fprintf(stderr,
1549 + "* %s on %s does not fast forward to local branch '%s'\n",
1550 + remote_ref, remote->url, local_ref);
1551 + rc = 1;
1552 + goto unlock;
1553 + }
1554 + }
1555 +
1556 + /* Generate and check list of required objects */
1557 + pushing = 0;
1558 + if (do_remote_update || push_all)
1559 + fetch_indices();
1560 + get_delta(push_all ? NULL : remote_sha1,
1561 + local_object, remote_lock);
1562 + process_waiting_requests();
1563 +
1564 + /* Push missing objects to remote, this would be a
1565 + convenient time to pack them first if appropriate. */
1566 + pushing = 1;
1567 + process_request_queue();
1568 + process_waiting_requests();
1569 +
1570 + /* Update the remote branch if all went well */
1571 + if (do_remote_update) {
1572 + if (!aborted && update_remote(remote_path,
1573 + local_sha1,
1574 + remote_lock)) {
1575 + fprintf(stderr, "%s remote branch %s\n",
1576 + new_branch ? "Created" : "Updated",
1577 + remote_ref);
1578 + } else {
1579 + fprintf(stderr,
1580 + "Unable to %s remote branch %s\n",
1581 + new_branch ? "create" : "update",
1582 + remote_ref);
1583 + rc = 1;
1584 + goto unlock;
1585 + }
1586 + }
1587 +
1588 + unlock:
1589 + unlock_remote(remote_path, remote_lock);
1590 + free(remote_path);
1591 + free(remote_lock);
1592 + }
1593 +
1594 + cleanup:
1595 + free(remote);
1596 +
1597 + curl_slist_free_all(no_pragma_header);
1598 + curl_slist_free_all(default_headers);
1599 +
1600 + slot = active_queue_head;
1601 + while (slot != NULL) {
1602 + next_slot = slot->next;
1603 + if (slot->curl != NULL)
1604 + curl_easy_cleanup(slot->curl);
1605 + free(slot);
1606 + slot = next_slot;
1607 + }
1608 +
1609 + request = request_queue_head;
1610 + while (request != NULL) {
1611 + next_request = request->next;
1612 + release_request(request);
1613 + free(request);
1614 + request = next_request;
1615 + }
1616 +
1617 +#ifndef NO_CURL_EASY_DUPHANDLE
1618 + curl_easy_cleanup(curl_default);
1619 +#endif
1620 +#ifdef USE_CURL_MULTI
1621 + curl_multi_cleanup(curlm);
1622 +#endif
1623 + curl_global_cleanup();
1624 + return rc;
1625 +}