cc76e3f59ba47a5c76e375f53ff3ccf712322e59
[git/git.git] / transport.c
1 #include "cache.h"
2 #include "transport.h"
3 #include "run-command.h"
4 #include "http.h"
5 #include "pkt-line.h"
6 #include "fetch-pack.h"
7 #include "walker.h"
8 #include "bundle.h"
9
10 /* Generic functions for using commit walkers */
11
12 static int fetch_objs_via_walker(struct transport *transport,
13 int nr_objs, struct ref **to_fetch)
14 {
15 char *dest = xstrdup(transport->url);
16 struct walker *walker = transport->data;
17 char **objs = xmalloc(nr_objs * sizeof(*objs));
18 int i;
19
20 walker->get_all = 1;
21 walker->get_tree = 1;
22 walker->get_history = 1;
23 walker->get_verbosely = transport->verbose;
24 walker->get_recover = 0;
25
26 for (i = 0; i < nr_objs; i++)
27 objs[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
28
29 if (walker_fetch(walker, nr_objs, objs, NULL, NULL))
30 die("Fetch failed.");
31
32 for (i = 0; i < nr_objs; i++)
33 free(objs[i]);
34 free(objs);
35 free(dest);
36 return 0;
37 }
38
39 static int disconnect_walker(struct transport *transport)
40 {
41 struct walker *walker = transport->data;
42 if (walker)
43 walker_free(walker);
44 return 0;
45 }
46
47 static const struct transport_ops rsync_transport;
48
49 static int curl_transport_push(struct transport *transport, int refspec_nr, const char **refspec, int flags) {
50 const char **argv;
51 int argc;
52 int err;
53
54 argv = xmalloc((refspec_nr + 11) * sizeof(char *));
55 argv[0] = "http-push";
56 argc = 1;
57 if (flags & TRANSPORT_PUSH_ALL)
58 argv[argc++] = "--all";
59 if (flags & TRANSPORT_PUSH_FORCE)
60 argv[argc++] = "--force";
61 argv[argc++] = transport->url;
62 while (refspec_nr--)
63 argv[argc++] = *refspec++;
64 argv[argc] = NULL;
65 err = run_command_v_opt(argv, RUN_GIT_CMD);
66 switch (err) {
67 case -ERR_RUN_COMMAND_FORK:
68 error("unable to fork for %s", argv[0]);
69 case -ERR_RUN_COMMAND_EXEC:
70 error("unable to exec %s", argv[0]);
71 break;
72 case -ERR_RUN_COMMAND_WAITPID:
73 case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
74 case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
75 case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
76 error("%s died with strange error", argv[0]);
77 }
78 return !!err;
79 }
80
81 #ifndef NO_CURL
82 static int missing__target(int code, int result)
83 {
84 return /* file:// URL -- do we ever use one??? */
85 (result == CURLE_FILE_COULDNT_READ_FILE) ||
86 /* http:// and https:// URL */
87 (code == 404 && result == CURLE_HTTP_RETURNED_ERROR) ||
88 /* ftp:// URL */
89 (code == 550 && result == CURLE_FTP_COULDNT_RETR_FILE)
90 ;
91 }
92
93 #define missing_target(a) missing__target((a)->http_code, (a)->curl_result)
94
95 static struct ref *get_refs_via_curl(const struct transport *transport)
96 {
97 struct buffer buffer;
98 char *data, *start, *mid;
99 char *ref_name;
100 char *refs_url;
101 int i = 0;
102
103 struct active_request_slot *slot;
104 struct slot_results results;
105
106 struct ref *refs = NULL;
107 struct ref *ref = NULL;
108 struct ref *last_ref = NULL;
109
110 data = xmalloc(4096);
111 buffer.size = 4096;
112 buffer.posn = 0;
113 buffer.buffer = data;
114
115 refs_url = xmalloc(strlen(transport->url) + 11);
116 sprintf(refs_url, "%s/info/refs", transport->url);
117
118 http_init();
119
120 slot = get_active_slot();
121 slot->results = &results;
122 curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
123 curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
124 curl_easy_setopt(slot->curl, CURLOPT_URL, refs_url);
125 curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
126 if (start_active_slot(slot)) {
127 run_active_slot(slot);
128 if (results.curl_result != CURLE_OK) {
129 if (missing_target(&results)) {
130 free(buffer.buffer);
131 return NULL;
132 } else {
133 free(buffer.buffer);
134 error("%s", curl_errorstr);
135 return NULL;
136 }
137 }
138 } else {
139 free(buffer.buffer);
140 error("Unable to start request");
141 return NULL;
142 }
143
144 http_cleanup();
145
146 data = buffer.buffer;
147 start = NULL;
148 mid = data;
149 while (i < buffer.posn) {
150 if (!start)
151 start = &data[i];
152 if (data[i] == '\t')
153 mid = &data[i];
154 if (data[i] == '\n') {
155 data[i] = 0;
156 ref_name = mid + 1;
157 ref = xmalloc(sizeof(struct ref) +
158 strlen(ref_name) + 1);
159 memset(ref, 0, sizeof(struct ref));
160 strcpy(ref->name, ref_name);
161 get_sha1_hex(start, ref->old_sha1);
162 if (!refs)
163 refs = ref;
164 if (last_ref)
165 last_ref->next = ref;
166 last_ref = ref;
167 start = NULL;
168 }
169 i++;
170 }
171
172 free(buffer.buffer);
173
174 return refs;
175 }
176
177 static int fetch_objs_via_curl(struct transport *transport,
178 int nr_objs, struct ref **to_fetch)
179 {
180 if (!transport->data)
181 transport->data = get_http_walker(transport->url);
182 return fetch_objs_via_walker(transport, nr_objs, to_fetch);
183 }
184
185 #else
186
187 static struct ref *get_refs_via_curl(const struct transport *transport)
188 {
189 die("Cannot fetch from '%s' without curl ...", transport->url);
190 return NULL;
191 }
192
193 static int fetch_objs_via_curl(struct transport *transport,
194 int nr_objs, struct ref **to_fetch)
195 {
196 die("Cannot fetch from '%s' without curl ...", transport->url);
197 return -1;
198 }
199
200 #endif
201
202 static const struct transport_ops curl_transport = {
203 /* set_option */ NULL,
204 /* get_refs_list */ get_refs_via_curl,
205 /* fetch */ fetch_objs_via_curl,
206 /* push */ curl_transport_push,
207 /* disconnect */ disconnect_walker
208 };
209
210 struct bundle_transport_data {
211 int fd;
212 struct bundle_header header;
213 };
214
215 static struct ref *get_refs_from_bundle(const struct transport *transport)
216 {
217 struct bundle_transport_data *data = transport->data;
218 struct ref *result = NULL;
219 int i;
220
221 if (data->fd > 0)
222 close(data->fd);
223 data->fd = read_bundle_header(transport->url, &data->header);
224 if (data->fd < 0)
225 die ("Could not read bundle '%s'.", transport->url);
226 for (i = 0; i < data->header.references.nr; i++) {
227 struct ref_list_entry *e = data->header.references.list + i;
228 struct ref *ref = alloc_ref(strlen(e->name));
229 hashcpy(ref->old_sha1, e->sha1);
230 strcpy(ref->name, e->name);
231 ref->next = result;
232 result = ref;
233 }
234 return result;
235 }
236
237 static int fetch_refs_from_bundle(struct transport *transport,
238 int nr_heads, struct ref **to_fetch)
239 {
240 struct bundle_transport_data *data = transport->data;
241 return unbundle(&data->header, data->fd);
242 }
243
244 static int close_bundle(struct transport *transport)
245 {
246 struct bundle_transport_data *data = transport->data;
247 if (data->fd > 0)
248 close(data->fd);
249 return 0;
250 }
251
252 static const struct transport_ops bundle_transport = {
253 /* set_option */ NULL,
254 /* get_refs_list */ get_refs_from_bundle,
255 /* fetch */ fetch_refs_from_bundle,
256 /* push */ NULL,
257 /* disconnect */ close_bundle
258 };
259
260 struct git_transport_data {
261 unsigned thin : 1;
262 unsigned keep : 1;
263
264 int unpacklimit;
265
266 int depth;
267
268 const char *uploadpack;
269 const char *receivepack;
270 };
271
272 static int set_git_option(struct transport *connection,
273 const char *name, const char *value)
274 {
275 struct git_transport_data *data = connection->data;
276 if (!strcmp(name, TRANS_OPT_UPLOADPACK)) {
277 data->uploadpack = value;
278 return 0;
279 } else if (!strcmp(name, TRANS_OPT_RECEIVEPACK)) {
280 data->receivepack = value;
281 return 0;
282 } else if (!strcmp(name, TRANS_OPT_THIN)) {
283 data->thin = !!value;
284 return 0;
285 } else if (!strcmp(name, TRANS_OPT_KEEP)) {
286 data->keep = !!value;
287 return 0;
288 } else if (!strcmp(name, TRANS_OPT_UNPACKLIMIT)) {
289 data->unpacklimit = atoi(value);
290 return 0;
291 } else if (!strcmp(name, TRANS_OPT_DEPTH)) {
292 if (!value)
293 data->depth = 0;
294 else
295 data->depth = atoi(value);
296 return 0;
297 }
298 return 1;
299 }
300
301 static struct ref *get_refs_via_connect(const struct transport *transport)
302 {
303 struct git_transport_data *data = transport->data;
304 struct ref *refs;
305 int fd[2];
306 pid_t pid;
307 char *dest = xstrdup(transport->url);
308
309 pid = git_connect(fd, dest, data->uploadpack, 0);
310
311 if (pid < 0)
312 die("Failed to connect to \"%s\"", transport->url);
313
314 get_remote_heads(fd[0], &refs, 0, NULL, 0);
315 packet_flush(fd[1]);
316
317 finish_connect(pid);
318
319 free(dest);
320
321 return refs;
322 }
323
324 static int fetch_refs_via_pack(struct transport *transport,
325 int nr_heads, struct ref **to_fetch)
326 {
327 struct git_transport_data *data = transport->data;
328 char **heads = xmalloc(nr_heads * sizeof(*heads));
329 char **origh = xmalloc(nr_heads * sizeof(*origh));
330 struct ref *refs;
331 char *dest = xstrdup(transport->url);
332 struct fetch_pack_args args;
333 int i;
334
335 args.uploadpack = data->uploadpack;
336 args.quiet = 0;
337 args.keep_pack = data->keep;
338 args.unpacklimit = data->unpacklimit;
339 args.use_thin_pack = data->thin;
340 args.fetch_all = 0;
341 args.verbose = transport->verbose;
342 args.depth = data->depth;
343 args.no_progress = 0;
344
345 setup_fetch_pack(&args);
346
347 for (i = 0; i < nr_heads; i++)
348 origh[i] = heads[i] = xstrdup(to_fetch[i]->name);
349 refs = fetch_pack(dest, nr_heads, heads, &transport->pack_lockfile);
350
351 for (i = 0; i < nr_heads; i++)
352 free(origh[i]);
353 free(origh);
354 free(heads);
355 free_refs(refs);
356 free(dest);
357 return 0;
358 }
359
360 static int git_transport_push(struct transport *transport, int refspec_nr, const char **refspec, int flags) {
361 struct git_transport_data *data = transport->data;
362 const char **argv;
363 char *rem;
364 int argc;
365 int err;
366
367 argv = xmalloc((refspec_nr + 11) * sizeof(char *));
368 argv[0] = "send-pack";
369 argc = 1;
370 if (flags & TRANSPORT_PUSH_ALL)
371 argv[argc++] = "--all";
372 if (flags & TRANSPORT_PUSH_FORCE)
373 argv[argc++] = "--force";
374 if (data->receivepack) {
375 char *rp = xmalloc(strlen(data->receivepack) + 16);
376 sprintf(rp, "--receive-pack=%s", data->receivepack);
377 argv[argc++] = rp;
378 }
379 if (data->thin)
380 argv[argc++] = "--thin";
381 rem = xmalloc(strlen(transport->remote->name) + 10);
382 sprintf(rem, "--remote=%s", transport->remote->name);
383 argv[argc++] = rem;
384 argv[argc++] = transport->url;
385 while (refspec_nr--)
386 argv[argc++] = *refspec++;
387 argv[argc] = NULL;
388 err = run_command_v_opt(argv, RUN_GIT_CMD);
389 switch (err) {
390 case -ERR_RUN_COMMAND_FORK:
391 error("unable to fork for %s", argv[0]);
392 case -ERR_RUN_COMMAND_EXEC:
393 error("unable to exec %s", argv[0]);
394 break;
395 case -ERR_RUN_COMMAND_WAITPID:
396 case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
397 case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
398 case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
399 error("%s died with strange error", argv[0]);
400 }
401 return !!err;
402 }
403
404 static const struct transport_ops git_transport = {
405 /* set_option */ set_git_option,
406 /* get_refs_list */ get_refs_via_connect,
407 /* fetch */ fetch_refs_via_pack,
408 /* push */ git_transport_push
409 };
410
411 static int is_local(const char *url)
412 {
413 const char *colon = strchr(url, ':');
414 const char *slash = strchr(url, '/');
415 return !colon || (slash && slash < colon);
416 }
417
418 static int is_file(const char *url)
419 {
420 struct stat buf;
421 if (stat(url, &buf))
422 return 0;
423 return S_ISREG(buf.st_mode);
424 }
425
426 struct transport *transport_get(struct remote *remote, const char *url)
427 {
428 struct transport *ret = xcalloc(1, sizeof(*ret));
429
430 ret->remote = remote;
431 ret->url = url;
432
433 if (!prefixcmp(url, "rsync://")) {
434 ret->ops = &rsync_transport;
435 } else if (!prefixcmp(url, "http://")
436 || !prefixcmp(url, "https://")
437 || !prefixcmp(url, "ftp://")) {
438 ret->ops = &curl_transport;
439 } else if (is_local(url) && is_file(url)) {
440 struct bundle_transport_data *data = xcalloc(1, sizeof(*data));
441 ret->data = data;
442 ret->ops = &bundle_transport;
443 } else {
444 struct git_transport_data *data = xcalloc(1, sizeof(*data));
445 ret->data = data;
446 data->thin = 1;
447 data->uploadpack = "git-upload-pack";
448 if (remote && remote->uploadpack)
449 data->uploadpack = remote->uploadpack;
450 data->receivepack = "git-receive-pack";
451 if (remote && remote->receivepack)
452 data->receivepack = remote->receivepack;
453 data->unpacklimit = -1;
454 ret->ops = &git_transport;
455 }
456
457 return ret;
458 }
459
460 int transport_set_option(struct transport *transport,
461 const char *name, const char *value)
462 {
463 if (transport->ops->set_option)
464 return transport->ops->set_option(transport, name, value);
465 return 1;
466 }
467
468 int transport_push(struct transport *transport,
469 int refspec_nr, const char **refspec, int flags)
470 {
471 if (!transport->ops->push)
472 return 1;
473 return transport->ops->push(transport, refspec_nr, refspec, flags);
474 }
475
476 struct ref *transport_get_remote_refs(struct transport *transport)
477 {
478 if (!transport->remote_refs)
479 transport->remote_refs =
480 transport->ops->get_refs_list(transport);
481 return transport->remote_refs;
482 }
483
484 int transport_fetch_refs(struct transport *transport, struct ref *refs)
485 {
486 int rc;
487 int nr_heads = 0, nr_alloc = 0;
488 struct ref **heads = NULL;
489 struct ref *rm;
490
491 for (rm = refs; rm; rm = rm->next) {
492 if (rm->peer_ref &&
493 !hashcmp(rm->peer_ref->old_sha1, rm->old_sha1))
494 continue;
495 ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
496 heads[nr_heads++] = rm;
497 }
498
499 rc = transport->ops->fetch(transport, nr_heads, heads);
500 free(heads);
501 return rc;
502 }
503
504 void transport_unlock_pack(struct transport *transport)
505 {
506 if (transport->pack_lockfile) {
507 unlink(transport->pack_lockfile);
508 free(transport->pack_lockfile);
509 transport->pack_lockfile = NULL;
510 }
511 }
512
513 int transport_disconnect(struct transport *transport)
514 {
515 int ret = 0;
516 if (transport->ops->disconnect)
517 ret = transport->ops->disconnect(transport);
518 free(transport);
519 return ret;
520 }