uhttp.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831
  1. /* uhttp: see uhttp.h. Extracted from the original ucmd_curl.c so curl and
  2. * the browser share one HTTP/TLS path. */
  3. #include "uhttp.h"
  4. #include "tls.h"
  5. /* ---- tiny string helpers ---- */
  6. static unsigned int s_len(const char *s)
  7. {
  8. unsigned int n = 0;
  9. while (s && s[n])
  10. n++;
  11. return n;
  12. }
  13. static void s_copy(char *d, const char *s, unsigned int cap)
  14. {
  15. unsigned int i = 0;
  16. if (!cap)
  17. return;
  18. while (s && s[i] && i + 1 < cap) {
  19. d[i] = s[i];
  20. i++;
  21. }
  22. d[i] = '\0';
  23. }
  24. static int starts_with(const char *s, const char *prefix)
  25. {
  26. unsigned int i = 0;
  27. while (prefix[i]) {
  28. if (s[i] != prefix[i])
  29. return 0;
  30. i++;
  31. }
  32. return 1;
  33. }
  34. static int contains_ci(const char *hay, const char *needle)
  35. {
  36. unsigned int i, j;
  37. for (i = 0; hay[i]; i++) {
  38. for (j = 0; needle[j]; j++) {
  39. char a = hay[i + j];
  40. if (a >= 'A' && a <= 'Z')
  41. a = (char)(a - 'A' + 'a');
  42. if (a != needle[j])
  43. break;
  44. }
  45. if (!needle[j])
  46. return 1;
  47. }
  48. return 0;
  49. }
  50. /* ---- URL parsing / resolution ---- */
  51. int uhttp_parse_url(const char *s, struct uhttp_url *u)
  52. {
  53. const char *p = s, *h;
  54. unsigned int i;
  55. int secure = 0;
  56. if (!s || !u)
  57. return UHTTP_ERR_URL;
  58. if (starts_with(s, "https://")) {
  59. secure = 1;
  60. p += 8;
  61. } else if (starts_with(s, "http://")) {
  62. p += 7;
  63. } else {
  64. for (i = 0; s[i] && i < 8; i++) {
  65. if (s[i] == ':' && s[i + 1] == '/' && s[i + 2] == '/')
  66. return UHTTP_ERR_URL;
  67. if (s[i] == '/')
  68. break;
  69. }
  70. }
  71. u->secure = secure;
  72. h = p;
  73. while (*p && *p != '/' && *p != ':')
  74. p++;
  75. if (p == h || (unsigned int)(p - h) >= UHTTP_HOST_MAX)
  76. return UHTTP_ERR_URL;
  77. for (i = 0; i < (unsigned int)(p - h); i++)
  78. u->host[i] = h[i];
  79. u->host[i] = '\0';
  80. u->port = secure ? 443 : 80;
  81. if (*p == ':') {
  82. unsigned int port = 0;
  83. p++;
  84. if (*p < '0' || *p > '9')
  85. return UHTTP_ERR_URL;
  86. while (*p >= '0' && *p <= '9') {
  87. port = port * 10 + (unsigned int)(*p - '0');
  88. if (port > 65535)
  89. return UHTTP_ERR_URL;
  90. p++;
  91. }
  92. if (port == 0 || (*p != '/' && *p != '\0'))
  93. return UHTTP_ERR_URL;
  94. u->port = port;
  95. }
  96. i = 0;
  97. if (*p == '/') {
  98. while (p[i]) {
  99. if (p[i] == '#')
  100. break;
  101. if (i + 1 >= UHTTP_PATH_MAX)
  102. return UHTTP_ERR_URL;
  103. u->path[i] = p[i];
  104. i++;
  105. }
  106. }
  107. u->path[i] = '\0';
  108. if (i == 0) {
  109. u->path[0] = '/';
  110. u->path[1] = '\0';
  111. }
  112. return 0;
  113. }
  114. static void url_build(const struct uhttp_url *u, char *out, unsigned int cap)
  115. {
  116. unsigned int n = 0;
  117. #define APP(s) do { const char *ap = (s); \
  118. while (*ap && n + 1 < cap) out[n++] = *ap++; } while (0)
  119. APP(u->secure ? "https://" : "http://");
  120. APP(u->host);
  121. if (u->port != (u->secure ? 443u : 80u)) {
  122. char tmp[8];
  123. unsigned int v = u->port, k = 0, j;
  124. if (v == 0) {
  125. tmp[k++] = '0';
  126. } else {
  127. while (v && k < sizeof(tmp)) {
  128. tmp[k++] = (char)('0' + v % 10);
  129. v /= 10;
  130. }
  131. }
  132. if (n + 1 < cap)
  133. out[n++] = ':';
  134. for (j = 0; j < k && n + 1 < cap; j++)
  135. out[n++] = tmp[k - 1 - j];
  136. }
  137. APP(u->path);
  138. #undef APP
  139. out[n] = '\0';
  140. }
  141. /* Normalize an absolute URL path in place: collapse "//", "." and "..".
  142. * 0 ok, -1 too long. */
  143. static int path_normalize(char *path)
  144. {
  145. char tmp[UHTTP_PATH_MAX];
  146. unsigned int i, o = 1, len = 0, start, seglen, j;
  147. int trailing;
  148. while (path[len])
  149. len++;
  150. if (len == 0 || path[0] != '/')
  151. return 0;
  152. trailing = (len > 1 && path[len - 1] == '/');
  153. tmp[0] = '/';
  154. i = 1;
  155. while (path[i]) {
  156. while (path[i] == '/')
  157. i++;
  158. start = i;
  159. while (path[i] && path[i] != '/')
  160. i++;
  161. seglen = i - start;
  162. if (seglen == 0)
  163. break;
  164. if (seglen == 1 && path[start] == '.')
  165. continue;
  166. if (seglen == 2 && path[start] == '.' && path[start + 1] == '.') {
  167. while (o > 1 && tmp[o - 1] != '/')
  168. o--;
  169. if (o > 1)
  170. o--;
  171. continue;
  172. }
  173. if (o + seglen + 2 > sizeof(tmp))
  174. return -1;
  175. if (o > 1)
  176. tmp[o++] = '/';
  177. for (j = 0; j < seglen; j++)
  178. tmp[o++] = path[start + j];
  179. }
  180. if (trailing && o > 1 && tmp[o - 1] != '/') {
  181. if (o + 2 > sizeof(tmp))
  182. return -1;
  183. tmp[o++] = '/';
  184. }
  185. tmp[o] = '\0';
  186. for (i = 0; i <= o; i++)
  187. path[i] = tmp[i];
  188. return 0;
  189. }
  190. /* Apply a Location header to the current URL. */
  191. static int url_apply_location(struct uhttp_url *u, const char *loc)
  192. {
  193. char joined[UHTTP_PATH_MAX];
  194. char scheme[8];
  195. unsigned int i, dirlen = 1, n = 0;
  196. if (starts_with(loc, "http://") || starts_with(loc, "https://"))
  197. return uhttp_parse_url(loc, u);
  198. if (loc[0] == '/' && loc[1] == '/') {
  199. /* scheme-relative */
  200. s_copy(scheme, u->secure ? "https:" : "http:", sizeof(scheme));
  201. if (s_len(scheme) + s_len(loc) + 1 > UHTTP_LOC_MAX)
  202. return -1;
  203. {
  204. char full[UHTTP_LOC_MAX];
  205. unsigned int k = 0;
  206. while (scheme[k]) {
  207. full[k] = scheme[k];
  208. k++;
  209. }
  210. for (i = 0; loc[i] && k + 1 < sizeof(full); i++)
  211. full[k++] = loc[i];
  212. full[k] = '\0';
  213. return uhttp_parse_url(full, u);
  214. }
  215. }
  216. if (loc[0] == '/') {
  217. for (i = 0; loc[i]; i++) {
  218. if (i + 1 >= UHTTP_PATH_MAX)
  219. return -1;
  220. u->path[i] = loc[i];
  221. }
  222. u->path[i] = '\0';
  223. return path_normalize(u->path);
  224. }
  225. for (i = 0; u->path[i]; i++)
  226. if (u->path[i] == '/')
  227. dirlen = i + 1;
  228. while (loc[n])
  229. n++;
  230. if (dirlen + n + 1 > UHTTP_PATH_MAX)
  231. return -1;
  232. for (i = 0; i < dirlen; i++)
  233. joined[i] = u->path[i];
  234. for (i = 0; i < n; i++)
  235. joined[dirlen + i] = loc[i];
  236. joined[dirlen + n] = '\0';
  237. for (i = 0; i <= dirlen + n; i++)
  238. u->path[i] = joined[i];
  239. return path_normalize(u->path);
  240. }
  241. int uhttp_resolve(const char *base, const char *href, char *out,
  242. unsigned int cap)
  243. {
  244. struct uhttp_url u;
  245. if (!base || !href || !out || cap == 0)
  246. return UHTTP_ERR_URL;
  247. if (uhttp_parse_url(base, &u) != 0)
  248. return UHTTP_ERR_URL;
  249. if (href[0] == '#') {
  250. s_copy(out, base, cap);
  251. return 0;
  252. }
  253. if (url_apply_location(&u, href) != 0)
  254. return UHTTP_ERR_URL;
  255. url_build(&u, out, cap);
  256. return 0;
  257. }
  258. /* ---- HTTP header helpers ---- */
  259. static int hdr_match(const char *line, const char *name)
  260. {
  261. unsigned int i;
  262. for (i = 0; name[i]; i++) {
  263. char a = line[i];
  264. if (a >= 'A' && a <= 'Z')
  265. a = (char)(a - 'A' + 'a');
  266. if (a != name[i])
  267. return 0;
  268. }
  269. return line[i] == ':';
  270. }
  271. static int parse_dec_after_colon(const char *line, unsigned int *val)
  272. {
  273. unsigned int i = 0, v = 0;
  274. int digits = 0;
  275. while (line[i] && line[i] != ':')
  276. i++;
  277. if (line[i] != ':')
  278. return 0;
  279. i++;
  280. while (line[i] == ' ' || line[i] == '\t')
  281. i++;
  282. while (line[i] >= '0' && line[i] <= '9') {
  283. v = v * 10 + (unsigned int)(line[i] - '0');
  284. digits = 1;
  285. i++;
  286. }
  287. if (!digits)
  288. return 0;
  289. *val = v;
  290. return 1;
  291. }
  292. static void copy_after_colon(const char *line, char *out, unsigned int max)
  293. {
  294. unsigned int i = 0, j = 0;
  295. while (line[i] && line[i] != ':')
  296. i++;
  297. if (line[i] == ':')
  298. i++;
  299. while (line[i] == ' ' || line[i] == '\t')
  300. i++;
  301. while (line[i] && j + 1 < max)
  302. out[j++] = line[i++];
  303. out[j] = '\0';
  304. }
  305. static unsigned int parse_status(const char *line)
  306. {
  307. unsigned int i = 0, v = 0, digits = 0;
  308. while (line[i] && line[i] != ' ')
  309. i++;
  310. if (line[i] == ' ')
  311. i++;
  312. while (line[i] >= '0' && line[i] <= '9') {
  313. v = v * 10 + (unsigned int)(line[i] - '0');
  314. digits++;
  315. i++;
  316. }
  317. return digits == 3 ? v : 0;
  318. }
  319. /* ---- transport ---- */
  320. static int xport_send(struct uhttp *h, const void *buf, unsigned int len)
  321. {
  322. if (h->url.secure)
  323. return tls_send(buf, len);
  324. return (int)u_syscall2(SYS_TCP_SEND, (int)buf, (int)len);
  325. }
  326. static int xport_recv(struct uhttp *h, void *buf, unsigned int max,
  327. unsigned int timeout_ms)
  328. {
  329. if (h->url.secure)
  330. return tls_recv(buf, max, timeout_ms);
  331. return (int)u_syscall3(SYS_TCP_RECV, (int)buf, (int)max,
  332. (int)timeout_ms);
  333. }
  334. static void transport_close(struct uhttp *h)
  335. {
  336. if (!h->connected)
  337. return;
  338. if (h->url.secure)
  339. tls_close();
  340. u_syscall0(SYS_TCP_CLOSE);
  341. h->connected = 0;
  342. }
  343. /* Connect to h->url (TCP + TLS). Keeps the NIC acquired. */
  344. static int http_connect(struct uhttp *h)
  345. {
  346. unsigned char ip[4], hop[4], mac[6];
  347. int rv;
  348. if (u_parse_ip(h->url.host, ip) != 0) {
  349. if (u_syscall2(SYS_DNS_RESOLVE, (int)h->url.host, (int)ip) != 0)
  350. return UHTTP_ERR_DNS;
  351. }
  352. u_syscall2(SYS_NET_NEXT_HOP, (int)ip, (int)hop);
  353. rv = u_syscall2(SYS_NET_ARP, (int)hop, (int)mac);
  354. if (rv != 0)
  355. return UHTTP_ERR_ARP;
  356. rv = u_syscall3(SYS_TCP_CONNECT, (int)mac, (int)ip, (int)h->url.port);
  357. if (rv == -1)
  358. return UHTTP_ERR_TIMEOUT;
  359. if (rv == -2)
  360. return UHTTP_ERR_REFUSED;
  361. if (rv != 0)
  362. return UHTTP_ERR_CONNECT;
  363. h->connected = 1;
  364. if (h->url.secure) {
  365. if (tls_connect(h->url.host) != 0) {
  366. transport_close(h);
  367. return UHTTP_ERR_TLS;
  368. }
  369. }
  370. return 0;
  371. }
  372. /* ---- response reader ---- */
  373. static int reader_fill(struct uhttp *h, unsigned int timeout_ms)
  374. {
  375. unsigned int now, deadline, rel;
  376. int n;
  377. if (h->eof)
  378. return 0;
  379. now = u_ticks_ms();
  380. deadline = now + timeout_ms;
  381. if ((int)(h->total_deadline - deadline) < 0)
  382. deadline = h->total_deadline;
  383. rel = (int)(deadline - now) > 0 ? deadline - now : 1;
  384. n = xport_recv(h, h->buf, sizeof(h->buf), rel);
  385. if (n > 0) {
  386. h->len = (unsigned int)n;
  387. h->pos = 0;
  388. return 1;
  389. }
  390. if (n == 0) {
  391. h->eof = 1;
  392. return 0;
  393. }
  394. h->error = (n == -1) ? UHTTP_ERR_TIMEOUT : UHTTP_ERR_RESET;
  395. return 0;
  396. }
  397. static int reader_getc(struct uhttp *h, unsigned int timeout_ms)
  398. {
  399. if (h->pos >= h->len) {
  400. if (!reader_fill(h, timeout_ms))
  401. return -1;
  402. }
  403. return h->buf[h->pos++];
  404. }
  405. static int reader_readline(struct uhttp *h, char *out, unsigned int max,
  406. unsigned int timeout_ms)
  407. {
  408. unsigned int n = 0;
  409. int c;
  410. for (;;) {
  411. c = reader_getc(h, timeout_ms);
  412. if (c < 0) {
  413. out[n] = '\0';
  414. return (n == 0) ? -1 : (int)n;
  415. }
  416. if (c == '\n') {
  417. out[n] = '\0';
  418. return (int)n;
  419. }
  420. if (c == '\r')
  421. continue;
  422. if (n + 1 < max)
  423. out[n++] = (char)c;
  424. }
  425. }
  426. /* ---- request / response ---- */
  427. static unsigned int req_app(char *buf, unsigned int pos, unsigned int cap,
  428. const char *s)
  429. {
  430. while (*s && pos + 1 < cap)
  431. buf[pos++] = *s++;
  432. buf[pos] = '\0';
  433. return pos;
  434. }
  435. static unsigned int req_app_dec(char *buf, unsigned int pos, unsigned int cap,
  436. unsigned int v)
  437. {
  438. char b[12];
  439. int i = 0;
  440. if (v == 0) {
  441. if (pos + 1 < cap)
  442. buf[pos++] = '0';
  443. buf[pos] = '\0';
  444. return pos;
  445. }
  446. while (v) {
  447. b[i++] = (char)('0' + (v % 10));
  448. v /= 10;
  449. }
  450. while (i) {
  451. i--;
  452. if (pos + 1 < cap)
  453. buf[pos++] = b[i];
  454. }
  455. buf[pos] = '\0';
  456. return pos;
  457. }
  458. /* Read the status line and headers of the current response. Returns 0 and
  459. * sets redirect/location when the response is a redirect with a target. */
  460. static int read_response_head(struct uhttp *h, char *location, int *have_loc)
  461. {
  462. char line[UHTTP_LINE_MAX];
  463. unsigned int status = 0;
  464. int rv;
  465. h->resp.status = 0;
  466. h->resp.chunked = 0;
  467. h->resp.have_length = 0;
  468. h->resp.content_length = 0;
  469. h->resp.gzip = 0;
  470. h->resp.content_type[0] = '\0';
  471. h->resp.content_encoding[0] = '\0';
  472. h->chunk_state = 0;
  473. h->chunk_left = 0;
  474. h->body_read = 0;
  475. h->len = h->pos = 0;
  476. h->eof = 0;
  477. h->error = 0;
  478. *have_loc = 0;
  479. location[0] = '\0';
  480. rv = reader_readline(h, line, sizeof(line), UHTTP_IDLE_TIMEOUT_MS);
  481. if (rv < 0)
  482. return (h->error == UHTTP_ERR_RESET) ? UHTTP_ERR_RESET :
  483. UHTTP_ERR_TIMEOUT;
  484. status = parse_status(line);
  485. h->resp.status = (int)status;
  486. if (h->hooks && h->hooks->status)
  487. h->hooks->status(h->hooks->ctx, (int)status, line);
  488. for (;;) {
  489. rv = reader_readline(h, line, sizeof(line), UHTTP_IDLE_TIMEOUT_MS);
  490. if (rv < 0)
  491. return (h->error == UHTTP_ERR_RESET) ? UHTTP_ERR_RESET :
  492. UHTTP_ERR_TIMEOUT;
  493. if (rv == 0)
  494. break;
  495. if (h->hooks && h->hooks->header)
  496. h->hooks->header(h->hooks->ctx, line);
  497. if (hdr_match(line, "content-length"))
  498. h->resp.have_length =
  499. parse_dec_after_colon(line, &h->resp.content_length);
  500. else if (hdr_match(line, "transfer-encoding") &&
  501. contains_ci(line, "chunked"))
  502. h->resp.chunked = 1;
  503. else if (hdr_match(line, "content-encoding")) {
  504. copy_after_colon(line, h->resp.content_encoding,
  505. sizeof(h->resp.content_encoding));
  506. if (contains_ci(h->resp.content_encoding, "gzip"))
  507. h->resp.gzip = 1;
  508. }
  509. else if (hdr_match(line, "content-type")) {
  510. copy_after_colon(line, h->resp.content_type,
  511. sizeof(h->resp.content_type));
  512. } else if (hdr_match(line, "location")) {
  513. copy_after_colon(line, location, UHTTP_LOC_MAX);
  514. *have_loc = location[0] != '\0';
  515. }
  516. }
  517. return 0;
  518. }
  519. static int send_request(struct uhttp *h, unsigned int flags)
  520. {
  521. char req[640];
  522. unsigned int n = 0;
  523. int rv;
  524. n = req_app(req, 0, sizeof(req), "GET ");
  525. n = req_app(req, n, sizeof(req), h->url.path);
  526. n = req_app(req, n, sizeof(req), " HTTP/1.1\r\nHost: ");
  527. n = req_app(req, n, sizeof(req), h->url.host);
  528. if (h->url.port != (h->url.secure ? 443u : 80u)) {
  529. n = req_app(req, n, sizeof(req), ":");
  530. n = req_app_dec(req, n, sizeof(req), h->url.port);
  531. }
  532. n = req_app(req, n, sizeof(req), "\r\nUser-Agent: ");
  533. n = req_app(req, n, sizeof(req), h->user_agent);
  534. n = req_app(req, n, sizeof(req), "\r\nAccept: */*\r\n");
  535. if (flags & UHTTP_GZIP)
  536. n = req_app(req, n, sizeof(req), "Accept-Encoding: gzip\r\n");
  537. n = req_app(req, n, sizeof(req), "Connection: close\r\n\r\n");
  538. if ((int)n > u_syscall0(SYS_TCP_PEER_MSS))
  539. return UHTTP_ERR_TOOLONG;
  540. rv = xport_send(h, req, n);
  541. if (rv != 0)
  542. return UHTTP_ERR_SEND;
  543. return 0;
  544. }
  545. void uhttp_init(struct uhttp *h)
  546. {
  547. unsigned int i;
  548. for (i = 0; i < sizeof(*h); i++)
  549. ((unsigned char *)h)[i] = 0;
  550. h->user_agent = "nebos-uhttp/0.1";
  551. }
  552. int uhttp_open(struct uhttp *h, const char *url, unsigned int flags,
  553. const struct uhttp_hooks *hooks)
  554. {
  555. char location[UHTTP_LOC_MAX];
  556. unsigned int hops = 0;
  557. int rv;
  558. h->hooks = hooks;
  559. if (!h->user_agent)
  560. h->user_agent = "nebos-uhttp/0.1";
  561. h->len = h->pos = 0;
  562. h->eof = 0;
  563. h->error = 0;
  564. h->connected = 0;
  565. h->owns_nic = 0;
  566. if (uhttp_parse_url(url, &h->url) != 0)
  567. return UHTTP_ERR_URL;
  568. url_build(&h->url, h->resp.final_url, sizeof(h->resp.final_url));
  569. {
  570. struct sys_netinfo ni;
  571. if (u_syscall1(SYS_NET_INFO, (int)&ni) != 1)
  572. return UHTTP_ERR_NIC;
  573. if (u_syscall0(SYS_NET_CONFIGURED) != 1)
  574. return UHTTP_ERR_IP;
  575. if (u_syscall0(SYS_NET_ACQUIRE) != 0)
  576. return UHTTP_ERR_BUSY;
  577. h->owns_nic = 1;
  578. }
  579. h->total_deadline = u_ticks_ms() + UHTTP_TOTAL_TIMEOUT_MS;
  580. for (;;) {
  581. int have_loc;
  582. rv = http_connect(h);
  583. if (rv != 0)
  584. goto fail;
  585. if (h->hooks && h->hooks->connected)
  586. h->hooks->connected(h->hooks->ctx, h->url.secure);
  587. rv = send_request(h, flags);
  588. if (rv != 0)
  589. goto fail;
  590. rv = read_response_head(h, location, &have_loc);
  591. if (rv != 0)
  592. goto fail;
  593. if (h->resp.status >= 300 && h->resp.status < 400 && have_loc) {
  594. if (h->hooks && h->hooks->redirect)
  595. h->hooks->redirect(h->hooks->ctx, location);
  596. if (hops >= UHTTP_MAX_REDIRECTS) {
  597. rv = UHTTP_ERR_TOOMANY;
  598. goto fail;
  599. }
  600. transport_close(h);
  601. if (url_apply_location(&h->url, location) != 0) {
  602. rv = UHTTP_ERR_REDIRECT;
  603. goto fail;
  604. }
  605. url_build(&h->url, h->resp.final_url,
  606. sizeof(h->resp.final_url));
  607. hops++;
  608. continue;
  609. }
  610. break;
  611. }
  612. return 0;
  613. fail:
  614. uhttp_close(h);
  615. return rv;
  616. }
  617. /* Copy up to max decoded body bytes; >0 data, 0 EOF, <0 error. */
  618. int uhttp_read(struct uhttp *h, void *vbuf, unsigned int max,
  619. unsigned int timeout_ms)
  620. {
  621. unsigned char *out = (unsigned char *)vbuf;
  622. unsigned int n = 0;
  623. int c;
  624. if (h->error)
  625. return h->error;
  626. if (h->eof && h->chunk_state != 1 &&
  627. !(h->resp.have_length && h->body_read < h->resp.content_length))
  628. return 0;
  629. if (max == 0)
  630. return 0;
  631. if (!h->resp.chunked && h->resp.have_length &&
  632. h->body_read >= h->resp.content_length) {
  633. h->eof = 1;
  634. return 0;
  635. }
  636. while (n < max) {
  637. if (h->resp.chunked) {
  638. if (h->chunk_state == 0) {
  639. char line[64];
  640. unsigned int sz = 0, k = 0;
  641. int hl = reader_readline(h, line, sizeof(line),
  642. timeout_ms);
  643. if (hl < 0) {
  644. if (n)
  645. break;
  646. return h->error ? h->error : 0;
  647. }
  648. while (line[k]) {
  649. char ch = line[k];
  650. unsigned int d;
  651. if (ch >= '0' && ch <= '9')
  652. d = (unsigned int)(ch - '0');
  653. else if (ch >= 'a' && ch <= 'f')
  654. d = (unsigned int)(ch - 'a' + 10);
  655. else if (ch >= 'A' && ch <= 'F')
  656. d = (unsigned int)(ch - 'A' + 10);
  657. else
  658. break;
  659. sz = sz * 16 + d;
  660. k++;
  661. }
  662. if (k == 0) {
  663. h->error = UHTTP_ERR_RESET;
  664. return n ? (int)n : h->error;
  665. }
  666. if (sz == 0) {
  667. h->chunk_state = 3;
  668. } else {
  669. h->chunk_left = sz;
  670. h->chunk_state = 1;
  671. }
  672. } else if (h->chunk_state == 1) {
  673. c = reader_getc(h, timeout_ms);
  674. if (c < 0) {
  675. if (n)
  676. break;
  677. return h->error ? h->error : 0;
  678. }
  679. out[n++] = (unsigned char)c;
  680. h->body_read++;
  681. if (--h->chunk_left == 0)
  682. h->chunk_state = 2;
  683. } else if (h->chunk_state == 2) {
  684. (void)reader_getc(h, timeout_ms); /* CR */
  685. (void)reader_getc(h, timeout_ms); /* LF */
  686. h->chunk_state = 0;
  687. } else {
  688. char line[64];
  689. int hl = reader_readline(h, line, sizeof(line),
  690. timeout_ms);
  691. if (hl <= 0) {
  692. h->eof = 1;
  693. break;
  694. }
  695. }
  696. } else {
  697. if (h->resp.have_length &&
  698. h->body_read >= h->resp.content_length) {
  699. h->eof = 1;
  700. break;
  701. }
  702. c = reader_getc(h, timeout_ms);
  703. if (c < 0) {
  704. if (n)
  705. break;
  706. return h->error ? h->error : 0;
  707. }
  708. out[n++] = (unsigned char)c;
  709. h->body_read++;
  710. }
  711. }
  712. return (int)n;
  713. }
  714. void uhttp_close(struct uhttp *h)
  715. {
  716. transport_close(h);
  717. if (h->owns_nic) {
  718. u_syscall0(SYS_NET_RELEASE);
  719. h->owns_nic = 0;
  720. }
  721. }
  722. const char *uhttp_error_string(int err)
  723. {
  724. switch (err) {
  725. case 0: return "ok";
  726. case UHTTP_ERR_URL: return "bad URL";
  727. case UHTTP_ERR_NIC: return "no NIC found";
  728. case UHTTP_ERR_IP: return "no IP address (run dhcp or netip)";
  729. case UHTTP_ERR_BUSY: return "network busy";
  730. case UHTTP_ERR_DNS: return "DNS lookup failed";
  731. case UHTTP_ERR_ARP: return "no ARP reply";
  732. case UHTTP_ERR_CONNECT: return "connection failed";
  733. case UHTTP_ERR_REFUSED: return "connection refused";
  734. case UHTTP_ERR_TLS: return "TLS handshake failed";
  735. case UHTTP_ERR_SEND: return "request send failed";
  736. case UHTTP_ERR_TIMEOUT: return "timeout";
  737. case UHTTP_ERR_RESET: return "connection reset";
  738. case UHTTP_ERR_REDIRECT: return "bad redirect target";
  739. case UHTTP_ERR_TOOMANY: return "too many redirects";
  740. case UHTTP_ERR_TOOLONG: return "request too long";
  741. default: return "network error";
  742. }
  743. }