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 #else
 178
 179 static struct ref *get_refs_via_curl(const struct transport *transport)
 180 {
 181         die("Cannot fetch from '%s' without curl ...", transport->url);
 182         return NULL;
 183 }
 184
 185 #endif
 186
 187 static const struct transport_ops curl_transport = {
 188         /* set_option */        NULL,
 189         /* get_refs_list */     get_refs_via_curl,
 190         /* fetch */             fetch_objs_via_walker,
 191         /* push */              curl_transport_push,
 192         /* disconnect */        disconnect_walker
 193 };
 194
 195 struct bundle_transport_data {
 196         int fd;
 197         struct bundle_header header;
 198 };
 199
 200 static struct ref *get_refs_from_bundle(const struct transport *transport)
 201 {
 202         struct bundle_transport_data *data = transport->data;
 203         struct ref *result = NULL;
 204         int i;
 205
 206         if (data->fd > 0)
 207                 close(data->fd);
 208         data->fd = read_bundle_header(transport->url, &data->header);
 209         if (data->fd < 0)
 210                 die ("Could not read bundle '%s'.", transport->url);
 211         for (i = 0; i < data->header.references.nr; i++) {
 212                 struct ref_list_entry *e = data->header.references.list + i;
 213                 struct ref *ref = alloc_ref(strlen(e->name));
 214                 hashcpy(ref->old_sha1, e->sha1);
 215                 strcpy(ref->name, e->name);
 216                 ref->next = result;
 217                 result = ref;
 218         }
 219         return result;
 220 }
 221
 222 static int fetch_refs_from_bundle(struct transport *transport,
 223                                int nr_heads, struct ref **to_fetch)
 224 {
 225         struct bundle_transport_data *data = transport->data;
 226         return unbundle(&data->header, data->fd);
 227 }
 228
 229 static int close_bundle(struct transport *transport)
 230 {
 231         struct bundle_transport_data *data = transport->data;
 232         if (data->fd > 0)
 233                 close(data->fd);
 234         return 0;
 235 }
 236
 237 static const struct transport_ops bundle_transport = {
 238         /* set_option */        NULL,
 239         /* get_refs_list */     get_refs_from_bundle,
 240         /* fetch */             fetch_refs_from_bundle,
 241         /* push */              NULL,
 242         /* disconnect */        close_bundle
 243 };
 244
 245 struct git_transport_data {
 246         unsigned thin : 1;
 247         unsigned keep : 1;
 248
 249         int unpacklimit;
 250
 251         int depth;
 252
 253         const char *uploadpack;
 254         const char *receivepack;
 255 };
 256
 257 static int set_git_option(struct transport *connection,
 258                           const char *name, const char *value)
 259 {
 260         struct git_transport_data *data = connection->data;
 261         if (!strcmp(name, TRANS_OPT_UPLOADPACK)) {
 262                 data->uploadpack = value;
 263                 return 0;
 264         } else if (!strcmp(name, TRANS_OPT_RECEIVEPACK)) {
 265                 data->receivepack = value;
 266                 return 0;
 267         } else if (!strcmp(name, TRANS_OPT_THIN)) {
 268                 data->thin = !!value;
 269                 return 0;
 270         } else if (!strcmp(name, TRANS_OPT_KEEP)) {
 271                 data->keep = !!value;
 272                 return 0;
 273         } else if (!strcmp(name, TRANS_OPT_UNPACKLIMIT)) {
 274                 data->unpacklimit = atoi(value);
 275                 return 0;
 276         } else if (!strcmp(name, TRANS_OPT_DEPTH)) {
 277                 if (!value)
 278                         data->depth = 0;
 279                 else
 280                         data->depth = atoi(value);
 281                 return 0;
 282         }
 283         return 1;
 284 }
 285
 286 static struct ref *get_refs_via_connect(const struct transport *transport)
 287 {
 288         struct git_transport_data *data = transport->data;
 289         struct ref *refs;
 290         int fd[2];
 291         pid_t pid;
 292         char *dest = xstrdup(transport->url);
 293
 294         pid = git_connect(fd, dest, data->uploadpack, 0);
 295
 296         if (pid < 0)
 297                 die("Failed to connect to \"%s\"", transport->url);
 298
 299         get_remote_heads(fd[0], &refs, 0, NULL, 0);
 300         packet_flush(fd[1]);
 301
 302         finish_connect(pid);
 303
 304         free(dest);
 305
 306         return refs;
 307 }
 308
 309 static int fetch_refs_via_pack(struct transport *transport,
 310                                int nr_heads, struct ref **to_fetch)
 311 {
 312         struct git_transport_data *data = transport->data;
 313         char **heads = xmalloc(nr_heads * sizeof(*heads));
 314         char **origh = xmalloc(nr_heads * sizeof(*origh));
 315         struct ref *refs;
 316         char *dest = xstrdup(transport->url);
 317         struct fetch_pack_args args;
 318         int i;
 319
 320         args.uploadpack = data->uploadpack;
 321         args.quiet = 0;
 322         args.keep_pack = data->keep;
 323         args.unpacklimit = data->unpacklimit;
 324         args.use_thin_pack = data->thin;
 325         args.fetch_all = 0;
 326         args.verbose = transport->verbose;
 327         args.depth = data->depth;
 328         args.no_progress = 0;
 329
 330         setup_fetch_pack(&args);
 331
 332         for (i = 0; i < nr_heads; i++)
 333                 origh[i] = heads[i] = xstrdup(to_fetch[i]->name);
 334         refs = fetch_pack(dest, nr_heads, heads, &transport->pack_lockfile);
 335
 336         for (i = 0; i < nr_heads; i++)
 337                 free(origh[i]);
 338         free(origh);
 339         free(heads);
 340         free_refs(refs);
 341         free(dest);
 342         return 0;
 343 }
 344
 345 static int git_transport_push(struct transport *transport, int refspec_nr, const char **refspec, int flags) {
 346         struct git_transport_data *data = transport->data;
 347         const char **argv;
 348         char *rem;
 349         int argc;
 350         int err;
 351
 352         argv = xmalloc((refspec_nr + 11) * sizeof(char *));
 353         argv[0] = "send-pack";
 354         argc = 1;
 355         if (flags & TRANSPORT_PUSH_ALL)
 356                 argv[argc++] = "--all";
 357         if (flags & TRANSPORT_PUSH_FORCE)
 358                 argv[argc++] = "--force";
 359         if (data->receivepack) {
 360                 char *rp = xmalloc(strlen(data->receivepack) + 16);
 361                 sprintf(rp, "--receive-pack=%s", data->receivepack);
 362                 argv[argc++] = rp;
 363         }
 364         if (data->thin)
 365                 argv[argc++] = "--thin";
 366         rem = xmalloc(strlen(transport->remote->name) + 10);
 367         sprintf(rem, "--remote=%s", transport->remote->name);
 368         argv[argc++] = rem;
 369         argv[argc++] = transport->url;
 370         while (refspec_nr--)
 371                 argv[argc++] = *refspec++;
 372         argv[argc] = NULL;
 373         err = run_command_v_opt(argv, RUN_GIT_CMD);
 374         switch (err) {
 375         case -ERR_RUN_COMMAND_FORK:
 376                 error("unable to fork for %s", argv[0]);
 377         case -ERR_RUN_COMMAND_EXEC:
 378                 error("unable to exec %s", argv[0]);
 379                 break;
 380         case -ERR_RUN_COMMAND_WAITPID:
 381         case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
 382         case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
 383         case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
 384                 error("%s died with strange error", argv[0]);
 385         }
 386         return !!err;
 387 }
 388
 389 static const struct transport_ops git_transport = {
 390         /* set_option */        set_git_option,
 391         /* get_refs_list */     get_refs_via_connect,
 392         /* fetch */             fetch_refs_via_pack,
 393         /* push */              git_transport_push
 394 };
 395
 396 static int is_local(const char *url)
 397 {
 398         const char *colon = strchr(url, ':');
 399         const char *slash = strchr(url, '/');
 400         return !colon || (slash && slash < colon);
 401 }
 402
 403 static int is_file(const char *url)
 404 {
 405         struct stat buf;
 406         if (stat(url, &buf))
 407                 return 0;
 408         return S_ISREG(buf.st_mode);
 409 }
 410
 411 struct transport *transport_get(struct remote *remote, const char *url,
 412                                 int fetch)
 413 {
 414         struct transport *ret = NULL;
 415         if (!prefixcmp(url, "rsync://")) {
 416                 ret = xmalloc(sizeof(*ret));
 417                 ret->data = NULL;
 418                 ret->ops = &rsync_transport;
 419         } else if (!prefixcmp(url, "http://") || !prefixcmp(url, "https://") ||
 420                    !prefixcmp(url, "ftp://")) {
 421                 ret = xmalloc(sizeof(*ret));
 422                 ret->ops = &curl_transport;
 423                 if (fetch)
 424                         ret->data = get_http_walker(url);
 425                 else
 426                         ret->data = NULL;
 427         } else if (is_local(url) && is_file(url)) {
 428                 struct bundle_transport_data *data = xcalloc(1, sizeof(*data));
 429                 ret = xmalloc(sizeof(*ret));
 430                 ret->data = data;
 431                 ret->ops = &bundle_transport;
 432         } else {
 433                 struct git_transport_data *data = xcalloc(1, sizeof(*data));
 434                 ret = xcalloc(1, sizeof(*ret));
 435                 ret->data = data;
 436                 data->thin = 1;
 437                 data->uploadpack = "git-upload-pack";
 438                 if (remote && remote->uploadpack)
 439                         data->uploadpack = remote->uploadpack;
 440                 data->receivepack = "git-receive-pack";
 441                 if (remote && remote->receivepack)
 442                         data->receivepack = remote->receivepack;
 443                 data->unpacklimit = -1;
 444                 ret->ops = &git_transport;
 445         }
 446         if (ret) {
 447                 ret->remote = remote;
 448                 ret->url = url;
 449                 ret->remote_refs = NULL;
 450                 ret->fetch = !!fetch;
 451                 ret->pack_lockfile = NULL;
 452         }
 453         return ret;
 454 }
 455
 456 int transport_set_option(struct transport *transport,
 457                          const char *name, const char *value)
 458 {
 459         int ret = 1;
 460         if (transport->ops->set_option)
 461                 ret = transport->ops->set_option(transport, name, value);
 462         if (ret < 0)
 463                 fprintf(stderr, "For '%s' option %s cannot be set to '%s'\n",
 464                         transport->url, name, value);
 465         if (ret > 0)
 466                 fprintf(stderr, "For '%s' option %s is ignored\n",
 467                         transport->url, name);
 468         return ret;
 469 }
 470
 471 int transport_push(struct transport *transport,
 472                    int refspec_nr, const char **refspec, int flags)
 473 {
 474         if (!transport->ops->push)
 475                 return 1;
 476         return transport->ops->push(transport, refspec_nr, refspec, flags);
 477 }
 478
 479 struct ref *transport_get_remote_refs(struct transport *transport)
 480 {
 481         if (!transport->remote_refs)
 482                 transport->remote_refs =
 483                         transport->ops->get_refs_list(transport);
 484         return transport->remote_refs;
 485 }
 486
 487 int transport_fetch_refs(struct transport *transport, struct ref *refs)
 488 {
 489         int rc;
 490         int nr_heads = 0, nr_alloc = 0;
 491         struct ref **heads = NULL;
 492         struct ref *rm;
 493
 494         for (rm = refs; rm; rm = rm->next) {
 495                 if (rm->peer_ref &&
 496                     !hashcmp(rm->peer_ref->old_sha1, rm->old_sha1))
 497                         continue;
 498                 ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
 499                 heads[nr_heads++] = rm;
 500         }
 501
 502         rc = transport->ops->fetch(transport, nr_heads, heads);
 503         free(heads);
 504         return rc;
 505 }
 506
 507 void transport_unlock_pack(struct transport *transport)
 508 {
 509         if (transport->pack_lockfile) {
 510                 unlink(transport->pack_lockfile);
 511                 free(transport->pack_lockfile);
 512                 transport->pack_lockfile = NULL;
 513         }
 514 }
 515
 516 int transport_disconnect(struct transport *transport)
 517 {
 518         int ret = 0;
 519         if (transport->ops->disconnect)
 520                 ret = transport->ops->disconnect(transport);
 521         free(transport);
 522         return ret;
 523 }