altsvc.c 19 KB

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