3 #include "run-command.h"
8 #include "fetch-pack.h"
17 * We copy packed-refs and refs/ into a temporary file, then read the
18 * loose refs recursively (sorting whenever possible), and then inserting
19 * those packed refs that are not yet in the list (not validating, but
20 * assuming that the file is sorted).
22 * Appears refactoring this from refs.c is too cumbersome.
25 static int str_cmp(const void *a
, const void *b
)
30 return strcmp(s1
, s2
);
33 /* path->buf + name_offset is expected to point to "refs/" */
35 static int read_loose_refs(struct strbuf
*path
, int name_offset
,
38 DIR *dir
= opendir(path
->buf
);
49 memset (&list
, 0, sizeof(list
));
51 while ((de
= readdir(dir
))) {
52 if (de
->d_name
[0] == '.' && (de
->d_name
[1] == '\0' ||
53 (de
->d_name
[1] == '.' &&
54 de
->d_name
[2] == '\0')))
56 ALLOC_GROW(list
.entries
, list
.nr
+ 1, list
.alloc
);
57 list
.entries
[list
.nr
++] = xstrdup(de
->d_name
);
63 qsort(list
.entries
, list
.nr
, sizeof(char *), str_cmp
);
66 strbuf_addch(path
, '/');
68 for (i
= 0; i
< list
.nr
; i
++, strbuf_setlen(path
, pathlen
+ 1)) {
69 strbuf_addstr(path
, list
.entries
[i
]);
70 if (read_loose_refs(path
, name_offset
, tail
)) {
71 int fd
= open(path
->buf
, O_RDONLY
);
77 next
= alloc_ref(path
->len
- name_offset
+ 1);
78 if (read_in_full(fd
, buffer
, 40) != 40 ||
79 get_sha1_hex(buffer
, next
->old_sha1
)) {
85 strcpy(next
->name
, path
->buf
+ name_offset
);
90 strbuf_setlen(path
, pathlen
);
92 for (i
= 0; i
< list
.nr
; i
++)
93 free(list
.entries
[i
]);
99 /* insert the packed refs for which no loose refs were found */
101 static void insert_packed_refs(const char *packed_refs
, struct ref
**list
)
103 FILE *f
= fopen(packed_refs
, "r");
104 static char buffer
[PATH_MAX
];
112 if (!fgets(buffer
, sizeof(buffer
), f
)) {
117 if (hexval(buffer
[0]) > 0xf)
119 len
= strlen(buffer
);
120 if (buffer
[len
- 1] == '\n')
121 buffer
[--len
] = '\0';
124 while ((*list
)->next
&&
125 (cmp
= strcmp(buffer
+ 41,
126 (*list
)->next
->name
)) > 0)
127 list
= &(*list
)->next
;
128 if (!(*list
)->next
|| cmp
< 0) {
129 struct ref
*next
= alloc_ref(len
- 40);
131 if (get_sha1_hex(buffer
, next
->old_sha1
)) {
132 warning ("invalid SHA-1: %s", buffer
);
136 strcpy(next
->name
, buffer
+ 41);
137 next
->next
= (*list
)->next
;
138 (*list
)->next
= next
;
139 list
= &(*list
)->next
;
144 static struct ref
*get_refs_via_rsync(const struct transport
*transport
)
146 struct strbuf buf
= STRBUF_INIT
, temp_dir
= STRBUF_INIT
;
147 struct ref dummy
, *tail
= &dummy
;
148 struct child_process rsync
;
152 /* copy the refs to the temporary directory */
154 strbuf_addstr(&temp_dir
, git_path("rsync-refs-XXXXXX"));
155 if (!mkdtemp(temp_dir
.buf
))
156 die ("Could not make temporary directory");
157 temp_dir_len
= temp_dir
.len
;
159 strbuf_addstr(&buf
, transport
->url
);
160 strbuf_addstr(&buf
, "/refs");
162 memset(&rsync
, 0, sizeof(rsync
));
164 rsync
.stdout_to_stderr
= 1;
166 args
[1] = (transport
->verbose
> 0) ? "-rv" : "-r";
168 args
[3] = temp_dir
.buf
;
171 if (run_command(&rsync
))
172 die ("Could not run rsync to get refs");
175 strbuf_addstr(&buf
, transport
->url
);
176 strbuf_addstr(&buf
, "/packed-refs");
180 if (run_command(&rsync
))
181 die ("Could not run rsync to get refs");
183 /* read the copied refs */
185 strbuf_addstr(&temp_dir
, "/refs");
186 read_loose_refs(&temp_dir
, temp_dir_len
+ 1, &tail
);
187 strbuf_setlen(&temp_dir
, temp_dir_len
);
190 strbuf_addstr(&temp_dir
, "/packed-refs");
191 insert_packed_refs(temp_dir
.buf
, &tail
);
192 strbuf_setlen(&temp_dir
, temp_dir_len
);
194 if (remove_dir_recursively(&temp_dir
, 0))
195 warning ("Error removing temporary directory %s.",
198 strbuf_release(&buf
);
199 strbuf_release(&temp_dir
);
204 static int fetch_objs_via_rsync(struct transport
*transport
,
205 int nr_objs
, struct ref
**to_fetch
)
207 struct strbuf buf
= STRBUF_INIT
;
208 struct child_process rsync
;
212 strbuf_addstr(&buf
, transport
->url
);
213 strbuf_addstr(&buf
, "/objects/");
215 memset(&rsync
, 0, sizeof(rsync
));
217 rsync
.stdout_to_stderr
= 1;
219 args
[1] = (transport
->verbose
> 0) ? "-rv" : "-r";
220 args
[2] = "--ignore-existing";
221 args
[3] = "--exclude";
224 args
[6] = get_object_directory();
227 /* NEEDSWORK: handle one level of alternates */
228 result
= run_command(&rsync
);
230 strbuf_release(&buf
);
235 static int write_one_ref(const char *name
, const unsigned char *sha1
,
236 int flags
, void *data
)
238 struct strbuf
*buf
= data
;
242 /* when called via for_each_ref(), flags is non-zero */
243 if (flags
&& prefixcmp(name
, "refs/heads/") &&
244 prefixcmp(name
, "refs/tags/"))
247 strbuf_addstr(buf
, name
);
248 if (safe_create_leading_directories(buf
->buf
) ||
249 !(f
= fopen(buf
->buf
, "w")) ||
250 fprintf(f
, "%s\n", sha1_to_hex(sha1
)) < 0 ||
252 return error("problems writing temporary file %s", buf
->buf
);
253 strbuf_setlen(buf
, len
);
257 static int write_refs_to_temp_dir(struct strbuf
*temp_dir
,
258 int refspec_nr
, const char **refspec
)
262 for (i
= 0; i
< refspec_nr
; i
++) {
263 unsigned char sha1
[20];
266 if (dwim_ref(refspec
[i
], strlen(refspec
[i
]), sha1
, &ref
) != 1)
267 return error("Could not get ref %s", refspec
[i
]);
269 if (write_one_ref(ref
, sha1
, 0, temp_dir
)) {
278 static int rsync_transport_push(struct transport
*transport
,
279 int refspec_nr
, const char **refspec
, int flags
)
281 struct strbuf buf
= STRBUF_INIT
, temp_dir
= STRBUF_INIT
;
283 struct child_process rsync
;
284 const char *args
[10];
286 /* first push the objects */
288 strbuf_addstr(&buf
, transport
->url
);
289 strbuf_addch(&buf
, '/');
291 memset(&rsync
, 0, sizeof(rsync
));
293 rsync
.stdout_to_stderr
= 1;
297 if (flags
& TRANSPORT_PUSH_DRY_RUN
)
298 args
[i
++] = "--dry-run";
299 if (transport
->verbose
> 0)
301 args
[i
++] = "--ignore-existing";
302 args
[i
++] = "--exclude";
304 args
[i
++] = get_object_directory();
308 if (run_command(&rsync
))
309 return error("Could not push objects to %s", transport
->url
);
311 /* copy the refs to the temporary directory; they could be packed. */
313 strbuf_addstr(&temp_dir
, git_path("rsync-refs-XXXXXX"));
314 if (!mkdtemp(temp_dir
.buf
))
315 die ("Could not make temporary directory");
316 strbuf_addch(&temp_dir
, '/');
318 if (flags
& TRANSPORT_PUSH_ALL
) {
319 if (for_each_ref(write_one_ref
, &temp_dir
))
321 } else if (write_refs_to_temp_dir(&temp_dir
, refspec_nr
, refspec
))
325 if (flags
& TRANSPORT_PUSH_DRY_RUN
)
326 args
[i
++] = "--dry-run";
327 if (!(flags
& TRANSPORT_PUSH_FORCE
))
328 args
[i
++] = "--ignore-existing";
329 args
[i
++] = temp_dir
.buf
;
330 args
[i
++] = transport
->url
;
332 if (run_command(&rsync
))
333 result
= error("Could not push to %s", transport
->url
);
335 if (remove_dir_recursively(&temp_dir
, 0))
336 warning ("Could not remove temporary directory %s.",
339 strbuf_release(&buf
);
340 strbuf_release(&temp_dir
);
345 /* Generic functions for using commit walkers */
347 static int fetch_objs_via_walker(struct transport
*transport
,
348 int nr_objs
, struct ref
**to_fetch
)
350 char *dest
= xstrdup(transport
->url
);
351 struct walker
*walker
= transport
->data
;
352 char **objs
= xmalloc(nr_objs
* sizeof(*objs
));
356 walker
->get_tree
= 1;
357 walker
->get_history
= 1;
358 walker
->get_verbosely
= transport
->verbose
>= 0;
359 walker
->get_recover
= 0;
361 for (i
= 0; i
< nr_objs
; i
++)
362 objs
[i
] = xstrdup(sha1_to_hex(to_fetch
[i
]->old_sha1
));
364 if (walker_fetch(walker
, nr_objs
, objs
, NULL
, NULL
))
365 die("Fetch failed.");
367 for (i
= 0; i
< nr_objs
; i
++)
374 static int disconnect_walker(struct transport
*transport
)
376 struct walker
*walker
= transport
->data
;
383 static int curl_transport_push(struct transport
*transport
, int refspec_nr
, const char **refspec
, int flags
) {
388 argv
= xmalloc((refspec_nr
+ 11) * sizeof(char *));
389 argv
[0] = "http-push";
391 if (flags
& TRANSPORT_PUSH_ALL
)
392 argv
[argc
++] = "--all";
393 if (flags
& TRANSPORT_PUSH_FORCE
)
394 argv
[argc
++] = "--force";
395 argv
[argc
++] = transport
->url
;
397 argv
[argc
++] = *refspec
++;
399 err
= run_command_v_opt(argv
, RUN_GIT_CMD
);
401 case -ERR_RUN_COMMAND_FORK
:
402 error("unable to fork for %s", argv
[0]);
403 case -ERR_RUN_COMMAND_EXEC
:
404 error("unable to exec %s", argv
[0]);
406 case -ERR_RUN_COMMAND_WAITPID
:
407 case -ERR_RUN_COMMAND_WAITPID_WRONG_PID
:
408 case -ERR_RUN_COMMAND_WAITPID_SIGNAL
:
409 case -ERR_RUN_COMMAND_WAITPID_NOEXIT
:
410 error("%s died with strange error", argv
[0]);
415 static int missing__target(int code
, int result
)
417 return /* file:// URL -- do we ever use one??? */
418 (result
== CURLE_FILE_COULDNT_READ_FILE
) ||
419 /* http:// and https:// URL */
420 (code
== 404 && result
== CURLE_HTTP_RETURNED_ERROR
) ||
422 (code
== 550 && result
== CURLE_FTP_COULDNT_RETR_FILE
)
426 #define missing_target(a) missing__target((a)->http_code, (a)->curl_result)
428 static struct ref
*get_refs_via_curl(const struct transport
*transport
)
430 struct buffer buffer
;
431 char *data
, *start
, *mid
;
436 struct active_request_slot
*slot
;
437 struct slot_results results
;
439 struct ref
*refs
= NULL
;
440 struct ref
*ref
= NULL
;
441 struct ref
*last_ref
= NULL
;
443 data
= xmalloc(4096);
446 buffer
.buffer
= data
;
448 refs_url
= xmalloc(strlen(transport
->url
) + 11);
449 sprintf(refs_url
, "%s/info/refs", transport
->url
);
453 slot
= get_active_slot();
454 slot
->results
= &results
;
455 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &buffer
);
456 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
457 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, refs_url
);
458 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, NULL
);
459 if (start_active_slot(slot
)) {
460 run_active_slot(slot
);
461 if (results
.curl_result
!= CURLE_OK
) {
462 if (missing_target(&results
)) {
467 error("%s", curl_errorstr
);
473 error("Unable to start request");
479 data
= buffer
.buffer
;
482 while (i
< buffer
.posn
) {
487 if (data
[i
] == '\n') {
490 ref
= xmalloc(sizeof(struct ref
) +
491 strlen(ref_name
) + 1);
492 memset(ref
, 0, sizeof(struct ref
));
493 strcpy(ref
->name
, ref_name
);
494 get_sha1_hex(start
, ref
->old_sha1
);
498 last_ref
->next
= ref
;
510 static int fetch_objs_via_curl(struct transport
*transport
,
511 int nr_objs
, struct ref
**to_fetch
)
513 if (!transport
->data
)
514 transport
->data
= get_http_walker(transport
->url
);
515 return fetch_objs_via_walker(transport
, nr_objs
, to_fetch
);
520 struct bundle_transport_data
{
522 struct bundle_header header
;
525 static struct ref
*get_refs_from_bundle(const struct transport
*transport
)
527 struct bundle_transport_data
*data
= transport
->data
;
528 struct ref
*result
= NULL
;
533 data
->fd
= read_bundle_header(transport
->url
, &data
->header
);
535 die ("Could not read bundle '%s'.", transport
->url
);
536 for (i
= 0; i
< data
->header
.references
.nr
; i
++) {
537 struct ref_list_entry
*e
= data
->header
.references
.list
+ i
;
538 struct ref
*ref
= alloc_ref(strlen(e
->name
) + 1);
539 hashcpy(ref
->old_sha1
, e
->sha1
);
540 strcpy(ref
->name
, e
->name
);
547 static int fetch_refs_from_bundle(struct transport
*transport
,
548 int nr_heads
, struct ref
**to_fetch
)
550 struct bundle_transport_data
*data
= transport
->data
;
551 return unbundle(&data
->header
, data
->fd
);
554 static int close_bundle(struct transport
*transport
)
556 struct bundle_transport_data
*data
= transport
->data
;
563 struct git_transport_data
{
567 const char *uploadpack
;
568 const char *receivepack
;
571 static int set_git_option(struct transport
*connection
,
572 const char *name
, const char *value
)
574 struct git_transport_data
*data
= connection
->data
;
575 if (!strcmp(name
, TRANS_OPT_UPLOADPACK
)) {
576 data
->uploadpack
= value
;
578 } else if (!strcmp(name
, TRANS_OPT_RECEIVEPACK
)) {
579 data
->receivepack
= value
;
581 } else if (!strcmp(name
, TRANS_OPT_THIN
)) {
582 data
->thin
= !!value
;
584 } else if (!strcmp(name
, TRANS_OPT_KEEP
)) {
585 data
->keep
= !!value
;
587 } else if (!strcmp(name
, TRANS_OPT_DEPTH
)) {
591 data
->depth
= atoi(value
);
597 static struct ref
*get_refs_via_connect(const struct transport
*transport
)
599 struct git_transport_data
*data
= transport
->data
;
603 char *dest
= xstrdup(transport
->url
);
605 pid
= git_connect(fd
, dest
, data
->uploadpack
, 0);
608 die("Failed to connect to \"%s\"", transport
->url
);
610 get_remote_heads(fd
[0], &refs
, 0, NULL
, 0);
620 static int fetch_refs_via_pack(struct transport
*transport
,
621 int nr_heads
, struct ref
**to_fetch
)
623 struct git_transport_data
*data
= transport
->data
;
624 char **heads
= xmalloc(nr_heads
* sizeof(*heads
));
625 char **origh
= xmalloc(nr_heads
* sizeof(*origh
));
627 char *dest
= xstrdup(transport
->url
);
628 struct fetch_pack_args args
;
631 memset(&args
, 0, sizeof(args
));
632 args
.uploadpack
= data
->uploadpack
;
633 args
.keep_pack
= data
->keep
;
635 args
.use_thin_pack
= data
->thin
;
636 args
.verbose
= transport
->verbose
> 0;
637 args
.depth
= data
->depth
;
639 for (i
= 0; i
< nr_heads
; i
++)
640 origh
[i
] = heads
[i
] = xstrdup(to_fetch
[i
]->name
);
641 refs
= fetch_pack(&args
, dest
, nr_heads
, heads
, &transport
->pack_lockfile
);
643 for (i
= 0; i
< nr_heads
; i
++)
652 static int git_transport_push(struct transport
*transport
, int refspec_nr
, const char **refspec
, int flags
) {
653 struct git_transport_data
*data
= transport
->data
;
659 argv
= xmalloc((refspec_nr
+ 11) * sizeof(char *));
660 argv
[0] = "send-pack";
662 if (flags
& TRANSPORT_PUSH_ALL
)
663 argv
[argc
++] = "--all";
664 if (flags
& TRANSPORT_PUSH_FORCE
)
665 argv
[argc
++] = "--force";
666 if (flags
& TRANSPORT_PUSH_DRY_RUN
)
667 argv
[argc
++] = "--dry-run";
668 if (data
->receivepack
) {
669 char *rp
= xmalloc(strlen(data
->receivepack
) + 16);
670 sprintf(rp
, "--receive-pack=%s", data
->receivepack
);
674 argv
[argc
++] = "--thin";
675 rem
= xmalloc(strlen(transport
->remote
->name
) + 10);
676 sprintf(rem
, "--remote=%s", transport
->remote
->name
);
678 argv
[argc
++] = transport
->url
;
680 argv
[argc
++] = *refspec
++;
682 err
= run_command_v_opt(argv
, RUN_GIT_CMD
);
684 case -ERR_RUN_COMMAND_FORK
:
685 error("unable to fork for %s", argv
[0]);
686 case -ERR_RUN_COMMAND_EXEC
:
687 error("unable to exec %s", argv
[0]);
689 case -ERR_RUN_COMMAND_WAITPID
:
690 case -ERR_RUN_COMMAND_WAITPID_WRONG_PID
:
691 case -ERR_RUN_COMMAND_WAITPID_SIGNAL
:
692 case -ERR_RUN_COMMAND_WAITPID_NOEXIT
:
693 error("%s died with strange error", argv
[0]);
698 static int disconnect_git(struct transport
*transport
)
700 free(transport
->data
);
704 static int is_local(const char *url
)
706 const char *colon
= strchr(url
, ':');
707 const char *slash
= strchr(url
, '/');
708 return !colon
|| (slash
&& slash
< colon
);
711 static int is_file(const char *url
)
716 return S_ISREG(buf
.st_mode
);
719 struct transport
*transport_get(struct remote
*remote
, const char *url
)
721 struct transport
*ret
= xcalloc(1, sizeof(*ret
));
723 ret
->remote
= remote
;
726 if (!prefixcmp(url
, "rsync://")) {
727 ret
->get_refs_list
= get_refs_via_rsync
;
728 ret
->fetch
= fetch_objs_via_rsync
;
729 ret
->push
= rsync_transport_push
;
731 } else if (!prefixcmp(url
, "http://")
732 || !prefixcmp(url
, "https://")
733 || !prefixcmp(url
, "ftp://")) {
735 error("git was compiled without libcurl support.");
737 ret
->get_refs_list
= get_refs_via_curl
;
738 ret
->fetch
= fetch_objs_via_curl
;
739 ret
->push
= curl_transport_push
;
741 ret
->disconnect
= disconnect_walker
;
743 } else if (is_local(url
) && is_file(url
)) {
744 struct bundle_transport_data
*data
= xcalloc(1, sizeof(*data
));
746 ret
->get_refs_list
= get_refs_from_bundle
;
747 ret
->fetch
= fetch_refs_from_bundle
;
748 ret
->disconnect
= close_bundle
;
751 struct git_transport_data
*data
= xcalloc(1, sizeof(*data
));
753 ret
->set_option
= set_git_option
;
754 ret
->get_refs_list
= get_refs_via_connect
;
755 ret
->fetch
= fetch_refs_via_pack
;
756 ret
->push
= git_transport_push
;
757 ret
->disconnect
= disconnect_git
;
760 data
->uploadpack
= "git-upload-pack";
761 if (remote
&& remote
->uploadpack
)
762 data
->uploadpack
= remote
->uploadpack
;
763 data
->receivepack
= "git-receive-pack";
764 if (remote
&& remote
->receivepack
)
765 data
->receivepack
= remote
->receivepack
;
771 int transport_set_option(struct transport
*transport
,
772 const char *name
, const char *value
)
774 if (transport
->set_option
)
775 return transport
->set_option(transport
, name
, value
);
779 int transport_push(struct transport
*transport
,
780 int refspec_nr
, const char **refspec
, int flags
)
782 if (!transport
->push
)
784 return transport
->push(transport
, refspec_nr
, refspec
, flags
);
787 struct ref
*transport_get_remote_refs(struct transport
*transport
)
789 if (!transport
->remote_refs
)
790 transport
->remote_refs
= transport
->get_refs_list(transport
);
791 return transport
->remote_refs
;
794 int transport_fetch_refs(struct transport
*transport
, struct ref
*refs
)
797 int nr_heads
= 0, nr_alloc
= 0;
798 struct ref
**heads
= NULL
;
801 for (rm
= refs
; rm
; rm
= rm
->next
) {
803 !hashcmp(rm
->peer_ref
->old_sha1
, rm
->old_sha1
))
805 ALLOC_GROW(heads
, nr_heads
+ 1, nr_alloc
);
806 heads
[nr_heads
++] = rm
;
809 rc
= transport
->fetch(transport
, nr_heads
, heads
);
814 void transport_unlock_pack(struct transport
*transport
)
816 if (transport
->pack_lockfile
) {
817 unlink(transport
->pack_lockfile
);
818 free(transport
->pack_lockfile
);
819 transport
->pack_lockfile
= NULL
;
823 int transport_disconnect(struct transport
*transport
)
826 if (transport
->disconnect
)
827 ret
= transport
->disconnect(transport
);