lib/libfetch/fetch.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1998-2004 Dag-Erling Smørgrav
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer
  12  *    in this position and unchanged.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <sys/param.h>
  32
  33 #include <netinet/in.h>
  34
  35 #include <errno.h>
  36 #include <ctype.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40
  41 #include "fetch.h"
  42 #include "common.h"
  43
  44 auth_t   fetchAuthMethod;
  45 int      fetchLastErrCode;
  46 char     fetchLastErrString[MAXERRSTRING];
  47 int      fetchTimeout;
  48 int      fetchRestartCalls = 1;
  49 int      fetchDebug;
  50
  51
  52 /*** Local data **************************************************************/
  53
  54 /*
  55  * Error messages for parser errors
  56  */
  57 #define URL_MALFORMED           1
  58 #define URL_BAD_SCHEME          2
  59 #define URL_BAD_PORT            3
  60 static struct fetcherr url_errlist[] = {
  61         { URL_MALFORMED,        FETCH_URL,      "Malformed URL" },
  62         { URL_BAD_SCHEME,       FETCH_URL,      "Invalid URL scheme" },
  63         { URL_BAD_PORT,         FETCH_URL,      "Invalid server port" },
  64         { -1,                   FETCH_UNKNOWN,  "Unknown parser error" }
  65 };
  66
  67
  68 /*** Public API **************************************************************/
  69
  70 /*
  71  * Select the appropriate protocol for the URL scheme, and return a
  72  * read-only stream connected to the document referenced by the URL.
  73  * Also fill out the struct url_stat.
  74  */
  75 FILE *
  76 fetchXGet(struct url *URL, struct url_stat *us, const char *flags)
  77 {
  78
  79         if (us != NULL) {
  80                 us->size = -1;
  81                 us->atime = us->mtime = 0;
  82         }
  83         if (strcmp(URL->scheme, SCHEME_FILE) == 0)
  84                 return (fetchXGetFile(URL, us, flags));
  85         else if (strcmp(URL->scheme, SCHEME_FTP) == 0)
  86                 return (fetchXGetFTP(URL, us, flags));
  87         else if (strcmp(URL->scheme, SCHEME_HTTP) == 0)
  88                 return (fetchXGetHTTP(URL, us, flags));
  89         else if (strcmp(URL->scheme, SCHEME_HTTPS) == 0)
  90                 return (fetchXGetHTTP(URL, us, flags));
  91         url_seterr(URL_BAD_SCHEME);
  92         return (NULL);
  93 }
  94
  95 /*
  96  * Select the appropriate protocol for the URL scheme, and return a
  97  * read-only stream connected to the document referenced by the URL.
  98  */
  99 FILE *
 100 fetchGet(struct url *URL, const char *flags)
 101 {
 102         return (fetchXGet(URL, NULL, flags));
 103 }
 104
 105 /*
 106  * Select the appropriate protocol for the URL scheme, and return a
 107  * write-only stream connected to the document referenced by the URL.
 108  */
 109 FILE *
 110 fetchPut(struct url *URL, const char *flags)
 111 {
 112
 113         if (strcmp(URL->scheme, SCHEME_FILE) == 0)
 114                 return (fetchPutFile(URL, flags));
 115         else if (strcmp(URL->scheme, SCHEME_FTP) == 0)
 116                 return (fetchPutFTP(URL, flags));
 117         else if (strcmp(URL->scheme, SCHEME_HTTP) == 0)
 118                 return (fetchPutHTTP(URL, flags));
 119         else if (strcmp(URL->scheme, SCHEME_HTTPS) == 0)
 120                 return (fetchPutHTTP(URL, flags));
 121         url_seterr(URL_BAD_SCHEME);
 122         return (NULL);
 123 }
 124
 125 /*
 126  * Select the appropriate protocol for the URL scheme, and return the
 127  * size of the document referenced by the URL if it exists.
 128  */
 129 int
 130 fetchStat(struct url *URL, struct url_stat *us, const char *flags)
 131 {
 132
 133         if (us != NULL) {
 134                 us->size = -1;
 135                 us->atime = us->mtime = 0;
 136         }
 137         if (strcmp(URL->scheme, SCHEME_FILE) == 0)
 138                 return (fetchStatFile(URL, us, flags));
 139         else if (strcmp(URL->scheme, SCHEME_FTP) == 0)
 140                 return (fetchStatFTP(URL, us, flags));
 141         else if (strcmp(URL->scheme, SCHEME_HTTP) == 0)
 142                 return (fetchStatHTTP(URL, us, flags));
 143         else if (strcmp(URL->scheme, SCHEME_HTTPS) == 0)
 144                 return (fetchStatHTTP(URL, us, flags));
 145         url_seterr(URL_BAD_SCHEME);
 146         return (-1);
 147 }
 148
 149 /*
 150  * Select the appropriate protocol for the URL scheme, and return a
 151  * list of files in the directory pointed to by the URL.
 152  */
 153 struct url_ent *
 154 fetchList(struct url *URL, const char *flags)
 155 {
 156
 157         if (strcmp(URL->scheme, SCHEME_FILE) == 0)
 158                 return (fetchListFile(URL, flags));
 159         else if (strcmp(URL->scheme, SCHEME_FTP) == 0)
 160                 return (fetchListFTP(URL, flags));
 161         else if (strcmp(URL->scheme, SCHEME_HTTP) == 0)
 162                 return (fetchListHTTP(URL, flags));
 163         else if (strcmp(URL->scheme, SCHEME_HTTPS) == 0)
 164                 return (fetchListHTTP(URL, flags));
 165         url_seterr(URL_BAD_SCHEME);
 166         return (NULL);
 167 }
 168
 169 /*
 170  * Attempt to parse the given URL; if successful, call fetchXGet().
 171  */
 172 FILE *
 173 fetchXGetURL(const char *URL, struct url_stat *us, const char *flags)
 174 {
 175         struct url *u;
 176         FILE *f;
 177
 178         if ((u = fetchParseURL(URL)) == NULL)
 179                 return (NULL);
 180
 181         f = fetchXGet(u, us, flags);
 182
 183         fetchFreeURL(u);
 184         return (f);
 185 }
 186
 187 /*
 188  * Attempt to parse the given URL; if successful, call fetchGet().
 189  */
 190 FILE *
 191 fetchGetURL(const char *URL, const char *flags)
 192 {
 193         return (fetchXGetURL(URL, NULL, flags));
 194 }
 195
 196 /*
 197  * Attempt to parse the given URL; if successful, call fetchPut().
 198  */
 199 FILE *
 200 fetchPutURL(const char *URL, const char *flags)
 201 {
 202         struct url *u;
 203         FILE *f;
 204
 205         if ((u = fetchParseURL(URL)) == NULL)
 206                 return (NULL);
 207
 208         f = fetchPut(u, flags);
 209
 210         fetchFreeURL(u);
 211         return (f);
 212 }
 213
 214 /*
 215  * Attempt to parse the given URL; if successful, call fetchStat().
 216  */
 217 int
 218 fetchStatURL(const char *URL, struct url_stat *us, const char *flags)
 219 {
 220         struct url *u;
 221         int s;
 222
 223         if ((u = fetchParseURL(URL)) == NULL)
 224                 return (-1);
 225
 226         s = fetchStat(u, us, flags);
 227
 228         fetchFreeURL(u);
 229         return (s);
 230 }
 231
 232 /*
 233  * Attempt to parse the given URL; if successful, call fetchList().
 234  */
 235 struct url_ent *
 236 fetchListURL(const char *URL, const char *flags)
 237 {
 238         struct url *u;
 239         struct url_ent *ue;
 240
 241         if ((u = fetchParseURL(URL)) == NULL)
 242                 return (NULL);
 243
 244         ue = fetchList(u, flags);
 245
 246         fetchFreeURL(u);
 247         return (ue);
 248 }
 249
 250 /*
 251  * Make a URL
 252  */
 253 struct url *
 254 fetchMakeURL(const char *scheme, const char *host, int port, const char *doc,
 255     const char *user, const char *pwd)
 256 {
 257         struct url *u;
 258
 259         if (!scheme || (!host && !doc)) {
 260                 url_seterr(URL_MALFORMED);
 261                 return (NULL);
 262         }
 263
 264         if (port < 0 || port > 65535) {
 265                 url_seterr(URL_BAD_PORT);
 266                 return (NULL);
 267         }
 268
 269         /* allocate struct url */
 270         if ((u = calloc(1, sizeof(*u))) == NULL) {
 271                 fetch_syserr();
 272                 return (NULL);
 273         }
 274         u->netrcfd = -1;
 275
 276         if ((u->doc = strdup(doc ? doc : "/")) == NULL) {
 277                 fetch_syserr();
 278                 free(u);
 279                 return (NULL);
 280         }
 281
 282 #define seturl(x) snprintf(u->x, sizeof(u->x), "%s", x)
 283         seturl(scheme);
 284         seturl(host);
 285         seturl(user);
 286         seturl(pwd);
 287 #undef seturl
 288         u->port = port;
 289
 290         return (u);
 291 }
 292
 293 /*
 294  * Return value of the given hex digit.
 295  */
 296 static int
 297 fetch_hexval(char ch)
 298 {
 299
 300         if (ch >= '0' && ch <= '9')
 301                 return (ch - '0');
 302         else if (ch >= 'a' && ch <= 'f')
 303                 return (ch - 'a' + 10);
 304         else if (ch >= 'A' && ch <= 'F')
 305                 return (ch - 'A' + 10);
 306         return (-1);
 307 }
 308
 309 /*
 310  * Decode percent-encoded URL component from src into dst, stopping at end
 311  * of string, or at @ or : separators.  Returns a pointer to the unhandled
 312  * part of the input string (null terminator, @, or :).  No terminator is
 313  * written to dst (it is the caller's responsibility).
 314  */
 315 static const char *
 316 fetch_pctdecode(char *dst, const char *src, size_t dlen)
 317 {
 318         int d1, d2;
 319         char c;
 320         const char *s;
 321
 322         for (s = src; *s != '\0' && *s != '@' && *s != ':'; s++) {
 323                 if (s[0] == '%' && (d1 = fetch_hexval(s[1])) >= 0 &&
 324                     (d2 = fetch_hexval(s[2])) >= 0 && (d1 > 0 || d2 > 0)) {
 325                         c = d1 << 4 | d2;
 326                         s += 2;
 327                 } else if (s[0] == '%') {
 328                         /* Invalid escape sequence. */
 329                         return (NULL);
 330                 } else {
 331                         c = *s;
 332                 }
 333                 if (dlen-- > 0)
 334                         *dst++ = c;
 335                 else
 336                         return (NULL);
 337         }
 338         return (s);
 339 }
 340
 341 /*
 342  * Split an URL into components. URL syntax is:
 343  * [method:/][/[user[:pwd]@]host[:port]/][document]
 344  * This almost, but not quite, RFC1738 URL syntax.
 345  */
 346 struct url *
 347 fetchParseURL(const char *URL)
 348 {
 349         char *doc;
 350         const char *p, *q;
 351         struct url *u;
 352         int i, n;
 353
 354         /* allocate struct url */
 355         if ((u = calloc(1, sizeof(*u))) == NULL) {
 356                 fetch_syserr();
 357                 return (NULL);
 358         }
 359         u->netrcfd = -1;
 360
 361         /* scheme name */
 362         if ((p = strstr(URL, ":/"))) {
 363                 if (p - URL > URL_SCHEMELEN)
 364                         goto ouch;
 365                 for (i = 0; URL + i < p; i++)
 366                         u->scheme[i] = tolower((unsigned char)URL[i]);
 367                 URL = ++p;
 368                 /*
 369                  * Only one slash: no host, leave slash as part of document
 370                  * Two slashes: host follows, strip slashes
 371                  */
 372                 if (URL[1] == '/')
 373                         URL = (p += 2);
 374         } else {
 375                 p = URL;
 376         }
 377         if (!*URL || *URL == '/' || *URL == '.' ||
 378             (u->scheme[0] == '\0' &&
 379                 strchr(URL, '/') == NULL && strchr(URL, ':') == NULL))
 380                 goto nohost;
 381
 382         p = strpbrk(URL, "/@");
 383         if (p && *p == '@') {
 384                 /* username */
 385                 q = fetch_pctdecode(u->user, URL, URL_USERLEN);
 386                 if (q == NULL)
 387                         goto ouch;
 388
 389                 /* password */
 390                 if (*q == ':') {
 391                         q = fetch_pctdecode(u->pwd, q + 1, URL_PWDLEN);
 392                         if (q == NULL)
 393                                 goto ouch;
 394                 }
 395                 p++;
 396         } else {
 397                 p = URL;
 398         }
 399
 400         /* hostname */
 401         if (*p == '[') {
 402                 q = p + 1 + strspn(p + 1, ":0123456789ABCDEFabcdef");
 403                 if (*q++ != ']')
 404                         goto ouch;
 405         } else {
 406                 /* valid characters in a DNS name */
 407                 q = p + strspn(p, "-." "0123456789"
 408                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "_"
 409                     "abcdefghijklmnopqrstuvwxyz");
 410         }
 411         if ((*q != '\0' && *q != '/' && *q != ':') || q - p > MAXHOSTNAMELEN)
 412                 goto ouch;
 413         for (i = 0; p + i < q; i++)
 414                 u->host[i] = tolower((unsigned char)p[i]);
 415         u->host[i] = '\0';
 416         p = q;
 417
 418         /* port */
 419         if (*p == ':') {
 420                 for (n = 0, q = ++p; *q && (*q != '/'); q++) {
 421                         if (*q >= '0' && *q <= '9' && n < INT_MAX / 10) {
 422                                 n = n * 10 + (*q - '0');
 423                         } else {
 424                                 /* invalid port */
 425                                 url_seterr(URL_BAD_PORT);
 426                                 goto ouch;
 427                         }
 428                 }
 429                 if (p != q && (n < 1 || n > IPPORT_MAX))
 430                         goto ouch;
 431                 u->port = n;
 432                 p = q;
 433         }
 434
 435 nohost:
 436         /* document */
 437         if (!*p)
 438                 p = "/";
 439
 440         if (strcmp(u->scheme, SCHEME_HTTP) == 0 ||
 441             strcmp(u->scheme, SCHEME_HTTPS) == 0) {
 442                 const char hexnums[] = "0123456789abcdef";
 443
 444                 /* percent-escape whitespace. */
 445                 if ((doc = malloc(strlen(p) * 3 + 1)) == NULL) {
 446                         fetch_syserr();
 447                         goto ouch;
 448                 }
 449                 u->doc = doc;
 450                 while (*p != '\0') {
 451                         if (!isspace((unsigned char)*p)) {
 452                                 *doc++ = *p++;
 453                         } else {
 454                                 *doc++ = '%';
 455                                 *doc++ = hexnums[((unsigned int)*p) >> 4];
 456                                 *doc++ = hexnums[((unsigned int)*p) & 0xf];
 457                                 p++;
 458                         }
 459                 }
 460                 *doc = '\0';
 461         } else if ((u->doc = strdup(p)) == NULL) {
 462                 fetch_syserr();
 463                 goto ouch;
 464         }
 465
 466         DEBUGF("scheme:   \"%s\"\n"
 467             "user:     \"%s\"\n"
 468             "password: \"%s\"\n"
 469             "host:     \"%s\"\n"
 470             "port:     \"%d\"\n"
 471             "document: \"%s\"\n",
 472             u->scheme, u->user, u->pwd,
 473             u->host, u->port, u->doc);
 474
 475         return (u);
 476
 477 ouch:
 478         free(u);
 479         return (NULL);
 480 }
 481
 482 /*
 483  * Free a URL
 484  */
 485 void
 486 fetchFreeURL(struct url *u)
 487 {
 488         free(u->doc);
 489         free(u);
 490 }