1 /* 2 * httpread - Manage reading file(s) from HTTP/TCP socket 3 * Author: Ted Merrill 4 * Copyright 2008 Atheros Communications 5 * 6 * This software may be distributed under the terms of the BSD license. 7 * See README for more details. 8 * 9 * The files are buffered via internal callbacks from eloop, then presented to 10 * an application callback routine when completely read into memory. May also 11 * be used if no file is expected but just to get the header, including HTTP 12 * replies (e.g. HTTP/1.1 200 OK etc.). 13 * 14 * This does not attempt to be an optimally efficient implementation, but does 15 * attempt to be of reasonably small size and memory consumption; assuming that 16 * only small files are to be read. A maximum file size is provided by 17 * application and enforced. 18 * 19 * It is assumed that the application does not expect any of the following: 20 * -- transfer encoding other than chunked 21 * -- trailer fields 22 * It is assumed that, even if the other side requested that the connection be 23 * kept open, that we will close it (thus HTTP messages sent by application 24 * should have the connection closed field); this is allowed by HTTP/1.1 and 25 * simplifies things for us. 26 * 27 * Other limitations: 28 * -- HTTP header may not exceed a hard-coded size. 29 * 30 * Notes: 31 * This code would be massively simpler without some of the new features of 32 * HTTP/1.1, especially chunked data. 33 */ 34 35 #include "includes.h" 36 37 #include "common.h" 38 #include "eloop.h" 39 #include "httpread.h" 40 41 42 /* Tunable parameters */ 43 #define HTTPREAD_READBUF_SIZE 1024 /* read in chunks of this size */ 44 #define HTTPREAD_HEADER_MAX_SIZE 4096 /* max allowed for headers */ 45 #define HTTPREAD_BODYBUF_DELTA 4096 /* increase allocation by this */ 46 47 #if 0 48 /* httpread_debug -- set this global variable > 0 e.g. from debugger 49 * to enable debugs (larger numbers for more debugs) 50 * Make this a #define of 0 to eliminate the debugging code. 51 */ 52 int httpread_debug = 99; 53 #else 54 #define httpread_debug 0 /* eliminates even the debugging code */ 55 #endif 56 57 58 /* control instance -- actual definition (opaque to application) 59 */ 60 struct httpread { 61 /* information from creation */ 62 int sd; /* descriptor of TCP socket to read from */ 63 void (*cb)(struct httpread *handle, void *cookie, 64 enum httpread_event e); /* call on event */ 65 void *cookie; /* pass to callback */ 66 int max_bytes; /* maximum file size else abort it */ 67 int timeout_seconds; /* 0 or total duration timeout period */ 68 69 /* dynamically used information follows */ 70 int sd_registered; /* nonzero if we need to unregister socket */ 71 int to_registered; /* nonzero if we need to unregister timeout */ 72 73 int got_hdr; /* nonzero when header is finalized */ 74 char hdr[HTTPREAD_HEADER_MAX_SIZE+1]; /* headers stored here */ 75 int hdr_nbytes; 76 77 enum httpread_hdr_type hdr_type; 78 int version; /* 1 if we've seen 1.1 */ 79 int reply_code; /* for type REPLY, e.g. 200 for HTTP/1.1 200 OK */ 80 int got_content_length; /* true if we know content length for sure */ 81 int content_length; /* body length, iff got_content_length */ 82 int chunked; /* nonzero for chunked data */ 83 char *uri; 84 85 int got_body; /* nonzero when body is finalized */ 86 char *body; 87 int body_nbytes; 88 int body_alloc_nbytes; /* amount allocated */ 89 90 int got_file; /* here when we are done */ 91 92 /* The following apply if data is chunked: */ 93 int in_chunk_data; /* 0=in/at header, 1=in the data or tail*/ 94 int chunk_start; /* offset in body of chunk hdr or data */ 95 int chunk_size; /* data of chunk (not hdr or ending CRLF)*/ 96 int in_trailer; /* in header fields after data (chunked only)*/ 97 enum trailer_state { 98 trailer_line_begin = 0, 99 trailer_empty_cr, /* empty line + CR */ 100 trailer_nonempty, 101 trailer_nonempty_cr, 102 } trailer_state; 103 }; 104 105 106 /* Check words for equality, where words consist of graphical characters 107 * delimited by whitespace 108 * Returns nonzero if "equal" doing case insensitive comparison. 109 */ 110 static int word_eq(char *s1, char *s2) 111 { 112 int c1; 113 int c2; 114 int end1 = 0; 115 int end2 = 0; 116 for (;;) { 117 c1 = *s1++; 118 c2 = *s2++; 119 if (isalpha(c1) && isupper(c1)) 120 c1 = tolower(c1); 121 if (isalpha(c2) && isupper(c2)) 122 c2 = tolower(c2); 123 end1 = !isgraph(c1); 124 end2 = !isgraph(c2); 125 if (end1 || end2 || c1 != c2) 126 break; 127 } 128 return end1 && end2; /* reached end of both words? */ 129 } 130 131 132 /* convert hex to binary 133 * Requires that c have been previously tested true with isxdigit(). 134 */ 135 static int hex_value(int c) 136 { 137 if (isdigit(c)) 138 return c - '0'; 139 if (islower(c)) 140 return 10 + c - 'a'; 141 return 10 + c - 'A'; 142 } 143 144 145 static void httpread_timeout_handler(void *eloop_data, void *user_ctx); 146 147 /* httpread_destroy -- if h is non-NULL, clean up 148 * This must eventually be called by the application following 149 * call of the application's callback and may be called 150 * earlier if desired. 151 */ 152 void httpread_destroy(struct httpread *h) 153 { 154 if (httpread_debug >= 10) 155 wpa_printf(MSG_DEBUG, "ENTER httpread_destroy(%p)", h); 156 if (!h) 157 return; 158 159 if (h->to_registered) 160 eloop_cancel_timeout(httpread_timeout_handler, NULL, h); 161 h->to_registered = 0; 162 if (h->sd_registered) 163 eloop_unregister_sock(h->sd, EVENT_TYPE_READ); 164 h->sd_registered = 0; 165 os_free(h->body); 166 os_free(h->uri); 167 os_memset(h, 0, sizeof(*h)); /* aid debugging */ 168 h->sd = -1; /* aid debugging */ 169 os_free(h); 170 } 171 172 173 /* httpread_timeout_handler -- called on excessive total duration 174 */ 175 static void httpread_timeout_handler(void *eloop_data, void *user_ctx) 176 { 177 struct httpread *h = user_ctx; 178 wpa_printf(MSG_DEBUG, "httpread timeout (%p)", h); 179 h->to_registered = 0; /* is self-cancelling */ 180 (*h->cb)(h, h->cookie, HTTPREAD_EVENT_TIMEOUT); 181 } 182 183 184 /* Analyze options only so far as is needed to correctly obtain the file. 185 * The application can look at the raw header to find other options. 186 */ 187 static int httpread_hdr_option_analyze( 188 struct httpread *h, 189 char *hbp /* pointer to current line in header buffer */ 190 ) 191 { 192 if (word_eq(hbp, "CONTENT-LENGTH:")) { 193 while (isgraph(*hbp)) 194 hbp++; 195 while (*hbp == ' ' || *hbp == '\t') 196 hbp++; 197 if (!isdigit(*hbp)) 198 return -1; 199 h->content_length = atol(hbp); 200 h->got_content_length = 1; 201 return 0; 202 } 203 if (word_eq(hbp, "TRANSFER_ENCODING:") || 204 word_eq(hbp, "TRANSFER-ENCODING:")) { 205 while (isgraph(*hbp)) 206 hbp++; 207 while (*hbp == ' ' || *hbp == '\t') 208 hbp++; 209 /* There should (?) be no encodings of interest 210 * other than chunked... 211 */ 212 if (word_eq(hbp, "CHUNKED")) { 213 h->chunked = 1; 214 h->in_chunk_data = 0; 215 /* ignore possible ;<parameters> */ 216 } 217 return 0; 218 } 219 /* skip anything we don't know, which is a lot */ 220 return 0; 221 } 222 223 224 static int httpread_hdr_analyze(struct httpread *h) 225 { 226 char *hbp = h->hdr; /* pointer into h->hdr */ 227 int standard_first_line = 1; 228 229 /* First line is special */ 230 h->hdr_type = HTTPREAD_HDR_TYPE_UNKNOWN; 231 if (!isgraph(*hbp)) 232 goto bad; 233 if (os_strncmp(hbp, "HTTP/", 5) == 0) { 234 h->hdr_type = HTTPREAD_HDR_TYPE_REPLY; 235 standard_first_line = 0; 236 hbp += 5; 237 if (hbp[0] == '1' && hbp[1] == '.' && 238 isdigit(hbp[2]) && hbp[2] != '0') 239 h->version = 1; 240 while (isgraph(*hbp)) 241 hbp++; 242 while (*hbp == ' ' || *hbp == '\t') 243 hbp++; 244 if (!isdigit(*hbp)) 245 goto bad; 246 h->reply_code = atol(hbp); 247 } else if (word_eq(hbp, "GET")) 248 h->hdr_type = HTTPREAD_HDR_TYPE_GET; 249 else if (word_eq(hbp, "HEAD")) 250 h->hdr_type = HTTPREAD_HDR_TYPE_HEAD; 251 else if (word_eq(hbp, "POST")) 252 h->hdr_type = HTTPREAD_HDR_TYPE_POST; 253 else if (word_eq(hbp, "PUT")) 254 h->hdr_type = HTTPREAD_HDR_TYPE_PUT; 255 else if (word_eq(hbp, "DELETE")) 256 h->hdr_type = HTTPREAD_HDR_TYPE_DELETE; 257 else if (word_eq(hbp, "TRACE")) 258 h->hdr_type = HTTPREAD_HDR_TYPE_TRACE; 259 else if (word_eq(hbp, "CONNECT")) 260 h->hdr_type = HTTPREAD_HDR_TYPE_CONNECT; 261 else if (word_eq(hbp, "NOTIFY")) 262 h->hdr_type = HTTPREAD_HDR_TYPE_NOTIFY; 263 else if (word_eq(hbp, "M-SEARCH")) 264 h->hdr_type = HTTPREAD_HDR_TYPE_M_SEARCH; 265 else if (word_eq(hbp, "M-POST")) 266 h->hdr_type = HTTPREAD_HDR_TYPE_M_POST; 267 else if (word_eq(hbp, "SUBSCRIBE")) 268 h->hdr_type = HTTPREAD_HDR_TYPE_SUBSCRIBE; 269 else if (word_eq(hbp, "UNSUBSCRIBE")) 270 h->hdr_type = HTTPREAD_HDR_TYPE_UNSUBSCRIBE; 271 else { 272 } 273 274 if (standard_first_line) { 275 char *rawuri; 276 char *uri; 277 /* skip type */ 278 while (isgraph(*hbp)) 279 hbp++; 280 while (*hbp == ' ' || *hbp == '\t') 281 hbp++; 282 /* parse uri. 283 * Find length, allocate memory for translated 284 * copy, then translate by changing %<hex><hex> 285 * into represented value. 286 */ 287 rawuri = hbp; 288 while (isgraph(*hbp)) 289 hbp++; 290 h->uri = os_malloc((hbp - rawuri) + 1); 291 if (h->uri == NULL) 292 goto bad; 293 uri = h->uri; 294 while (rawuri < hbp) { 295 int c = *rawuri; 296 if (c == '%' && 297 isxdigit(rawuri[1]) && isxdigit(rawuri[2])) { 298 *uri++ = (hex_value(rawuri[1]) << 4) | 299 hex_value(rawuri[2]); 300 rawuri += 3; 301 } else { 302 *uri++ = c; 303 rawuri++; 304 } 305 } 306 *uri = 0; /* null terminate */ 307 while (isgraph(*hbp)) 308 hbp++; 309 while (*hbp == ' ' || *hbp == '\t') 310 hbp++; 311 /* get version */ 312 if (0 == strncmp(hbp, "HTTP/", 5)) { 313 hbp += 5; 314 if (hbp[0] == '1' && hbp[1] == '.' && 315 isdigit(hbp[2]) && hbp[2] != '0') 316 h->version = 1; 317 } 318 } 319 /* skip rest of line */ 320 while (*hbp) 321 if (*hbp++ == '\n') 322 break; 323 324 /* Remainder of lines are options, in any order; 325 * or empty line to terminate 326 */ 327 for (;;) { 328 /* Empty line to terminate */ 329 if (hbp[0] == '\n' || 330 (hbp[0] == '\r' && hbp[1] == '\n')) 331 break; 332 if (!isgraph(*hbp)) 333 goto bad; 334 if (httpread_hdr_option_analyze(h, hbp)) 335 goto bad; 336 /* skip line */ 337 while (*hbp) 338 if (*hbp++ == '\n') 339 break; 340 } 341 342 /* chunked overrides content-length always */ 343 if (h->chunked) 344 h->got_content_length = 0; 345 346 /* For some types, we should not try to read a body 347 * This is in addition to the application determining 348 * that we should not read a body. 349 */ 350 switch (h->hdr_type) { 351 case HTTPREAD_HDR_TYPE_REPLY: 352 /* Some codes can have a body and some not. 353 * For now, just assume that any other than 200 354 * do not... 355 */ 356 if (h->reply_code != 200) 357 h->max_bytes = 0; 358 break; 359 case HTTPREAD_HDR_TYPE_GET: 360 case HTTPREAD_HDR_TYPE_HEAD: 361 /* in practice it appears that it is assumed 362 * that GETs have a body length of 0... ? 363 */ 364 if (h->chunked == 0 && h->got_content_length == 0) 365 h->max_bytes = 0; 366 break; 367 case HTTPREAD_HDR_TYPE_POST: 368 case HTTPREAD_HDR_TYPE_PUT: 369 case HTTPREAD_HDR_TYPE_DELETE: 370 case HTTPREAD_HDR_TYPE_TRACE: 371 case HTTPREAD_HDR_TYPE_CONNECT: 372 case HTTPREAD_HDR_TYPE_NOTIFY: 373 case HTTPREAD_HDR_TYPE_M_SEARCH: 374 case HTTPREAD_HDR_TYPE_M_POST: 375 case HTTPREAD_HDR_TYPE_SUBSCRIBE: 376 case HTTPREAD_HDR_TYPE_UNSUBSCRIBE: 377 default: 378 break; 379 } 380 381 return 0; 382 383 bad: 384 /* Error */ 385 return -1; 386 } 387 388 389 /* httpread_read_handler -- called when socket ready to read 390 * 391 * Note: any extra data we read past end of transmitted file is ignored; 392 * if we were to support keeping connections open for multiple files then 393 * this would have to be addressed. 394 */ 395 static void httpread_read_handler(int sd, void *eloop_ctx, void *sock_ctx) 396 { 397 struct httpread *h = sock_ctx; 398 int nread; 399 char *rbp; /* pointer into read buffer */ 400 char *hbp; /* pointer into header buffer */ 401 char *bbp; /* pointer into body buffer */ 402 char readbuf[HTTPREAD_READBUF_SIZE]; /* temp use to read into */ 403 404 if (httpread_debug >= 20) 405 wpa_printf(MSG_DEBUG, "ENTER httpread_read_handler(%p)", h); 406 407 /* read some at a time, then search for the interal 408 * boundaries between header and data and etc. 409 */ 410 nread = read(h->sd, readbuf, sizeof(readbuf)); 411 if (nread < 0) 412 goto bad; 413 if (nread == 0) { 414 /* end of transmission... this may be normal 415 * or may be an error... in some cases we can't 416 * tell which so we must assume it is normal then. 417 */ 418 if (!h->got_hdr) { 419 /* Must at least have completed header */ 420 wpa_printf(MSG_DEBUG, "httpread premature eof(%p)", h); 421 goto bad; 422 } 423 if (h->chunked || h->got_content_length) { 424 /* Premature EOF; e.g. dropped connection */ 425 wpa_printf(MSG_DEBUG, 426 "httpread premature eof(%p) %d/%d", 427 h, h->body_nbytes, 428 h->content_length); 429 goto bad; 430 } 431 /* No explicit length, hopefully we have all the data 432 * although dropped connections can cause false 433 * end 434 */ 435 if (httpread_debug >= 10) 436 wpa_printf(MSG_DEBUG, "httpread ok eof(%p)", h); 437 h->got_body = 1; 438 goto got_file; 439 } 440 rbp = readbuf; 441 442 /* Header consists of text lines (terminated by both CR and LF) 443 * and an empty line (CR LF only). 444 */ 445 if (!h->got_hdr) { 446 hbp = h->hdr + h->hdr_nbytes; 447 /* add to headers until: 448 * -- we run out of data in read buffer 449 * -- or, we run out of header buffer room 450 * -- or, we get double CRLF in headers 451 */ 452 for (;;) { 453 if (nread == 0) 454 goto get_more; 455 if (h->hdr_nbytes == HTTPREAD_HEADER_MAX_SIZE) { 456 goto bad; 457 } 458 *hbp++ = *rbp++; 459 nread--; 460 h->hdr_nbytes++; 461 if (h->hdr_nbytes >= 4 && 462 hbp[-1] == '\n' && 463 hbp[-2] == '\r' && 464 hbp[-3] == '\n' && 465 hbp[-4] == '\r' ) { 466 h->got_hdr = 1; 467 *hbp = 0; /* null terminate */ 468 break; 469 } 470 } 471 /* here we've just finished reading the header */ 472 if (httpread_hdr_analyze(h)) { 473 wpa_printf(MSG_DEBUG, "httpread bad hdr(%p)", h); 474 goto bad; 475 } 476 if (h->max_bytes == 0) { 477 if (httpread_debug >= 10) 478 wpa_printf(MSG_DEBUG, 479 "httpread no body hdr end(%p)", h); 480 goto got_file; 481 } 482 if (h->got_content_length && h->content_length == 0) { 483 if (httpread_debug >= 10) 484 wpa_printf(MSG_DEBUG, 485 "httpread zero content length(%p)", 486 h); 487 goto got_file; 488 } 489 } 490 491 /* Certain types of requests never have data and so 492 * must be specially recognized. 493 */ 494 if (!os_strncasecmp(h->hdr, "SUBSCRIBE", 9) || 495 !os_strncasecmp(h->hdr, "UNSUBSCRIBE", 11) || 496 !os_strncasecmp(h->hdr, "HEAD", 4) || 497 !os_strncasecmp(h->hdr, "GET", 3)) { 498 if (!h->got_body) { 499 if (httpread_debug >= 10) 500 wpa_printf(MSG_DEBUG, 501 "httpread NO BODY for sp. type"); 502 } 503 h->got_body = 1; 504 goto got_file; 505 } 506 507 /* Data can be just plain binary data, or if "chunked" 508 * consists of chunks each with a header, ending with 509 * an ending header. 510 */ 511 if (nread == 0) 512 goto get_more; 513 if (!h->got_body) { 514 /* Here to get (more of) body */ 515 /* ensure we have enough room for worst case for body 516 * plus a null termination character 517 */ 518 if (h->body_alloc_nbytes < (h->body_nbytes + nread + 1)) { 519 char *new_body; 520 int new_alloc_nbytes; 521 522 if (h->body_nbytes >= h->max_bytes) 523 goto bad; 524 new_alloc_nbytes = h->body_alloc_nbytes + 525 HTTPREAD_BODYBUF_DELTA; 526 /* For content-length case, the first time 527 * through we allocate the whole amount 528 * we need. 529 */ 530 if (h->got_content_length && 531 new_alloc_nbytes < (h->content_length + 1)) 532 new_alloc_nbytes = h->content_length + 1; 533 if ((new_body = os_realloc(h->body, new_alloc_nbytes)) 534 == NULL) 535 goto bad; 536 537 h->body = new_body; 538 h->body_alloc_nbytes = new_alloc_nbytes; 539 } 540 /* add bytes */ 541 bbp = h->body + h->body_nbytes; 542 for (;;) { 543 int ncopy; 544 /* See if we need to stop */ 545 if (h->chunked && h->in_chunk_data == 0) { 546 /* in chunk header */ 547 char *cbp = h->body + h->chunk_start; 548 if (bbp-cbp >= 2 && bbp[-2] == '\r' && 549 bbp[-1] == '\n') { 550 /* end of chunk hdr line */ 551 /* hdr line consists solely 552 * of a hex numeral and CFLF 553 */ 554 if (!isxdigit(*cbp)) 555 goto bad; 556 h->chunk_size = strtoul(cbp, NULL, 16); 557 /* throw away chunk header 558 * so we have only real data 559 */ 560 h->body_nbytes = h->chunk_start; 561 bbp = cbp; 562 if (h->chunk_size == 0) { 563 /* end of chunking */ 564 /* trailer follows */ 565 h->in_trailer = 1; 566 if (httpread_debug >= 20) 567 wpa_printf( 568 MSG_DEBUG, 569 "httpread end chunks(%p)", h); 570 break; 571 } 572 h->in_chunk_data = 1; 573 /* leave chunk_start alone */ 574 } 575 } else if (h->chunked) { 576 /* in chunk data */ 577 if ((h->body_nbytes - h->chunk_start) == 578 (h->chunk_size + 2)) { 579 /* end of chunk reached, 580 * new chunk starts 581 */ 582 /* check chunk ended w/ CRLF 583 * which we'll throw away 584 */ 585 if (bbp[-1] == '\n' && 586 bbp[-2] == '\r') { 587 } else 588 goto bad; 589 h->body_nbytes -= 2; 590 bbp -= 2; 591 h->chunk_start = h->body_nbytes; 592 h->in_chunk_data = 0; 593 h->chunk_size = 0; /* just in case */ 594 } 595 } else if (h->got_content_length && 596 h->body_nbytes >= h->content_length) { 597 h->got_body = 1; 598 if (httpread_debug >= 10) 599 wpa_printf( 600 MSG_DEBUG, 601 "httpread got content(%p)", h); 602 goto got_file; 603 } 604 if (nread <= 0) 605 break; 606 /* Now transfer. Optimize using memcpy where we can. */ 607 if (h->chunked && h->in_chunk_data) { 608 /* copy up to remainder of chunk data 609 * plus the required CR+LF at end 610 */ 611 ncopy = (h->chunk_start + h->chunk_size + 2) - 612 h->body_nbytes; 613 } else if (h->chunked) { 614 /*in chunk header -- don't optimize */ 615 *bbp++ = *rbp++; 616 nread--; 617 h->body_nbytes++; 618 continue; 619 } else if (h->got_content_length) { 620 ncopy = h->content_length - h->body_nbytes; 621 } else { 622 ncopy = nread; 623 } 624 /* Note: should never be 0 */ 625 if (ncopy > nread) 626 ncopy = nread; 627 os_memcpy(bbp, rbp, ncopy); 628 bbp += ncopy; 629 h->body_nbytes += ncopy; 630 rbp += ncopy; 631 nread -= ncopy; 632 } /* body copy loop */ 633 } /* !got_body */ 634 if (h->chunked && h->in_trailer) { 635 /* If "chunked" then there is always a trailer, 636 * consisting of zero or more non-empty lines 637 * ending with CR LF and then an empty line w/ CR LF. 638 * We do NOT support trailers except to skip them -- 639 * this is supported (generally) by the http spec. 640 */ 641 bbp = h->body + h->body_nbytes; 642 for (;;) { 643 int c; 644 if (nread <= 0) 645 break; 646 c = *rbp++; 647 nread--; 648 switch (h->trailer_state) { 649 case trailer_line_begin: 650 if (c == '\r') 651 h->trailer_state = trailer_empty_cr; 652 else 653 h->trailer_state = trailer_nonempty; 654 break; 655 case trailer_empty_cr: 656 /* end empty line */ 657 if (c == '\n') { 658 h->trailer_state = trailer_line_begin; 659 h->in_trailer = 0; 660 if (httpread_debug >= 10) 661 wpa_printf( 662 MSG_DEBUG, 663 "httpread got content(%p)", h); 664 h->got_body = 1; 665 goto got_file; 666 } 667 h->trailer_state = trailer_nonempty; 668 break; 669 case trailer_nonempty: 670 if (c == '\r') 671 h->trailer_state = trailer_nonempty_cr; 672 break; 673 case trailer_nonempty_cr: 674 if (c == '\n') 675 h->trailer_state = trailer_line_begin; 676 else 677 h->trailer_state = trailer_nonempty; 678 break; 679 } 680 } 681 } 682 goto get_more; 683 684 bad: 685 /* Error */ 686 wpa_printf(MSG_DEBUG, "httpread read/parse failure (%p)", h); 687 (*h->cb)(h, h->cookie, HTTPREAD_EVENT_ERROR); 688 return; 689 690 get_more: 691 return; 692 693 got_file: 694 if (httpread_debug >= 10) 695 wpa_printf(MSG_DEBUG, 696 "httpread got file %d bytes type %d", 697 h->body_nbytes, h->hdr_type); 698 /* Null terminate for convenience of some applications */ 699 if (h->body) 700 h->body[h->body_nbytes] = 0; /* null terminate */ 701 h->got_file = 1; 702 /* Assume that we do NOT support keeping connection alive, 703 * and just in case somehow we don't get destroyed right away, 704 * unregister now. 705 */ 706 if (h->sd_registered) 707 eloop_unregister_sock(h->sd, EVENT_TYPE_READ); 708 h->sd_registered = 0; 709 /* The application can destroy us whenever they feel like... 710 * cancel timeout. 711 */ 712 if (h->to_registered) 713 eloop_cancel_timeout(httpread_timeout_handler, NULL, h); 714 h->to_registered = 0; 715 (*h->cb)(h, h->cookie, HTTPREAD_EVENT_FILE_READY); 716 } 717 718 719 /* httpread_create -- start a new reading session making use of eloop. 720 * The new instance will use the socket descriptor for reading (until 721 * it gets a file and not after) but will not close the socket, even 722 * when the instance is destroyed (the application must do that). 723 * Return NULL on error. 724 * 725 * Provided that httpread_create successfully returns a handle, 726 * the callback fnc is called to handle httpread_event events. 727 * The caller should do destroy on any errors or unknown events. 728 * 729 * Pass max_bytes == 0 to not read body at all (required for e.g. 730 * reply to HEAD request). 731 */ 732 struct httpread * httpread_create( 733 int sd, /* descriptor of TCP socket to read from */ 734 void (*cb)(struct httpread *handle, void *cookie, 735 enum httpread_event e), /* call on event */ 736 void *cookie, /* pass to callback */ 737 int max_bytes, /* maximum body size else abort it */ 738 int timeout_seconds /* 0; or total duration timeout period */ 739 ) 740 { 741 struct httpread *h = NULL; 742 743 h = os_zalloc(sizeof(*h)); 744 if (h == NULL) 745 goto fail; 746 h->sd = sd; 747 h->cb = cb; 748 h->cookie = cookie; 749 h->max_bytes = max_bytes; 750 h->timeout_seconds = timeout_seconds; 751 752 if (timeout_seconds > 0) { 753 if (eloop_register_timeout(timeout_seconds, 0, 754 httpread_timeout_handler, 755 NULL, h)) { 756 /* No way to recover (from malloc failure) */ 757 goto fail; 758 } 759 h->to_registered = 1; 760 } 761 if (eloop_register_sock(sd, EVENT_TYPE_READ, httpread_read_handler, 762 NULL, h)) { 763 /* No way to recover (from malloc failure) */ 764 goto fail; 765 } 766 h->sd_registered = 1; 767 return h; 768 769 fail: 770 771 /* Error */ 772 httpread_destroy(h); 773 return NULL; 774 } 775 776 777 /* httpread_hdr_type_get -- When file is ready, returns header type. */ 778 enum httpread_hdr_type httpread_hdr_type_get(struct httpread *h) 779 { 780 return h->hdr_type; 781 } 782 783 784 /* httpread_uri_get -- When file is ready, uri_get returns (translated) URI 785 * or possibly NULL (which would be an error). 786 */ 787 char * httpread_uri_get(struct httpread *h) 788 { 789 return h->uri; 790 } 791 792 793 /* httpread_reply_code_get -- When reply is ready, returns reply code */ 794 int httpread_reply_code_get(struct httpread *h) 795 { 796 return h->reply_code; 797 } 798 799 800 /* httpread_length_get -- When file is ready, returns file length. */ 801 int httpread_length_get(struct httpread *h) 802 { 803 return h->body_nbytes; 804 } 805 806 807 /* httpread_data_get -- When file is ready, returns file content 808 * with null byte appened. 809 * Might return NULL in some error condition. 810 */ 811 void * httpread_data_get(struct httpread *h) 812 { 813 return h->body ? h->body : ""; 814 } 815 816 817 /* httpread_hdr_get -- When file is ready, returns header content 818 * with null byte appended. 819 * Might return NULL in some error condition. 820 */ 821 char * httpread_hdr_get(struct httpread *h) 822 { 823 return h->hdr; 824 } 825 826 827 /* httpread_hdr_line_get -- When file is ready, returns pointer 828 * to line within header content matching the given tag 829 * (after the tag itself and any spaces/tabs). 830 * 831 * The tag should end with a colon for reliable matching. 832 * 833 * If not found, returns NULL; 834 */ 835 char * httpread_hdr_line_get(struct httpread *h, const char *tag) 836 { 837 int tag_len = os_strlen(tag); 838 char *hdr = h->hdr; 839 hdr = os_strchr(hdr, '\n'); 840 if (hdr == NULL) 841 return NULL; 842 hdr++; 843 for (;;) { 844 if (!os_strncasecmp(hdr, tag, tag_len)) { 845 hdr += tag_len; 846 while (*hdr == ' ' || *hdr == '\t') 847 hdr++; 848 return hdr; 849 } 850 hdr = os_strchr(hdr, '\n'); 851 if (hdr == NULL) 852 return NULL; 853 hdr++; 854 } 855 } 856