Annotation of embedaddon/curl/lib/altsvc.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 2019 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: ***************************************************************************/
! 22: /*
! 23: * The Alt-Svc: header is defined in RFC 7838:
! 24: * https://tools.ietf.org/html/rfc7838
! 25: */
! 26: #include "curl_setup.h"
! 27:
! 28: #if !defined(CURL_DISABLE_HTTP) && defined(USE_ALTSVC)
! 29: #include <curl/curl.h>
! 30: #include "urldata.h"
! 31: #include "altsvc.h"
! 32: #include "curl_get_line.h"
! 33: #include "strcase.h"
! 34: #include "parsedate.h"
! 35: #include "sendf.h"
! 36: #include "warnless.h"
! 37: #include "rand.h"
! 38: #include "rename.h"
! 39:
! 40: /* The last 3 #include files should be in this order */
! 41: #include "curl_printf.h"
! 42: #include "curl_memory.h"
! 43: #include "memdebug.h"
! 44:
! 45: #define MAX_ALTSVC_LINE 4095
! 46: #define MAX_ALTSVC_DATELENSTR "64"
! 47: #define MAX_ALTSVC_DATELEN 64
! 48: #define MAX_ALTSVC_HOSTLENSTR "512"
! 49: #define MAX_ALTSVC_HOSTLEN 512
! 50: #define MAX_ALTSVC_ALPNLENSTR "10"
! 51: #define MAX_ALTSVC_ALPNLEN 10
! 52:
! 53: #if (defined(USE_QUICHE) || defined(USE_NGTCP2)) && !defined(UNITTESTS)
! 54: #define H3VERSION "h3-27"
! 55: #else
! 56: #define H3VERSION "h3"
! 57: #endif
! 58:
! 59: static enum alpnid alpn2alpnid(char *name)
! 60: {
! 61: if(strcasecompare(name, "h1"))
! 62: return ALPN_h1;
! 63: if(strcasecompare(name, "h2"))
! 64: return ALPN_h2;
! 65: if(strcasecompare(name, H3VERSION))
! 66: return ALPN_h3;
! 67: return ALPN_none; /* unknown, probably rubbish input */
! 68: }
! 69:
! 70: /* Given the ALPN ID, return the name */
! 71: const char *Curl_alpnid2str(enum alpnid id)
! 72: {
! 73: switch(id) {
! 74: case ALPN_h1:
! 75: return "h1";
! 76: case ALPN_h2:
! 77: return "h2";
! 78: case ALPN_h3:
! 79: return H3VERSION;
! 80: default:
! 81: return ""; /* bad */
! 82: }
! 83: }
! 84:
! 85:
! 86: static void altsvc_free(struct altsvc *as)
! 87: {
! 88: free(as->src.host);
! 89: free(as->dst.host);
! 90: free(as);
! 91: }
! 92:
! 93: static struct altsvc *altsvc_createid(const char *srchost,
! 94: const char *dsthost,
! 95: enum alpnid srcalpnid,
! 96: enum alpnid dstalpnid,
! 97: unsigned int srcport,
! 98: unsigned int dstport)
! 99: {
! 100: struct altsvc *as = calloc(sizeof(struct altsvc), 1);
! 101: if(!as)
! 102: return NULL;
! 103:
! 104: as->src.host = strdup(srchost);
! 105: if(!as->src.host)
! 106: goto error;
! 107: as->dst.host = strdup(dsthost);
! 108: if(!as->dst.host)
! 109: goto error;
! 110:
! 111: as->src.alpnid = srcalpnid;
! 112: as->dst.alpnid = dstalpnid;
! 113: as->src.port = curlx_ultous(srcport);
! 114: as->dst.port = curlx_ultous(dstport);
! 115:
! 116: return as;
! 117: error:
! 118: altsvc_free(as);
! 119: return NULL;
! 120: }
! 121:
! 122: static struct altsvc *altsvc_create(char *srchost,
! 123: char *dsthost,
! 124: char *srcalpn,
! 125: char *dstalpn,
! 126: unsigned int srcport,
! 127: unsigned int dstport)
! 128: {
! 129: enum alpnid dstalpnid = alpn2alpnid(dstalpn);
! 130: enum alpnid srcalpnid = alpn2alpnid(srcalpn);
! 131: if(!srcalpnid || !dstalpnid)
! 132: return NULL;
! 133: return altsvc_createid(srchost, dsthost, srcalpnid, dstalpnid,
! 134: srcport, dstport);
! 135: }
! 136:
! 137: /* only returns SERIOUS errors */
! 138: static CURLcode altsvc_add(struct altsvcinfo *asi, char *line)
! 139: {
! 140: /* Example line:
! 141: h2 example.com 443 h3 shiny.example.com 8443 "20191231 10:00:00" 1
! 142: */
! 143: char srchost[MAX_ALTSVC_HOSTLEN + 1];
! 144: char dsthost[MAX_ALTSVC_HOSTLEN + 1];
! 145: char srcalpn[MAX_ALTSVC_ALPNLEN + 1];
! 146: char dstalpn[MAX_ALTSVC_ALPNLEN + 1];
! 147: char date[MAX_ALTSVC_DATELEN + 1];
! 148: unsigned int srcport;
! 149: unsigned int dstport;
! 150: unsigned int prio;
! 151: unsigned int persist;
! 152: int rc;
! 153:
! 154: rc = sscanf(line,
! 155: "%" MAX_ALTSVC_ALPNLENSTR "s %" MAX_ALTSVC_HOSTLENSTR "s %u "
! 156: "%" MAX_ALTSVC_ALPNLENSTR "s %" MAX_ALTSVC_HOSTLENSTR "s %u "
! 157: "\"%" MAX_ALTSVC_DATELENSTR "[^\"]\" %u %u",
! 158: srcalpn, srchost, &srcport,
! 159: dstalpn, dsthost, &dstport,
! 160: date, &persist, &prio);
! 161: if(9 == rc) {
! 162: struct altsvc *as;
! 163: time_t expires = Curl_getdate_capped(date);
! 164: as = altsvc_create(srchost, dsthost, srcalpn, dstalpn, srcport, dstport);
! 165: if(as) {
! 166: as->expires = expires;
! 167: as->prio = prio;
! 168: as->persist = persist ? 1 : 0;
! 169: Curl_llist_insert_next(&asi->list, asi->list.tail, as, &as->node);
! 170: asi->num++; /* one more entry */
! 171: }
! 172: }
! 173:
! 174: return CURLE_OK;
! 175: }
! 176:
! 177: /*
! 178: * Load alt-svc entries from the given file. The text based line-oriented file
! 179: * format is documented here:
! 180: * https://github.com/curl/curl/wiki/QUIC-implementation
! 181: *
! 182: * This function only returns error on major problems that prevents alt-svc
! 183: * handling to work completely. It will ignore individual syntactical errors
! 184: * etc.
! 185: */
! 186: static CURLcode altsvc_load(struct altsvcinfo *asi, const char *file)
! 187: {
! 188: CURLcode result = CURLE_OK;
! 189: char *line = NULL;
! 190: FILE *fp;
! 191:
! 192: /* we need a private copy of the file name so that the altsvc cache file
! 193: name survives an easy handle reset */
! 194: free(asi->filename);
! 195: asi->filename = strdup(file);
! 196: if(!asi->filename)
! 197: return CURLE_OUT_OF_MEMORY;
! 198:
! 199: fp = fopen(file, FOPEN_READTEXT);
! 200: if(fp) {
! 201: line = malloc(MAX_ALTSVC_LINE);
! 202: if(!line)
! 203: goto fail;
! 204: while(Curl_get_line(line, MAX_ALTSVC_LINE, fp)) {
! 205: char *lineptr = line;
! 206: while(*lineptr && ISBLANK(*lineptr))
! 207: lineptr++;
! 208: if(*lineptr == '#')
! 209: /* skip commented lines */
! 210: continue;
! 211:
! 212: altsvc_add(asi, lineptr);
! 213: }
! 214: free(line); /* free the line buffer */
! 215: fclose(fp);
! 216: }
! 217: return result;
! 218:
! 219: fail:
! 220: Curl_safefree(asi->filename);
! 221: free(line);
! 222: fclose(fp);
! 223: return CURLE_OUT_OF_MEMORY;
! 224: }
! 225:
! 226: /*
! 227: * Write this single altsvc entry to a single output line
! 228: */
! 229:
! 230: static CURLcode altsvc_out(struct altsvc *as, FILE *fp)
! 231: {
! 232: struct tm stamp;
! 233: CURLcode result = Curl_gmtime(as->expires, &stamp);
! 234: if(result)
! 235: return result;
! 236:
! 237: fprintf(fp,
! 238: "%s %s %u "
! 239: "%s %s %u "
! 240: "\"%d%02d%02d "
! 241: "%02d:%02d:%02d\" "
! 242: "%u %d\n",
! 243: Curl_alpnid2str(as->src.alpnid), as->src.host, as->src.port,
! 244: Curl_alpnid2str(as->dst.alpnid), as->dst.host, as->dst.port,
! 245: stamp.tm_year + 1900, stamp.tm_mon + 1, stamp.tm_mday,
! 246: stamp.tm_hour, stamp.tm_min, stamp.tm_sec,
! 247: as->persist, as->prio);
! 248: return CURLE_OK;
! 249: }
! 250:
! 251: /* ---- library-wide functions below ---- */
! 252:
! 253: /*
! 254: * Curl_altsvc_init() creates a new altsvc cache.
! 255: * It returns the new instance or NULL if something goes wrong.
! 256: */
! 257: struct altsvcinfo *Curl_altsvc_init(void)
! 258: {
! 259: struct altsvcinfo *asi = calloc(sizeof(struct altsvcinfo), 1);
! 260: if(!asi)
! 261: return NULL;
! 262: Curl_llist_init(&asi->list, NULL);
! 263:
! 264: /* set default behavior */
! 265: asi->flags = CURLALTSVC_H1
! 266: #ifdef USE_NGHTTP2
! 267: | CURLALTSVC_H2
! 268: #endif
! 269: #ifdef ENABLE_QUIC
! 270: | CURLALTSVC_H3
! 271: #endif
! 272: ;
! 273: return asi;
! 274: }
! 275:
! 276: /*
! 277: * Curl_altsvc_load() loads alt-svc from file.
! 278: */
! 279: CURLcode Curl_altsvc_load(struct altsvcinfo *asi, const char *file)
! 280: {
! 281: CURLcode result;
! 282: DEBUGASSERT(asi);
! 283: result = altsvc_load(asi, file);
! 284: return result;
! 285: }
! 286:
! 287: /*
! 288: * Curl_altsvc_ctrl() passes on the external bitmask.
! 289: */
! 290: CURLcode Curl_altsvc_ctrl(struct altsvcinfo *asi, const long ctrl)
! 291: {
! 292: DEBUGASSERT(asi);
! 293: if(!ctrl)
! 294: /* unexpected */
! 295: return CURLE_BAD_FUNCTION_ARGUMENT;
! 296: asi->flags = ctrl;
! 297: return CURLE_OK;
! 298: }
! 299:
! 300: /*
! 301: * Curl_altsvc_cleanup() frees an altsvc cache instance and all associated
! 302: * resources.
! 303: */
! 304: void Curl_altsvc_cleanup(struct altsvcinfo *altsvc)
! 305: {
! 306: struct curl_llist_element *e;
! 307: struct curl_llist_element *n;
! 308: if(altsvc) {
! 309: for(e = altsvc->list.head; e; e = n) {
! 310: struct altsvc *as = e->ptr;
! 311: n = e->next;
! 312: altsvc_free(as);
! 313: }
! 314: free(altsvc->filename);
! 315: free(altsvc);
! 316: }
! 317: }
! 318:
! 319: /*
! 320: * Curl_altsvc_save() writes the altsvc cache to a file.
! 321: */
! 322: CURLcode Curl_altsvc_save(struct Curl_easy *data,
! 323: struct altsvcinfo *altsvc, const char *file)
! 324: {
! 325: struct curl_llist_element *e;
! 326: struct curl_llist_element *n;
! 327: CURLcode result = CURLE_OK;
! 328: FILE *out;
! 329: char *tempstore;
! 330: unsigned char randsuffix[9];
! 331:
! 332: if(!altsvc)
! 333: /* no cache activated */
! 334: return CURLE_OK;
! 335:
! 336: /* if not new name is given, use the one we stored from the load */
! 337: if(!file && altsvc->filename)
! 338: file = altsvc->filename;
! 339:
! 340: if((altsvc->flags & CURLALTSVC_READONLYFILE) || !file || !file[0])
! 341: /* marked as read-only, no file or zero length file name */
! 342: return CURLE_OK;
! 343:
! 344: if(Curl_rand_hex(data, randsuffix, sizeof(randsuffix)))
! 345: return CURLE_FAILED_INIT;
! 346:
! 347: tempstore = aprintf("%s.%s.tmp", file, randsuffix);
! 348: if(!tempstore)
! 349: return CURLE_OUT_OF_MEMORY;
! 350:
! 351: out = fopen(tempstore, FOPEN_WRITETEXT);
! 352: if(!out)
! 353: result = CURLE_WRITE_ERROR;
! 354: else {
! 355: fputs("# Your alt-svc cache. https://curl.haxx.se/docs/alt-svc.html\n"
! 356: "# This file was generated by libcurl! Edit at your own risk.\n",
! 357: out);
! 358: for(e = altsvc->list.head; e; e = n) {
! 359: struct altsvc *as = e->ptr;
! 360: n = e->next;
! 361: result = altsvc_out(as, out);
! 362: if(result)
! 363: break;
! 364: }
! 365: fclose(out);
! 366: if(!result && Curl_rename(tempstore, file))
! 367: result = CURLE_WRITE_ERROR;
! 368:
! 369: if(result)
! 370: unlink(tempstore);
! 371: }
! 372: free(tempstore);
! 373: return result;
! 374: }
! 375:
! 376: static CURLcode getalnum(const char **ptr, char *alpnbuf, size_t buflen)
! 377: {
! 378: size_t len;
! 379: const char *protop;
! 380: const char *p = *ptr;
! 381: while(*p && ISBLANK(*p))
! 382: p++;
! 383: protop = p;
! 384: while(*p && !ISBLANK(*p) && (*p != ';') && (*p != '='))
! 385: p++;
! 386: len = p - protop;
! 387: *ptr = p;
! 388:
! 389: if(!len || (len >= buflen))
! 390: return CURLE_BAD_FUNCTION_ARGUMENT;
! 391: memcpy(alpnbuf, protop, len);
! 392: alpnbuf[len] = 0;
! 393: return CURLE_OK;
! 394: }
! 395:
! 396: /* altsvc_flush() removes all alternatives for this source origin from the
! 397: list */
! 398: static void altsvc_flush(struct altsvcinfo *asi, enum alpnid srcalpnid,
! 399: const char *srchost, unsigned short srcport)
! 400: {
! 401: struct curl_llist_element *e;
! 402: struct curl_llist_element *n;
! 403: for(e = asi->list.head; e; e = n) {
! 404: struct altsvc *as = e->ptr;
! 405: n = e->next;
! 406: if((srcalpnid == as->src.alpnid) &&
! 407: (srcport == as->src.port) &&
! 408: strcasecompare(srchost, as->src.host)) {
! 409: Curl_llist_remove(&asi->list, e, NULL);
! 410: altsvc_free(as);
! 411: asi->num--;
! 412: }
! 413: }
! 414: }
! 415:
! 416: #ifdef DEBUGBUILD
! 417: /* to play well with debug builds, we can *set* a fixed time this will
! 418: return */
! 419: static time_t debugtime(void *unused)
! 420: {
! 421: char *timestr = getenv("CURL_TIME");
! 422: (void)unused;
! 423: if(timestr) {
! 424: unsigned long val = strtol(timestr, NULL, 10);
! 425: return (time_t)val;
! 426: }
! 427: return time(NULL);
! 428: }
! 429: #define time(x) debugtime(x)
! 430: #endif
! 431:
! 432: /*
! 433: * Curl_altsvc_parse() takes an incoming alt-svc response header and stores
! 434: * the data correctly in the cache.
! 435: *
! 436: * 'value' points to the header *value*. That's contents to the right of the
! 437: * header name.
! 438: *
! 439: * Currently this function rejects invalid data without returning an error.
! 440: * Invalid host name, port number will result in the specific alternative
! 441: * being rejected. Unknown protocols are skipped.
! 442: */
! 443: CURLcode Curl_altsvc_parse(struct Curl_easy *data,
! 444: struct altsvcinfo *asi, const char *value,
! 445: enum alpnid srcalpnid, const char *srchost,
! 446: unsigned short srcport)
! 447: {
! 448: const char *p = value;
! 449: size_t len;
! 450: enum alpnid dstalpnid = srcalpnid; /* the same by default */
! 451: char namebuf[MAX_ALTSVC_HOSTLEN] = "";
! 452: char alpnbuf[MAX_ALTSVC_ALPNLEN] = "";
! 453: struct altsvc *as;
! 454: unsigned short dstport = srcport; /* the same by default */
! 455: CURLcode result = getalnum(&p, alpnbuf, sizeof(alpnbuf));
! 456: if(result) {
! 457: infof(data, "Excessive alt-svc header, ignoring...\n");
! 458: return CURLE_OK;
! 459: }
! 460:
! 461: DEBUGASSERT(asi);
! 462:
! 463: /* Flush all cached alternatives for this source origin, if any */
! 464: altsvc_flush(asi, srcalpnid, srchost, srcport);
! 465:
! 466: /* "clear" is a magic keyword */
! 467: if(strcasecompare(alpnbuf, "clear")) {
! 468: return CURLE_OK;
! 469: }
! 470:
! 471: do {
! 472: if(*p == '=') {
! 473: /* [protocol]="[host][:port]" */
! 474: dstalpnid = alpn2alpnid(alpnbuf);
! 475: p++;
! 476: if(*p == '\"') {
! 477: const char *dsthost;
! 478: const char *value_ptr;
! 479: char option[32];
! 480: unsigned long num;
! 481: char *end_ptr;
! 482: bool quoted = FALSE;
! 483: time_t maxage = 24 * 3600; /* default is 24 hours */
! 484: bool persist = FALSE;
! 485: p++;
! 486: if(*p != ':') {
! 487: /* host name starts here */
! 488: const char *hostp = p;
! 489: while(*p && (ISALNUM(*p) || (*p == '.') || (*p == '-')))
! 490: p++;
! 491: len = p - hostp;
! 492: if(!len || (len >= MAX_ALTSVC_HOSTLEN)) {
! 493: infof(data, "Excessive alt-svc host name, ignoring...\n");
! 494: dstalpnid = ALPN_none;
! 495: }
! 496: else {
! 497: memcpy(namebuf, hostp, len);
! 498: namebuf[len] = 0;
! 499: dsthost = namebuf;
! 500: }
! 501: }
! 502: else {
! 503: /* no destination name, use source host */
! 504: dsthost = srchost;
! 505: }
! 506: if(*p == ':') {
! 507: /* a port number */
! 508: unsigned long port = strtoul(++p, &end_ptr, 10);
! 509: if(port > USHRT_MAX || end_ptr == p || *end_ptr != '\"') {
! 510: infof(data, "Unknown alt-svc port number, ignoring...\n");
! 511: dstalpnid = ALPN_none;
! 512: }
! 513: p = end_ptr;
! 514: dstport = curlx_ultous(port);
! 515: }
! 516: if(*p++ != '\"')
! 517: break;
! 518: /* Handle the optional 'ma' and 'persist' flags. Unknown flags
! 519: are skipped. */
! 520: for(;;) {
! 521: while(*p && ISBLANK(*p) && *p != ';' && *p != ',')
! 522: p++;
! 523: if(!*p || *p == ',')
! 524: break;
! 525: p++; /* pass the semicolon */
! 526: if(!*p)
! 527: break;
! 528: result = getalnum(&p, option, sizeof(option));
! 529: if(result) {
! 530: /* skip option if name is too long */
! 531: option[0] = '\0';
! 532: }
! 533: while(*p && ISBLANK(*p))
! 534: p++;
! 535: if(*p != '=')
! 536: return CURLE_OK;
! 537: p++;
! 538: while(*p && ISBLANK(*p))
! 539: p++;
! 540: if(!*p)
! 541: return CURLE_OK;
! 542: if(*p == '\"') {
! 543: /* quoted value */
! 544: p++;
! 545: quoted = TRUE;
! 546: }
! 547: value_ptr = p;
! 548: if(quoted) {
! 549: while(*p && *p != '\"')
! 550: p++;
! 551: if(!*p++)
! 552: return CURLE_OK;
! 553: }
! 554: else {
! 555: while(*p && !ISBLANK(*p) && *p!= ';' && *p != ',')
! 556: p++;
! 557: }
! 558: num = strtoul(value_ptr, &end_ptr, 10);
! 559: if((end_ptr != value_ptr) && (num < ULONG_MAX)) {
! 560: if(strcasecompare("ma", option))
! 561: maxage = num;
! 562: else if(strcasecompare("persist", option) && (num == 1))
! 563: persist = TRUE;
! 564: }
! 565: }
! 566: if(dstalpnid) {
! 567: as = altsvc_createid(srchost, dsthost,
! 568: srcalpnid, dstalpnid,
! 569: srcport, dstport);
! 570: if(as) {
! 571: /* The expires time also needs to take the Age: value (if any) into
! 572: account. [See RFC 7838 section 3.1] */
! 573: as->expires = maxage + time(NULL);
! 574: as->persist = persist;
! 575: Curl_llist_insert_next(&asi->list, asi->list.tail, as, &as->node);
! 576: asi->num++; /* one more entry */
! 577: infof(data, "Added alt-svc: %s:%d over %s\n", dsthost, dstport,
! 578: Curl_alpnid2str(dstalpnid));
! 579: }
! 580: }
! 581: else {
! 582: infof(data, "Unknown alt-svc protocol \"%s\", skipping...\n",
! 583: alpnbuf);
! 584: }
! 585: }
! 586: else
! 587: break;
! 588: /* after the double quote there can be a comma if there's another
! 589: string or a semicolon if no more */
! 590: if(*p == ',') {
! 591: /* comma means another alternative is presented */
! 592: p++;
! 593: result = getalnum(&p, alpnbuf, sizeof(alpnbuf));
! 594: if(result)
! 595: break;
! 596: }
! 597: }
! 598: else
! 599: break;
! 600: } while(*p && (*p != ';') && (*p != '\n') && (*p != '\r'));
! 601:
! 602: return CURLE_OK;
! 603: }
! 604:
! 605: /*
! 606: * Return TRUE on a match
! 607: */
! 608: bool Curl_altsvc_lookup(struct altsvcinfo *asi,
! 609: enum alpnid srcalpnid, const char *srchost,
! 610: int srcport,
! 611: struct altsvc **dstentry,
! 612: const int versions) /* one or more bits */
! 613: {
! 614: struct curl_llist_element *e;
! 615: struct curl_llist_element *n;
! 616: time_t now = time(NULL);
! 617: DEBUGASSERT(asi);
! 618: DEBUGASSERT(srchost);
! 619: DEBUGASSERT(dstentry);
! 620:
! 621: for(e = asi->list.head; e; e = n) {
! 622: struct altsvc *as = e->ptr;
! 623: n = e->next;
! 624: if(as->expires < now) {
! 625: /* an expired entry, remove */
! 626: Curl_llist_remove(&asi->list, e, NULL);
! 627: altsvc_free(as);
! 628: continue;
! 629: }
! 630: if((as->src.alpnid == srcalpnid) &&
! 631: strcasecompare(as->src.host, srchost) &&
! 632: (as->src.port == srcport) &&
! 633: (versions & as->dst.alpnid)) {
! 634: /* match */
! 635: *dstentry = as;
! 636: return TRUE;
! 637: }
! 638: }
! 639: return FALSE;
! 640: }
! 641:
! 642: #endif /* CURL_DISABLE_HTTP || USE_ALTSVC */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to altsvc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib