Lines Matching refs:request
81 * - 5.1.1: request methods. only MUST support GET and HEAD,
91 * just ignore them and send the request anyway. they are
160 #define TOTAL_MAX_REQ_TIME "600" /* must have total request in 600 */
180 { REDIRECT_FILE, "rejected redirect request" },
181 { ABSREDIRECT_FILE, "rejected absredirect request" },
182 { REMAP_FILE, "rejected remap request" },
183 { AUTH_FILE, "rejected authfile request" },
282 * convert "in" into the three parts of a request (first line).
340 bozo_clean_request(bozo_httpreq_t *request)
344 if (request == NULL)
348 bozo_ssl_destroy(request->hr_httpd);
350 /* clean up request */
351 free(request->hr_remotehost);
352 free(request->hr_remoteaddr);
353 free(request->hr_serverport);
354 free(request->hr_virthostname);
355 free(request->hr_file_free);
357 if (request->hr_file_free != request->hr_oldfile)
358 free(request->hr_oldfile);
360 free(request->hr_file);
361 free(request->hr_query);
362 free(request->hr_host);
363 bozo_user_free(request->hr_user);
364 bozo_auth_cleanup(request);
365 for (hdr = SIMPLEQ_FIRST(&request->hr_headers); hdr;
374 for (hdr = SIMPLEQ_FIRST(&request->hr_replheaders); hdr;
383 free(request);
399 * set a timeout for "ssl", "initial", "header", or "request".
409 "request timeout",
435 addmerge_header(bozo_httpreq_t *request, struct qheaders *headers,
438 struct bozohttpd_t *httpd = request->hr_httpd;
466 hdr->h_header = bozostrdup(httpd, request, val);
468 hdr->h_value = bozostrdup(httpd, request, str);
470 hdr->h_value = bozostrdup(httpd, request, " ");
473 request->hr_nheaders++;
480 addmerge_reqheader(bozo_httpreq_t *request, const char *val, const char *str,
484 return addmerge_header(request, &request->hr_headers, val, str, len);
488 addmerge_replheader(bozo_httpreq_t *request, const char *val, const char *str,
492 return addmerge_header(request, &request->hr_replheaders,
501 process_proto(bozo_httpreq_t *request, const char *proto)
503 struct bozohttpd_t *httpd = request->hr_httpd;
509 request->hr_proto = httpd->consts.http_09;
510 debug((httpd, DEBUG_FAT, "request %s is http/0.9",
511 request->hr_file));
534 request->hr_proto = httpd->consts.http_10;
536 request->hr_proto = httpd->consts.http_11;
540 debug((httpd, DEBUG_FAT, "request %s is %s",
541 request->hr_file, request->hr_proto));
542 SIMPLEQ_INIT(&request->hr_headers);
543 request->hr_nheaders = 0;
572 process_method(bozo_httpreq_t *request, const char *method)
574 struct bozohttpd_t *httpd = request->hr_httpd;
577 if (request->hr_proto == httpd->consts.http_11)
578 request->hr_allow = "GET, HEAD, POST";
582 request->hr_method = mmp->type;
583 request->hr_methodstr = mmp->name;
587 return bozo_http_error(httpd, 404, request, "unknown method");
592 bozo_got_header_length(bozo_httpreq_t *request, size_t len)
595 if (len > BOZO_HEADERS_MAX_SIZE - request->hr_header_bytes)
596 return bozo_http_error(request->hr_httpd, 413, request,
599 request->hr_header_bytes += len;
605 * This function reads a http request from stdin, returning a pointer to a
606 * bozo_httpreq_t structure, describing the request.
620 bozo_httpreq_t *request;
631 request = bozomalloc(httpd, sizeof(*request));
632 memset(request, 0, sizeof(*request));
633 request->hr_httpd = httpd;
634 request->hr_allow = request->hr_host = NULL;
635 request->hr_content_type = request->hr_content_length = NULL;
636 request->hr_range = NULL;
637 request->hr_last_byte_pos = -1;
638 request->hr_if_modified_since = NULL;
639 request->hr_virthostname = NULL;
640 request->hr_file_free = NULL;
641 request->hr_file = NULL;
642 request->hr_oldfile = NULL;
643 SIMPLEQ_INIT(&request->hr_replheaders);
644 bozo_auth_init(request);
663 request->hr_remotehost = bozostrdup(httpd, request, host);
665 request->hr_remoteaddr = bozostrdup(httpd, request, addr);
669 * Override the bound port from the request value, so it works even
681 request->hr_serverport = bozostrdup(httpd, request, port);
684 * setup a timer to make sure the request is not hung
699 * caller there was no request to process and it will wait for
715 * tv_sec, or if current tv_sec is less than the request
730 bozo_http_error(httpd, 408, NULL, "request timed out");
741 "got request ``%s'' from host %s to port %s",
748 request->hr_file_free = request->hr_file = file;
749 request->hr_query = query;
764 if (process_proto(request, proto) ||
765 process_method(request, method)) {
770 request->hr_file,
771 request->hr_query ? request->hr_query : "<none>"));
774 if (request->hr_proto == httpd->consts.http_09)
787 bozo_http_error(httpd, 404, request, "no header");
791 bozo_http_error(httpd, 404, request,
800 if (bozo_got_header_length(request, len))
803 if (bozo_auth_check_headers(request, val, str, len))
806 hdr = addmerge_reqheader(request, val, str, len);
809 request->hr_content_type = hdr->h_value;
811 request->hr_content_length = hdr->h_value;
813 if (request->hr_host) {
815 bozo_http_error(httpd, 400, request,
819 request->hr_host = bozostrdup(httpd, request,
824 bozo_http_error(httpd, 417, request,
830 request->hr_referrer = hdr->h_value;
832 request->hr_range = hdr->h_value;
835 request->hr_if_modified_since = hdr->h_value;
838 request->hr_accept_encoding = hdr->h_value;
847 bozo_http_error(httpd, 413, request, "request too large");
856 if (request->hr_method == HTTP_POST &&
857 request->hr_content_length == NULL) {
858 bozo_http_error(httpd, 400, request, "missing content length");
863 if (request->hr_proto == httpd->consts.http_11 &&
864 /*(strncasecmp(request->hr_file, "http://", 7) != 0) &&*/
865 request->hr_host == NULL) {
866 bozo_http_error(httpd, 400, request, "missing Host header");
870 if (request->hr_range != NULL) {
871 debug((httpd, DEBUG_FAT, "hr_range: %s", request->hr_range));
873 if (strchr(request->hr_range, ',') == NULL) {
876 rstart = strchr(request->hr_range, '=');
882 request->hr_have_range = 1;
883 request->hr_first_byte_pos =
885 if (request->hr_first_byte_pos < 0)
886 request->hr_first_byte_pos = 0;
888 request->hr_last_byte_pos =
890 if (request->hr_last_byte_pos < 0)
891 request->hr_last_byte_pos = -1;
898 debug((httpd, DEBUG_FAT, "bozo_read_request returns url %s in request",
899 request->hr_file));
900 return request;
903 bozo_clean_request(request);
1059 handle_redirect(bozo_httpreq_t *request, const char *url, int absolute)
1061 bozohttpd_t *httpd = request->hr_httpd;
1068 const char *hostname = BOZOHOST(httpd, request);
1072 bozoasprintf(httpd, &urlbuf, "/%s/", request->hr_file);
1078 if (request->hr_user && !absolute) {
1079 bozoasprintf(httpd, &userbuf, "/~%s%s", request->hr_user, url);
1124 if (request->hr_serverport &&
1125 strcmp(request->hr_serverport, defport) != 0)
1127 request->hr_serverport);
1134 if (request->hr_query && strlen(request->hr_query)) {
1135 query = request->hr_query;
1147 bozo_printf(httpd, "%s 301 Document Moved\r\n", request->hr_proto);
1148 if (request->hr_proto != httpd->consts.http_09)
1149 bozo_print_header(request, NULL, "text/html", NULL);
1150 if (request->hr_proto != httpd->consts.http_09)
1153 if (request->hr_method == HTTP_HEAD)
1196 * Check if the request refers to a uri that is mapped via a .bzremap.
1202 check_remap(bozo_httpreq_t *request)
1204 bozohttpd_t *httpd = request->hr_httpd;
1205 char *file = request->hr_file, *newfile;
1307 free(request->hr_file_free);
1308 request->hr_file_free = request->hr_file = newfile;
1324 check_virtual(bozo_httpreq_t *request)
1326 bozohttpd_t *httpd = request->hr_httpd;
1327 char *file = request->hr_file, *s;
1331 * convert http://virtual.host/ to request->hr_host
1339 free(request->hr_host);
1340 request->hr_host = bozostrdup(httpd, request, file);
1341 if ((s = strchr(request->hr_host, '/')) != NULL)
1344 free(request->hr_file_free);
1345 request->hr_file_free = request->hr_file =
1346 bozostrdup(httpd, request, s ? s : "/");
1348 request->hr_host, request->hr_file));
1349 } else if (!request->hr_host)
1355 len = strlen(request->hr_host);
1357 strcmp(request->hr_host + len - 3, ":" BOZO_HTTP_PORT) == 0) {
1358 request->hr_host[len - 3] = '\0';
1359 len = strlen(request->hr_host);
1368 if (request->hr_host) {
1369 s = strrchr(request->hr_host, ':');
1376 request->hr_virthostname = bozostrdup(httpd, request,
1377 request->hr_host);
1394 request->hr_host, httpd->virtbase, request->hr_file));
1395 if (strncasecmp(httpd->virthostname, request->hr_host, len) != 0) {
1408 if (strcmp(d->d_name, request->hr_host) == 0) {
1411 request->hr_virthostname =
1412 bozostrdup(httpd, request, d->d_name);
1415 request->hr_virthostname);
1428 return bozo_http_error(httpd, 404, request,
1439 return bozo_http_error(httpd, 404, request,
1443 * is there a mapping for this request?
1445 check_remap(request);
1451 * checks to see if this request has a valid .bzredirect file. returns
1456 check_bzredirect(bozo_httpreq_t *request)
1458 bozohttpd_t *httpd = request->hr_httpd;
1469 if ((size_t)snprintf(dir, sizeof(dir), "%s", request->hr_file + 1) >=
1471 bozo_http_error(httpd, 404, request, "file path too long");
1484 basename = request->hr_file + 1;
1489 if (bozo_check_special_files(request, basename, true))
1496 return bozo_http_error(httpd, 404, request,
1506 bozo_http_error(httpd, 404, request,
1525 if (bozo_auth_check(request, path))
1532 bozo_http_error(httpd, 404, request,
1540 handle_redirect(request, finalredir, absolute);
1546 bozo_decode_url_percent(bozo_httpreq_t *request, char *str)
1548 bozohttpd_t *httpd = request->hr_httpd;
1576 return bozo_http_error(httpd, 400, request,
1579 return bozo_http_error(httpd, 404, request,
1582 return bozo_http_error(httpd, 404, request,
1593 return bozo_http_error(httpd, 400, request,
1605 request->hr_file));
1626 transform_request(bozo_httpreq_t *request, int *isindex)
1628 bozohttpd_t *httpd = request->hr_httpd;
1634 debug((httpd, DEBUG_FAT, "tf_req: file %s", request->hr_file));
1636 if (bozo_decode_url_percent(request, request->hr_file) ||
1637 check_virtual(request))
1640 file = request->hr_file;
1643 bozo_http_error(httpd, 404, request, "unknown URL");
1652 request->hr_file = file;
1660 bozo_http_error(httpd, 404, request,
1668 handle_redirect(request, userredirecturl, 0);
1674 if (!bozo_user_transform(request))
1677 file = request->hr_file;
1683 switch (check_bzredirect(request)) {
1702 newfile = bozostrdup(httpd, request, file + 1);
1705 newfile = bozostrdup(httpd, request, httpd->index_html);
1708 bozo_http_error(httpd, 500, request, "request->hr_file is nul");
1713 bozo_http_error(httpd, 500, request, "internal failure");
1728 bozo_http_error(httpd, 403, request, "illegal request");
1732 if (bozo_auth_check(request, newfile))
1736 request->hr_oldfile = request->hr_file_free;
1737 request->hr_file = newfile;
1740 if (bozo_process_cgi(request) ||
1741 bozo_process_lua(request))
1754 * can_gzip checks if the request supports and prefers gzip encoding.
1761 can_gzip(bozo_httpreq_t *request)
1767 /* First we decide if the request can be gzipped at all. */
1770 tmp = bozo_content_encoding(request, request->hr_file);
1775 if (request->hr_last_byte_pos != -1 || request->hr_have_range)
1780 for (pos = request->hr_accept_encoding; pos && *pos; pos += len) {
1802 * - check the request is valid
1805 * - return the HTTP request
1808 bozo_process_request(bozo_httpreq_t *request)
1810 bozohttpd_t *httpd = request->hr_httpd;
1820 * then the request has been handled already.
1822 if (transform_request(request, &isindex) == 0)
1827 if (can_gzip(request)) {
1828 bozoasprintf(httpd, &file, "%s.gz", request->hr_file);
1835 file = request->hr_file;
1845 bozo_http_error(httpd, 403, request,
1851 if (!bozo_dir_index(request, file, isindex))
1852 bozo_http_error(httpd, 404, request, "no file");
1855 bozo_http_error(httpd, 500, request, "open file");
1860 bozo_http_error(httpd, 500, request, "can't fstat");
1864 handle_redirect(request, NULL, 0);
1868 if (request->hr_if_modified_since &&
1869 parse_http_date(request->hr_if_modified_since, ×tamp) &&
1873 request->hr_proto);
1880 if (request->hr_last_byte_pos == -1 ||
1881 request->hr_last_byte_pos >= sb.st_size)
1882 request->hr_last_byte_pos = sb.st_size - 1;
1883 if (request->hr_have_range &&
1884 request->hr_first_byte_pos > request->hr_last_byte_pos) {
1885 request->hr_have_range = 0; /* punt */
1886 request->hr_first_byte_pos = 0;
1887 request->hr_last_byte_pos = sb.st_size - 1;
1890 request->hr_have_range,
1891 (long long)request->hr_first_byte_pos,
1892 (long long)request->hr_last_byte_pos));
1893 if (request->hr_have_range)
1895 request->hr_proto);
1897 bozo_printf(httpd, "%s 200 OK\r\n", request->hr_proto);
1899 if (request->hr_proto != httpd->consts.http_09) {
1900 type = bozo_content_type(request, file);
1902 encoding = bozo_content_encoding(request, file);
1904 bozo_print_header(request, &sb, type, encoding);
1909 if (request
1913 request->hr_last_byte_pos - request->hr_first_byte_pos + 1;
1914 cur_byte_pos = request->hr_first_byte_pos;
1940 bozo_ssl_shutdown(request->hr_httpd);
1948 bozo_check_special_files(bozo_httpreq_t *request, const char *name, bool doerror)
1950 bozohttpd_t *httpd = request->hr_httpd;
1957 error = bozo_http_error(httpd, 403, request,
1970 bozo_print_header(bozo_httpreq_t *request,
1973 bozohttpd_t *httpd = request->hr_httpd;
1978 SIMPLEQ_FOREACH(hdr, &request->hr_replheaders, h_next) {
2000 if (request->hr_have_range) {
2001 len = request->hr_last_byte_pos -
2002 request->hr_first_byte_pos +1;
2005 (long long) request->hr_first_byte_pos,
2006 (long long) request->hr_last_byte_pos,
2012 if (request->hr_proto == httpd->consts.http_11)
2168 { 200, "200 OK", "The request was valid", },
2169 { 400, "400 Bad Request", "The request was not valid", },
2173 { 408, "408 Request Timeout", "This request took too long", },
2178 { 501, "501 Not Implemented", "This request is not available", },
2225 bozo_http_error(bozohttpd_t *httpd, int code, bozo_httpreq_t *request,
2231 const char *proto = (request && request->hr_proto) ?
2232 request->hr_proto : httpd->consts.http_11;
2246 if (request && request->hr_serverport &&
2247 strcmp(request->hr_serverport, BOZO_HTTP_PORT) != 0)
2249 request->hr_serverport);
2253 if (request && request->hr_file) {
2256 const char *hostname = BOZOHOST(httpd, request);
2259 file = bozo_escape_html(NULL, request->hr_file);
2261 file = request->hr_file;
2266 if (request->hr_user != NULL) {
2269 user_escaped = bozo_escape_html(NULL, request->hr_user);
2271 user_escaped = request->hr_user;
2274 if (user_escaped != request->hr_user)
2302 if (request) {
2303 bozo_auth_check_401(request, code);
2304 SIMPLEQ_FOREACH(hdr, &request->hr_replheaders, h_next) {
2313 if (request && request->hr_allow)
2314 bozo_printf(httpd, "Allow: %s\r\n", request->hr_allow);
2316 if (code == 408 && request &&
2317 request->hr_proto == httpd->consts.http_11)
2322 if (size && request && request->hr_method != HTTP_HEAD)
2458 * note that these may access members of the httpd and/or request.
2487 bozostrdup(bozohttpd_t *httpd, bozo_httpreq_t *request, const char *str)
2495 if (!request)
2498 bozo_http_error(httpd, 500, request, "memory allocation failure");
2552 if (!bozo_set_pref(httpd, prefs, "request timeout", TOTAL_MAX_REQ_TIME))
2664 if ((cp = bozo_get_pref(prefs, "request timeout")) != NULL) {
Indexes created Tue Oct 14 06:10:07 GMT 2025