3 #include "run-command.h"
8 #include "fetch-pack.h"
18 * We copy packed-refs and refs/ into a temporary file, then read the
19 * loose refs recursively (sorting whenever possible), and then inserting
20 * those packed refs that are not yet in the list (not validating, but
21 * assuming that the file is sorted).
23 * Appears refactoring this from refs.c is too cumbersome.
26 static int str_cmp(const void *a
, const void *b
)
31 return strcmp(s1
, s2
);
34 /* path->buf + name_offset is expected to point to "refs/" */
36 static int read_loose_refs(struct strbuf
*path
, int name_offset
,
39 DIR *dir
= opendir(path
->buf
);
50 memset (&list
, 0, sizeof(list
));
52 while ((de
= readdir(dir
))) {
53 if (de
->d_name
[0] == '.' && (de
->d_name
[1] == '\0' ||
54 (de
->d_name
[1] == '.' &&
55 de
->d_name
[2] == '\0')))
57 ALLOC_GROW(list
.entries
, list
.nr
+ 1, list
.alloc
);
58 list
.entries
[list
.nr
++] = xstrdup(de
->d_name
);
64 qsort(list
.entries
, list
.nr
, sizeof(char *), str_cmp
);
67 strbuf_addch(path
, '/');
69 for (i
= 0; i
< list
.nr
; i
++, strbuf_setlen(path
, pathlen
+ 1)) {
70 strbuf_addstr(path
, list
.entries
[i
]);
71 if (read_loose_refs(path
, name_offset
, tail
)) {
72 int fd
= open(path
->buf
, O_RDONLY
);
78 next
= alloc_ref(path
->len
- name_offset
+ 1);
79 if (read_in_full(fd
, buffer
, 40) != 40 ||
80 get_sha1_hex(buffer
, next
->old_sha1
)) {
86 strcpy(next
->name
, path
->buf
+ name_offset
);
91 strbuf_setlen(path
, pathlen
);
93 for (i
= 0; i
< list
.nr
; i
++)
94 free(list
.entries
[i
]);
100 /* insert the packed refs for which no loose refs were found */
102 static void insert_packed_refs(const char *packed_refs
, struct ref
**list
)
104 FILE *f
= fopen(packed_refs
, "r");
105 static char buffer
[PATH_MAX
];
113 if (!fgets(buffer
, sizeof(buffer
), f
)) {
118 if (hexval(buffer
[0]) > 0xf)
120 len
= strlen(buffer
);
121 if (buffer
[len
- 1] == '\n')
122 buffer
[--len
] = '\0';
125 while ((*list
)->next
&&
126 (cmp
= strcmp(buffer
+ 41,
127 (*list
)->next
->name
)) > 0)
128 list
= &(*list
)->next
;
129 if (!(*list
)->next
|| cmp
< 0) {
130 struct ref
*next
= alloc_ref(len
- 40);
132 if (get_sha1_hex(buffer
, next
->old_sha1
)) {
133 warning ("invalid SHA-1: %s", buffer
);
137 strcpy(next
->name
, buffer
+ 41);
138 next
->next
= (*list
)->next
;
139 (*list
)->next
= next
;
140 list
= &(*list
)->next
;
145 static struct ref
*get_refs_via_rsync(struct transport
*transport
)
147 struct strbuf buf
= STRBUF_INIT
, temp_dir
= STRBUF_INIT
;
148 struct ref dummy
, *tail
= &dummy
;
149 struct child_process rsync
;
153 /* copy the refs to the temporary directory */
155 strbuf_addstr(&temp_dir
, git_path("rsync-refs-XXXXXX"));
156 if (!mkdtemp(temp_dir
.buf
))
157 die ("Could not make temporary directory");
158 temp_dir_len
= temp_dir
.len
;
160 strbuf_addstr(&buf
, transport
->url
);
161 strbuf_addstr(&buf
, "/refs");
163 memset(&rsync
, 0, sizeof(rsync
));
165 rsync
.stdout_to_stderr
= 1;
167 args
[1] = (transport
->verbose
> 0) ? "-rv" : "-r";
169 args
[3] = temp_dir
.buf
;
172 if (run_command(&rsync
))
173 die ("Could not run rsync to get refs");
176 strbuf_addstr(&buf
, transport
->url
);
177 strbuf_addstr(&buf
, "/packed-refs");
181 if (run_command(&rsync
))
182 die ("Could not run rsync to get refs");
184 /* read the copied refs */
186 strbuf_addstr(&temp_dir
, "/refs");
187 read_loose_refs(&temp_dir
, temp_dir_len
+ 1, &tail
);
188 strbuf_setlen(&temp_dir
, temp_dir_len
);
191 strbuf_addstr(&temp_dir
, "/packed-refs");
192 insert_packed_refs(temp_dir
.buf
, &tail
);
193 strbuf_setlen(&temp_dir
, temp_dir_len
);
195 if (remove_dir_recursively(&temp_dir
, 0))
196 warning ("Error removing temporary directory %s.",
199 strbuf_release(&buf
);
200 strbuf_release(&temp_dir
);
205 static int fetch_objs_via_rsync(struct transport
*transport
,
206 int nr_objs
, struct ref
**to_fetch
)
208 struct strbuf buf
= STRBUF_INIT
;
209 struct child_process rsync
;
213 strbuf_addstr(&buf
, transport
->url
);
214 strbuf_addstr(&buf
, "/objects/");
216 memset(&rsync
, 0, sizeof(rsync
));
218 rsync
.stdout_to_stderr
= 1;
220 args
[1] = (transport
->verbose
> 0) ? "-rv" : "-r";
221 args
[2] = "--ignore-existing";
222 args
[3] = "--exclude";
225 args
[6] = get_object_directory();
228 /* NEEDSWORK: handle one level of alternates */
229 result
= run_command(&rsync
);
231 strbuf_release(&buf
);
236 static int write_one_ref(const char *name
, const unsigned char *sha1
,
237 int flags
, void *data
)
239 struct strbuf
*buf
= data
;
243 /* when called via for_each_ref(), flags is non-zero */
244 if (flags
&& prefixcmp(name
, "refs/heads/") &&
245 prefixcmp(name
, "refs/tags/"))
248 strbuf_addstr(buf
, name
);
249 if (safe_create_leading_directories(buf
->buf
) ||
250 !(f
= fopen(buf
->buf
, "w")) ||
251 fprintf(f
, "%s\n", sha1_to_hex(sha1
)) < 0 ||
253 return error("problems writing temporary file %s", buf
->buf
);
254 strbuf_setlen(buf
, len
);
258 static int write_refs_to_temp_dir(struct strbuf
*temp_dir
,
259 int refspec_nr
, const char **refspec
)
263 for (i
= 0; i
< refspec_nr
; i
++) {
264 unsigned char sha1
[20];
267 if (dwim_ref(refspec
[i
], strlen(refspec
[i
]), sha1
, &ref
) != 1)
268 return error("Could not get ref %s", refspec
[i
]);
270 if (write_one_ref(ref
, sha1
, 0, temp_dir
)) {
279 static int rsync_transport_push(struct transport
*transport
,
280 int refspec_nr
, const char **refspec
, int flags
)
282 struct strbuf buf
= STRBUF_INIT
, temp_dir
= STRBUF_INIT
;
284 struct child_process rsync
;
285 const char *args
[10];
287 /* first push the objects */
289 strbuf_addstr(&buf
, transport
->url
);
290 strbuf_addch(&buf
, '/');
292 memset(&rsync
, 0, sizeof(rsync
));
294 rsync
.stdout_to_stderr
= 1;
298 if (flags
& TRANSPORT_PUSH_DRY_RUN
)
299 args
[i
++] = "--dry-run";
300 if (transport
->verbose
> 0)
302 args
[i
++] = "--ignore-existing";
303 args
[i
++] = "--exclude";
305 args
[i
++] = get_object_directory();
309 if (run_command(&rsync
))
310 return error("Could not push objects to %s", transport
->url
);
312 /* copy the refs to the temporary directory; they could be packed. */
314 strbuf_addstr(&temp_dir
, git_path("rsync-refs-XXXXXX"));
315 if (!mkdtemp(temp_dir
.buf
))
316 die ("Could not make temporary directory");
317 strbuf_addch(&temp_dir
, '/');
319 if (flags
& TRANSPORT_PUSH_ALL
) {
320 if (for_each_ref(write_one_ref
, &temp_dir
))
322 } else if (write_refs_to_temp_dir(&temp_dir
, refspec_nr
, refspec
))
326 if (flags
& TRANSPORT_PUSH_DRY_RUN
)
327 args
[i
++] = "--dry-run";
328 if (!(flags
& TRANSPORT_PUSH_FORCE
))
329 args
[i
++] = "--ignore-existing";
330 args
[i
++] = temp_dir
.buf
;
331 args
[i
++] = transport
->url
;
333 if (run_command(&rsync
))
334 result
= error("Could not push to %s", transport
->url
);
336 if (remove_dir_recursively(&temp_dir
, 0))
337 warning ("Could not remove temporary directory %s.",
340 strbuf_release(&buf
);
341 strbuf_release(&temp_dir
);
346 /* Generic functions for using commit walkers */
348 static int fetch_objs_via_walker(struct transport
*transport
,
349 int nr_objs
, struct ref
**to_fetch
)
351 char *dest
= xstrdup(transport
->url
);
352 struct walker
*walker
= transport
->data
;
353 char **objs
= xmalloc(nr_objs
* sizeof(*objs
));
357 walker
->get_tree
= 1;
358 walker
->get_history
= 1;
359 walker
->get_verbosely
= transport
->verbose
>= 0;
360 walker
->get_recover
= 0;
362 for (i
= 0; i
< nr_objs
; i
++)
363 objs
[i
] = xstrdup(sha1_to_hex(to_fetch
[i
]->old_sha1
));
365 if (walker_fetch(walker
, nr_objs
, objs
, NULL
, NULL
))
366 die("Fetch failed.");
368 for (i
= 0; i
< nr_objs
; i
++)
375 static int disconnect_walker(struct transport
*transport
)
377 struct walker
*walker
= transport
->data
;
384 static int curl_transport_push(struct transport
*transport
, int refspec_nr
, const char **refspec
, int flags
) {
389 argv
= xmalloc((refspec_nr
+ 11) * sizeof(char *));
390 argv
[0] = "http-push";
392 if (flags
& TRANSPORT_PUSH_ALL
)
393 argv
[argc
++] = "--all";
394 if (flags
& TRANSPORT_PUSH_FORCE
)
395 argv
[argc
++] = "--force";
396 if (flags
& TRANSPORT_PUSH_DRY_RUN
)
397 argv
[argc
++] = "--dry-run";
398 argv
[argc
++] = transport
->url
;
400 argv
[argc
++] = *refspec
++;
402 err
= run_command_v_opt(argv
, RUN_GIT_CMD
);
404 case -ERR_RUN_COMMAND_FORK
:
405 error("unable to fork for %s", argv
[0]);
406 case -ERR_RUN_COMMAND_EXEC
:
407 error("unable to exec %s", argv
[0]);
409 case -ERR_RUN_COMMAND_WAITPID
:
410 case -ERR_RUN_COMMAND_WAITPID_WRONG_PID
:
411 case -ERR_RUN_COMMAND_WAITPID_SIGNAL
:
412 case -ERR_RUN_COMMAND_WAITPID_NOEXIT
:
413 error("%s died with strange error", argv
[0]);
418 static int missing__target(int code
, int result
)
420 return /* file:// URL -- do we ever use one??? */
421 (result
== CURLE_FILE_COULDNT_READ_FILE
) ||
422 /* http:// and https:// URL */
423 (code
== 404 && result
== CURLE_HTTP_RETURNED_ERROR
) ||
425 (code
== 550 && result
== CURLE_FTP_COULDNT_RETR_FILE
)
429 #define missing_target(a) missing__target((a)->http_code, (a)->curl_result)
431 static struct ref
*get_refs_via_curl(struct transport
*transport
)
433 struct buffer buffer
;
434 char *data
, *start
, *mid
;
439 struct active_request_slot
*slot
;
440 struct slot_results results
;
442 struct ref
*refs
= NULL
;
443 struct ref
*ref
= NULL
;
444 struct ref
*last_ref
= NULL
;
446 data
= xmalloc(4096);
449 buffer
.buffer
= data
;
451 refs_url
= xmalloc(strlen(transport
->url
) + 11);
452 sprintf(refs_url
, "%s/info/refs", transport
->url
);
456 slot
= get_active_slot();
457 slot
->results
= &results
;
458 curl_easy_setopt(slot
->curl
, CURLOPT_FILE
, &buffer
);
459 curl_easy_setopt(slot
->curl
, CURLOPT_WRITEFUNCTION
, fwrite_buffer
);
460 curl_easy_setopt(slot
->curl
, CURLOPT_URL
, refs_url
);
461 curl_easy_setopt(slot
->curl
, CURLOPT_HTTPHEADER
, NULL
);
462 if (start_active_slot(slot
)) {
463 run_active_slot(slot
);
464 if (results
.curl_result
!= CURLE_OK
) {
465 if (missing_target(&results
)) {
470 error("%s", curl_errorstr
);
476 error("Unable to start request");
482 data
= buffer
.buffer
;
485 while (i
< buffer
.posn
) {
490 if (data
[i
] == '\n') {
493 ref
= xmalloc(sizeof(struct ref
) +
494 strlen(ref_name
) + 1);
495 memset(ref
, 0, sizeof(struct ref
));
496 strcpy(ref
->name
, ref_name
);
497 get_sha1_hex(start
, ref
->old_sha1
);
501 last_ref
->next
= ref
;
513 static int fetch_objs_via_curl(struct transport
*transport
,
514 int nr_objs
, struct ref
**to_fetch
)
516 if (!transport
->data
)
517 transport
->data
= get_http_walker(transport
->url
);
518 return fetch_objs_via_walker(transport
, nr_objs
, to_fetch
);
523 struct bundle_transport_data
{
525 struct bundle_header header
;
528 static struct ref
*get_refs_from_bundle(struct transport
*transport
)
530 struct bundle_transport_data
*data
= transport
->data
;
531 struct ref
*result
= NULL
;
536 data
->fd
= read_bundle_header(transport
->url
, &data
->header
);
538 die ("Could not read bundle '%s'.", transport
->url
);
539 for (i
= 0; i
< data
->header
.references
.nr
; i
++) {
540 struct ref_list_entry
*e
= data
->header
.references
.list
+ i
;
541 struct ref
*ref
= alloc_ref(strlen(e
->name
) + 1);
542 hashcpy(ref
->old_sha1
, e
->sha1
);
543 strcpy(ref
->name
, e
->name
);
550 static int fetch_refs_from_bundle(struct transport
*transport
,
551 int nr_heads
, struct ref
**to_fetch
)
553 struct bundle_transport_data
*data
= transport
->data
;
554 return unbundle(&data
->header
, data
->fd
);
557 static int close_bundle(struct transport
*transport
)
559 struct bundle_transport_data
*data
= transport
->data
;
566 struct git_transport_data
{
570 const char *uploadpack
;
571 const char *receivepack
;
574 static int set_git_option(struct transport
*connection
,
575 const char *name
, const char *value
)
577 struct git_transport_data
*data
= connection
->data
;
578 if (!strcmp(name
, TRANS_OPT_UPLOADPACK
)) {
579 data
->uploadpack
= value
;
581 } else if (!strcmp(name
, TRANS_OPT_RECEIVEPACK
)) {
582 data
->receivepack
= value
;
584 } else if (!strcmp(name
, TRANS_OPT_THIN
)) {
585 data
->thin
= !!value
;
587 } else if (!strcmp(name
, TRANS_OPT_KEEP
)) {
588 data
->keep
= !!value
;
590 } else if (!strcmp(name
, TRANS_OPT_DEPTH
)) {
594 data
->depth
= atoi(value
);
600 static struct ref
*get_refs_via_connect(struct transport
*transport
)
602 struct git_transport_data
*data
= transport
->data
;
605 char *dest
= xstrdup(transport
->url
);
606 struct child_process
*conn
= git_connect(fd
, dest
, data
->uploadpack
, 0);
608 get_remote_heads(fd
[0], &refs
, 0, NULL
, 0);
611 finish_connect(conn
);
618 static int fetch_refs_via_pack(struct transport
*transport
,
619 int nr_heads
, struct ref
**to_fetch
)
621 struct git_transport_data
*data
= transport
->data
;
622 char **heads
= xmalloc(nr_heads
* sizeof(*heads
));
623 char **origh
= xmalloc(nr_heads
* sizeof(*origh
));
625 char *dest
= xstrdup(transport
->url
);
626 struct fetch_pack_args args
;
629 memset(&args
, 0, sizeof(args
));
630 args
.uploadpack
= data
->uploadpack
;
631 args
.keep_pack
= data
->keep
;
633 args
.use_thin_pack
= data
->thin
;
634 args
.verbose
= transport
->verbose
> 0;
635 args
.depth
= data
->depth
;
637 for (i
= 0; i
< nr_heads
; i
++)
638 origh
[i
] = heads
[i
] = xstrdup(to_fetch
[i
]->name
);
639 refs
= fetch_pack(&args
, dest
, nr_heads
, heads
, &transport
->pack_lockfile
);
641 for (i
= 0; i
< nr_heads
; i
++)
650 static int git_transport_push(struct transport
*transport
, int refspec_nr
, const char **refspec
, int flags
) {
651 struct git_transport_data
*data
= transport
->data
;
652 struct send_pack_args args
;
654 args
.receivepack
= data
->receivepack
;
655 args
.send_all
= !!(flags
& TRANSPORT_PUSH_ALL
);
656 args
.force_update
= !!(flags
& TRANSPORT_PUSH_FORCE
);
657 args
.use_thin_pack
= data
->thin
;
658 args
.verbose
= transport
->verbose
;
659 args
.dry_run
= !!(flags
& TRANSPORT_PUSH_DRY_RUN
);
661 return send_pack(&args
, transport
->url
, transport
->remote
, refspec_nr
, refspec
);
664 static int disconnect_git(struct transport
*transport
)
666 free(transport
->data
);
670 static int is_local(const char *url
)
672 const char *colon
= strchr(url
, ':');
673 const char *slash
= strchr(url
, '/');
674 return !colon
|| (slash
&& slash
< colon
);
677 static int is_file(const char *url
)
682 return S_ISREG(buf
.st_mode
);
685 struct transport
*transport_get(struct remote
*remote
, const char *url
)
687 struct transport
*ret
= xcalloc(1, sizeof(*ret
));
689 ret
->remote
= remote
;
692 if (!prefixcmp(url
, "rsync://")) {
693 ret
->get_refs_list
= get_refs_via_rsync
;
694 ret
->fetch
= fetch_objs_via_rsync
;
695 ret
->push
= rsync_transport_push
;
697 } else if (!prefixcmp(url
, "http://")
698 || !prefixcmp(url
, "https://")
699 || !prefixcmp(url
, "ftp://")) {
701 error("git was compiled without libcurl support.");
703 ret
->get_refs_list
= get_refs_via_curl
;
704 ret
->fetch
= fetch_objs_via_curl
;
705 ret
->push
= curl_transport_push
;
707 ret
->disconnect
= disconnect_walker
;
709 } else if (is_local(url
) && is_file(url
)) {
710 struct bundle_transport_data
*data
= xcalloc(1, sizeof(*data
));
712 ret
->get_refs_list
= get_refs_from_bundle
;
713 ret
->fetch
= fetch_refs_from_bundle
;
714 ret
->disconnect
= close_bundle
;
717 struct git_transport_data
*data
= xcalloc(1, sizeof(*data
));
719 ret
->set_option
= set_git_option
;
720 ret
->get_refs_list
= get_refs_via_connect
;
721 ret
->fetch
= fetch_refs_via_pack
;
722 ret
->push
= git_transport_push
;
723 ret
->disconnect
= disconnect_git
;
726 data
->uploadpack
= "git-upload-pack";
727 if (remote
&& remote
->uploadpack
)
728 data
->uploadpack
= remote
->uploadpack
;
729 data
->receivepack
= "git-receive-pack";
730 if (remote
&& remote
->receivepack
)
731 data
->receivepack
= remote
->receivepack
;
737 int transport_set_option(struct transport
*transport
,
738 const char *name
, const char *value
)
740 if (transport
->set_option
)
741 return transport
->set_option(transport
, name
, value
);
745 int transport_push(struct transport
*transport
,
746 int refspec_nr
, const char **refspec
, int flags
)
748 if (!transport
->push
)
750 return transport
->push(transport
, refspec_nr
, refspec
, flags
);
753 const struct ref
*transport_get_remote_refs(struct transport
*transport
)
755 if (!transport
->remote_refs
)
756 transport
->remote_refs
= transport
->get_refs_list(transport
);
757 return transport
->remote_refs
;
760 int transport_fetch_refs(struct transport
*transport
, struct ref
*refs
)
763 int nr_heads
= 0, nr_alloc
= 0;
764 struct ref
**heads
= NULL
;
767 for (rm
= refs
; rm
; rm
= rm
->next
) {
769 !hashcmp(rm
->peer_ref
->old_sha1
, rm
->old_sha1
))
771 ALLOC_GROW(heads
, nr_heads
+ 1, nr_alloc
);
772 heads
[nr_heads
++] = rm
;
775 rc
= transport
->fetch(transport
, nr_heads
, heads
);
780 void transport_unlock_pack(struct transport
*transport
)
782 if (transport
->pack_lockfile
) {
783 unlink(transport
->pack_lockfile
);
784 free(transport
->pack_lockfile
);
785 transport
->pack_lockfile
= NULL
;
789 int transport_disconnect(struct transport
*transport
)
792 if (transport
->disconnect
)
793 ret
= transport
->disconnect(transport
);