libexec/got-fetch-http/got-fetch-http.c

   1 /*
   2  * Copyright (c) 2024 Tobias Heider <me@tobhe.de>
   3  * Copyright (c) 2022 Omar Polo <op@openbsd.org>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include "got_compat.h"
  19
  20 #include <sys/types.h>
  21 #include <sys/queue.h>
  22 #include <sys/socket.h>
  23
  24 #include <err.h>
  25 #include <errno.h>
  26 #include <limits.h>
  27 #include <netdb.h>
  28 #include <poll.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <tls.h>
  33 #include <unistd.h>
  34
  35 #include "got_error.h"
  36 #include "got_path.h"
  37 #include "got_version.h"
  38
  39 #include "got_lib_pkt.h"
  40
  41 #include "bufio.h"
  42
  43 #define UPLOAD_PACK_ADV "application/x-git-upload-pack-advertisement"
  44 #define UPLOAD_PACK_REQ "application/x-git-upload-pack-request"
  45 #define UPLOAD_PACK_RES "application/x-git-upload-pack-result"
  46
  47 #define GOT_USERAGENT   "got/" GOT_VERSION_STR
  48 #define MINIMUM(a, b)   ((a) < (b) ? (a) : (b))
  49 #define hasprfx(str, p) (strncasecmp(str, p, strlen(p)) == 0)
  50
  51 FILE *tmp;
  52
  53 static int      verbose;
  54
  55 static char *
  56 bufio_getdelim_sync(struct bufio *bio, const char *nl, size_t *len)
  57 {
  58         int     r;
  59
  60         do {
  61                 r = bufio_read(bio);
  62                 if (r == -1 && errno != EAGAIN)
  63                         errx(1, "bufio_read: %s", bufio_io_err(bio));
  64         } while (r == -1 && errno == EAGAIN);
  65         return buf_getdelim(&bio->rbuf, nl, len);
  66 }
  67
  68 static size_t
  69 bufio_drain_sync(struct bufio *bio, void *d, size_t len)
  70 {
  71         int     r;
  72
  73         do {
  74                 r = bufio_read(bio);
  75                 if (r == -1 && errno != EAGAIN)
  76                         errx(1, "bufio_read: %s", bufio_io_err(bio));
  77         } while (r == -1 && errno == EAGAIN);
  78         return bufio_drain(bio, d, len);
  79 }
  80
  81 static void
  82 bufio_close_sync(struct bufio *bio)
  83 {
  84         int      r;
  85
  86         do {
  87                 r = bufio_close(bio);
  88                 if (r == -1 && errno != EAGAIN)
  89                         errx(1, "bufio_close: %s", bufio_io_err(bio));
  90         } while (r == -1 && errno == EAGAIN);
  91 }
  92
  93 static long long
  94 hexstrtonum(const char *str, long long min, long long max, const char **errstr)
  95 {
  96         long long        lval;
  97         char            *cp;
  98
  99         errno = 0;
 100         lval = strtoll(str, &cp, 16);
 101         if (*str == '\0' || *cp != '\0') {
 102                 *errstr = "not a number";
 103                 return 0;
 104         }
 105         if ((errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN)) ||
 106             lval < min || lval > max) {
 107                 *errstr = "out of range";
 108                 return 0;
 109         }
 110
 111         *errstr = NULL;
 112         return lval;
 113 }
 114
 115 static int
 116 dial(int https, const char *host, const char *port)
 117 {
 118         struct addrinfo          hints, *res, *res0;
 119         int                      error, saved_errno, fd = -1;
 120         const char              *cause = NULL;
 121
 122         memset(&hints, 0, sizeof(hints));
 123         hints.ai_family = AF_UNSPEC;
 124         hints.ai_socktype = SOCK_STREAM;
 125         error = getaddrinfo(host, port, &hints, &res0);
 126         if (error) {
 127                 warnx("%s", gai_strerror(error));
 128                 return -1;
 129         }
 130
 131         for (res = res0; res; res = res->ai_next) {
 132                 fd = socket(res->ai_family, res->ai_socktype,
 133                     res->ai_protocol);
 134                 if (fd == -1) {
 135                         cause = "socket";
 136                         continue;
 137                 }
 138
 139                 if (connect(fd, res->ai_addr, res->ai_addrlen) == 0)
 140                         break;
 141
 142                 cause = "connect";
 143                 saved_errno = errno;
 144                 close(fd);
 145                 fd = -1;
 146                 errno = saved_errno;
 147         }
 148         freeaddrinfo(res0);
 149
 150         if (fd == -1) {
 151                 warn("%s", cause);
 152                 return -1;
 153         }
 154
 155         return fd;
 156 }
 157
 158 static int
 159 http_open(struct bufio *bio, int https, const char *method, const char *host, const char *port,
 160     const char *path, const char *path_sufx, const char *query, const char *ctype)
 161 {
 162         const char      *chdr = NULL, *te = "";
 163         char            *p, *req;
 164         int              r;
 165
 166         if (strcmp(method, "POST") == 0)
 167                 te = "\r\nTransfer-Encoding: chunked\r\n";
 168
 169         if (ctype)
 170                 chdr = "Content-Type: ";
 171
 172         r = asprintf(&p, "%s%s/%s%s%s", got_path_is_absolute(path) ? "" :"/",
 173             path, path_sufx, query ? "?" : "", query ? query : "");
 174         if (r == -1)
 175                 err(1, "asprintf");
 176
 177         r = asprintf(&req, "%s %s HTTP/1.1\r\n"
 178             "Host: %s\r\n"
 179             "Connection: close\r\n"
 180             "User-agent: %s\r\n"
 181             "%s%s%s\r\n",
 182             method, p, host, GOT_USERAGENT,
 183             chdr ? chdr : "", ctype ? ctype : "", te);
 184         if (r == -1)
 185                 err(1, "asprintf");
 186         free(p);
 187
 188         if (verbose > 0)
 189                 fprintf(stderr, "%s: request: %s\n", getprogname(), req);
 190
 191         r = bufio_compose(bio, req, r);
 192         if (r == -1)
 193                 err(1, "bufio_compose_fmt");
 194         free(req);
 195
 196         do {
 197                 r = bufio_write(bio);
 198                 if (r == -1 && errno != EAGAIN)
 199                         errx(1, "bufio_write: %s", bufio_io_err(bio));
 200         } while (bio->wbuf.len != 0);
 201
 202         return 0;
 203 }
 204
 205 static int
 206 http_parse_reply(struct bufio *bio, int *chunked, const char *expected_ctype)
 207 {
 208         char            *cp, *line;
 209         size_t           linelen;
 210
 211         *chunked = 0;
 212
 213         line = bufio_getdelim_sync(bio, "\r\n", &linelen);
 214         if (line == NULL) {
 215                 warnx("%s: bufio_getdelim_sync()", __func__);
 216                 return -1;
 217         }
 218
 219         if (verbose > 0)
 220                 fprintf(stderr, "%s: response: %s\n", getprogname(), line);
 221
 222         if ((cp = strchr(line, ' ')) == NULL) {
 223                 warnx("malformed HTTP response");
 224                 return -1;
 225         }
 226         cp++;
 227
 228         if (strncmp(cp, "200 ", 4) != 0) {
 229                 warnx("malformed HTTP response");
 230                 return -1;
 231         }
 232         buf_drain(&bio->rbuf, linelen);
 233
 234         while(1) {
 235                 line = bufio_getdelim_sync(bio, "\r\n", &linelen);
 236                 if (line == NULL) {
 237                         warnx("%s: bufio_getdelim_sync()", __func__);
 238                         return -1;
 239                 }
 240                 if (*line == '\0') {
 241                         buf_drain(&bio->rbuf, linelen);
 242                         break;
 243                 }
 244
 245                 if (hasprfx(line, "content-type:")) {
 246                         cp = strchr(line, ':') + 1;
 247                         cp += strspn(cp, " \t");
 248                         cp[strcspn(cp, " \t")] = '\0';
 249                         if (strcmp(cp, expected_ctype) != 0) {
 250                                 warnx("server not using the \"smart\" "
 251                                     "HTTP protocol.");
 252                                 return -1;
 253                         }
 254                 }
 255                 if (hasprfx(line, "transfer-encoding:")) {
 256                         cp = strchr(line, ':') + 1;
 257                         cp += strspn(cp, " \t");
 258                         cp[strcspn(cp, " \t")] = '\0';
 259                         if (strcmp(cp, "chunked") != 0) {
 260                                 warnx("unknown transfer-encoding");
 261                                 return -1;
 262                         }
 263                         *chunked = 1;
 264                 }
 265                 buf_drain(&bio->rbuf, linelen);
 266         }
 267
 268         return 0;
 269 }
 270
 271 static ssize_t
 272 http_read(struct bufio *bio, int chunked, size_t *chunksz, char *buf, size_t bufsz)
 273 {
 274         const char      *errstr;
 275         char            *line = NULL;
 276         size_t           r;
 277         ssize_t          ret = 0, linelen;
 278
 279         if (!chunked)
 280                 return bufio_drain_sync(bio, buf, bufsz);
 281
 282         while (bufsz > 0) {
 283                 if (*chunksz == 0) {
 284                 again:
 285                         line = bufio_getdelim_sync(bio, "\r\n", &linelen);
 286                         if (line == NULL) {
 287                                 buf_drain(&bio->rbuf, linelen);
 288                                 break;
 289                         }
 290                         if (*line == '\0') {
 291                                 buf_drain(&bio->rbuf, linelen);
 292                                 goto again; /* was the CRLF after the chunk */
 293                         }
 294
 295                         *chunksz = hexstrtonum(line, 0, INT_MAX, &errstr);
 296                         if (errstr != NULL) {
 297                                 warnx("invalid HTTP chunk: size is %s (%s)",
 298                                     errstr, line);
 299                                 ret = -1;
 300                                 break;
 301                         }
 302
 303                         if (*chunksz == 0) {
 304                                 buf_drain(&bio->rbuf, linelen);
 305                                 break;
 306                         }
 307                         buf_drain(&bio->rbuf, linelen);
 308                 }
 309
 310                 r = bufio_drain_sync(bio, buf, MINIMUM(*chunksz, bufsz));
 311                 if (r == 0) {
 312                         break;
 313                 }
 314
 315                 ret += r;
 316                 buf += r;
 317                 bufsz -= r;
 318                 *chunksz -= r;
 319         }
 320
 321         return ret;
 322 }
 323
 324 static int
 325 http_chunk(struct bufio *bio, const void *buf, size_t len)
 326 {
 327         int r;
 328
 329         if (bufio_compose_fmt(bio, "%zx\r\n", len) == -1 ||
 330             bufio_compose(bio, buf, len) == -1 ||
 331             bufio_compose(bio, "\r\n", 2) == -1)
 332                 return 1;
 333
 334         do {
 335                 r = bufio_write(bio);
 336                 if (r == -1 && errno != EAGAIN)
 337                         errx(1, "bufio_read: %s", bufio_io_err(bio));
 338         } while (bio->wbuf.len != 0);
 339
 340         return 0;
 341 }
 342
 343 static int
 344 get_refs(int https, const char *host, const char *port, const char *path)
 345 {
 346         struct bufio             bio;
 347         char                     buf[GOT_PKT_MAX];
 348         const struct got_error  *e;
 349         size_t                   chunksz = 0;
 350         ssize_t                  r;
 351         int                      skip;
 352         int                      chunked;
 353         int                      sock;
 354         int                      ret = -1;
 355
 356         if ((sock = dial(https, host, port)) == -1)
 357                 return -1;
 358
 359         if (bufio_init(&bio)) {
 360                 warnx("bufio_init");
 361                 goto err;
 362         }
 363         bufio_set_fd(&bio, sock);
 364         if (https && bufio_starttls(&bio, host, 0, NULL, 0, NULL, 0) == -1) {
 365                 warnx("bufio_starttls");
 366                 goto err;
 367         }
 368
 369         if (http_open(&bio, https, "GET", host, port, path, "info/refs",
 370             "service=git-upload-pack", NULL) == -1)
 371                 goto err;
 372
 373         /* Fetch the initial reference announcement from the server. */
 374         if (http_parse_reply(&bio, &chunked, UPLOAD_PACK_ADV) == -1)
 375                 goto err;
 376
 377         /* skip first pack; why git over http is like this? */
 378         r = http_read(&bio, chunked, &chunksz, buf, 4);
 379         if (r <= 0)
 380                 goto err;
 381
 382         e = got_pkt_readlen(&skip, buf, verbose);
 383         if (e) {
 384                 warnx("%s", e->msg);
 385                 goto err;
 386         }
 387
 388         /* TODO: validate it's # service=git-upload-pack\n */
 389         while (skip > 0) {
 390                 r = http_read(&bio, chunked, &chunksz, buf,
 391                     MINIMUM(skip, sizeof(buf)));
 392                 if (r <= 0)
 393                         goto err;
 394                 skip -= r;
 395         }
 396
 397         for (;;) {
 398                 r = http_read(&bio, chunked, &chunksz, buf, sizeof(buf));
 399                 if (r == -1)
 400                         goto err;
 401
 402                 if (r == 0)
 403                         break;
 404
 405                 fwrite(buf, 1, r, stdout);
 406         }
 407
 408         fflush(stdout);
 409         ret = 0;
 410 err:
 411         bufio_close_sync(&bio);
 412         bufio_free(&bio);
 413         return ret;
 414 }
 415
 416 static int
 417 upload_request(int https, const char *host, const char *port, const char *path,
 418     FILE *in)
 419 {
 420         struct bufio             bio;
 421         char                     buf[GOT_PKT_MAX];
 422         const struct got_error  *e;
 423         ssize_t                  r;
 424         size_t                   chunksz = 0;
 425         int                      t;
 426         int                      chunked;
 427         int                      sock;
 428         int                      ret = -1;
 429
 430         if ((sock = dial(https, host, port)) == -1)
 431                 return -1;
 432
 433         if (bufio_init(&bio)) {
 434                 warnx("bufio_init");
 435                 goto err;
 436         }
 437         bufio_set_fd(&bio, sock);
 438         if (https && bufio_starttls(&bio, host, 0, NULL, 0, NULL, 0) == -1) {
 439                 warnx("bufio_starttls");
 440                 goto err;
 441         }
 442 #ifndef PROFILE
 443         /* TODO: can we push this upwards such that get_refs() is covered? */
 444         if (pledge("stdio", NULL) == -1)
 445                 err(1, "pledge");
 446 #endif
 447         if (http_open(&bio, https, "POST", host, port, path, "git-upload-pack",
 448             NULL, UPLOAD_PACK_REQ) == -1)
 449                 goto err;
 450
 451         /*
 452          * Read have/want lines generated by got-fetch-pack and forward
 453          * them to the server in the POST request body.
 454          */
 455         for (;;) {
 456                 r = fread(buf, 1, 4, in);
 457                 if (r != 4)
 458                         goto err;
 459
 460                 e = got_pkt_readlen(&t, buf, verbose);
 461                 if (e) {
 462                         warnx("%s", e->msg);
 463                         goto err;
 464                 }
 465
 466                 if (t == 0) {
 467                         const char *flushpkt = "0000";
 468                         if (http_chunk(&bio, flushpkt, strlen(flushpkt)))
 469                                 goto err;
 470                         continue; /* got-fetch-pack will send "done" */
 471                 }
 472
 473                 if (t < 6) {
 474                         warnx("pktline len is too small");
 475                         goto err;
 476                 }
 477
 478                 r = fread(buf + 4, 1, t - 4, in);
 479                 if (r != t - 4)
 480                         goto err;
 481
 482                 if (http_chunk(&bio, buf, t))
 483                         goto err;
 484
 485                 /*
 486                  * Once got-fetch-pack is done the server will
 487                  * send pack file data.
 488                  */
 489                 if (t == 9 && strncmp(buf + 4, "done\n", 5) == 0) {
 490                         if (http_chunk(&bio, NULL, 0))
 491                                 goto err;
 492                         break;
 493                 }
 494         }
 495
 496         if (http_parse_reply(&bio, &chunked, UPLOAD_PACK_RES) == -1)
 497                 goto err;
 498
 499         /* Fetch pack file data from server. */
 500         for (;;) {
 501                 r = http_read(&bio, chunked, &chunksz, buf, sizeof(buf));
 502                 if (r == -1)
 503                         goto err;
 504
 505                 if (r == 0)
 506                         break;
 507
 508                 fwrite(buf, 1, r, stdout);
 509         }
 510
 511         ret = 0;
 512 err:
 513         bufio_close_sync(&bio);
 514         bufio_free(&bio);
 515         return ret;
 516 }
 517
 518 static __dead void
 519 usage(void)
 520 {
 521         fprintf(stderr, "usage: %s [-qv] proto host port path\n",
 522              getprogname());
 523         exit(1);
 524 }
 525
 526 int
 527 main(int argc, char **argv)
 528 {
 529         struct pollfd    pfd;
 530         const char      *host, *port;
 531         char            *path;
 532         int              https = 0;
 533         int              ch;
 534
 535 #ifndef PROFILE
 536         if (pledge("stdio rpath inet dns unveil", NULL) == -1)
 537                 err(1, "pledge");
 538 #endif
 539
 540         while ((ch = getopt(argc, argv, "qv")) != -1) {
 541                 switch (ch) {
 542                 case 'q':
 543                         verbose = -1;
 544                         break;
 545                 case 'v':
 546                         verbose++;
 547                         break;
 548                 default:
 549                         usage();
 550                 }
 551         }
 552         argc -= optind;
 553         argv += optind;
 554
 555         if (argc != 4)
 556                 usage();
 557
 558         https = strcmp(argv[0], "https") == 0;
 559 #ifndef PROFILE
 560         if (https) {
 561                 if (unveil("/etc/ssl/cert.pem", "r") == -1)
 562                         err(1, "unveil /etc/ssl/cert.pem");
 563         } else {
 564                 /* drop "rpath" */
 565                 if (pledge("stdio inet dns unveil", NULL) == -1)
 566                         err(1, "pledge");
 567         }
 568 #else
 569         if (unveil("gmon.out", "rwc") != 0)
 570                 err(1, "unveil gmon.out");
 571 #endif
 572         if (unveil(NULL, NULL) == -1)
 573                 err(1, "unveil NULL");
 574
 575         host = argv[1];
 576         port = argv[2];
 577         path = argv[3];
 578         got_path_strip_trailing_slashes(path);
 579
 580         if (get_refs(https, host, port, path) == -1)
 581                 errx(1, "failed to get refs");
 582
 583         pfd.fd = 0;
 584         pfd.events = POLLIN;
 585         if (poll(&pfd, 1, INFTIM) == -1)
 586                 err(1, "poll");
 587
 588         if ((ch = fgetc(stdin)) == EOF)
 589                 return 0;
 590
 591         ungetc(ch, stdin);
 592         if (upload_request(https, host, port, path, stdin) == -1) {
 593                 fflush(tmp);
 594                 errx(1, "failed to upload request");
 595         }
 596
 597         return 0;
 598 }