Annotation of embedaddon/libpdel/http/http_response.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/types.h>
! 42: #include <sys/param.h>
! 43: #include <sys/queue.h>
! 44:
! 45: #include <netinet/in.h>
! 46:
! 47: #include <stdio.h>
! 48: #include <stdlib.h>
! 49: #include <stdarg.h>
! 50: #include <string.h>
! 51: #include <pthread.h>
! 52: #include <limits.h>
! 53: #include <ctype.h>
! 54: #include <syslog.h>
! 55: #include <errno.h>
! 56: #include <assert.h>
! 57:
! 58: #include <openssl/ssl.h>
! 59:
! 60: #include "structs/structs.h"
! 61: #include "structs/type/array.h"
! 62:
! 63: #include "http/http_defs.h"
! 64: #include "http/http_server.h"
! 65: #include "http/http_internal.h"
! 66: #include "util/typed_mem.h"
! 67:
! 68: struct suffix_map {
! 69: const char *suffix;
! 70: const char *mime;
! 71: };
! 72:
! 73: /* error responses */
! 74: #define MALFORMED_RESPONSE_MSG "Malformed response"
! 75: #define TIMEOUT_RESPONSE_MSG "Server timed out"
! 76:
! 77: /*
! 78: * Internal functions
! 79: */
! 80: static int suffix_cmp(const void *v1, const void *v2);
! 81:
! 82: /* Filename suffix -> MIME encoding (list is sorted case insensitively) */
! 83: static const struct suffix_map mime_encodings[] = {
! 84: { "gz", "gzip" },
! 85: { "uu", "x-uuencode" },
! 86: { "Z", "compress" },
! 87: };
! 88: static const int num_mime_encodings
! 89: = sizeof(mime_encodings) / sizeof(*mime_encodings);
! 90:
! 91: /* Filename suffix -> MIME type (list is sorted case insensitively) */
! 92: static const struct suffix_map mime_types[] = {
! 93: { "a", "application/octet-stream" },
! 94: { "aab", "application/x-authorware-bin" },
! 95: { "aam", "application/x-authorware-map" },
! 96: { "aas", "application/x-authorware-seg" },
! 97: { "ai", "application/postscript" },
! 98: { "aif", "audio/x-aiff" },
! 99: { "aifc", "audio/x-aiff" },
! 100: { "aiff", "audio/x-aiff" },
! 101: { "au", "audio/basic" },
! 102: { "avi", "video/x-msvideo" },
! 103: { "bcpio", "application/x-bcpio" },
! 104: { "bin", "application/octet-stream" },
! 105: { "cdf", "application/x-netcdf" },
! 106: { "class", "application/java" },
! 107: { "cpio", "application/x-cpio" },
! 108: { "css", "text/css" },
! 109: { "dcr", "application/x-director" },
! 110: { "dir", "application/x-director" },
! 111: { "doc", "application/msword" },
! 112: { "dtd", "text/xml" },
! 113: { "dump", "application/octet-stream" },
! 114: { "dvi", "application/x-dvi" },
! 115: { "dxr", "application/x-director" },
! 116: { "eps", "application/postscript" },
! 117: { "etx", "text/x-setext" },
! 118: { "exe", "application/octet-stream" },
! 119: { "fgd", "application/x-director" },
! 120: { "fh", "image/x-freehand" },
! 121: { "fh4", "image/x-freehand" },
! 122: { "fh5", "image/x-freehand" },
! 123: { "fh7", "image/x-freehand" },
! 124: { "fhc", "image/x-freehand" },
! 125: { "gif", "image/gif" },
! 126: { "gtar", "application/x-gtar" },
! 127: { "hdf", "application/x-hdf" },
! 128: { "hqx", "application/mac-binhex40" },
! 129: { "htm", "text/html" },
! 130: { "html", "text/html" },
! 131: { "ief", "image/ief" },
! 132: { "iv", "application/x-inventor" },
! 133: { "jfif", "image/jpeg" },
! 134: { "jpe", "image/jpeg" },
! 135: { "jpeg", "image/jpeg" },
! 136: { "jpg", "image/jpeg" },
! 137: { "js", "application/x-javascript" },
! 138: { "kar", "audio/midi" },
! 139: { "latex", "application/x-latex" },
! 140: { "man", "application/x-troff-man" },
! 141: { "man", "application/x-troff-man" },
! 142: { "me", "application/x-troff-me" },
! 143: { "me", "application/x-troff-me" },
! 144: { "mid", "audio/midi" },
! 145: { "midi", "audio/midi" },
! 146: { "mif", "application/x-mif" },
! 147: { "mime", "message/rfc822" },
! 148: { "mmf", "application/x-www-urlformencoded" },
! 149: { "mov", "video/quicktime" },
! 150: { "movie", "video/x-sgi-movie" },
! 151: { "mp2", "audio/mpeg" },
! 152: { "mp3", "audio/mpeg" },
! 153: { "mpe", "video/mpeg" },
! 154: { "mpeg", "video/mpeg" },
! 155: { "mpg", "video/mpeg" },
! 156: { "mpga", "audio/mpeg" },
! 157: { "ms", "application/x-troff-ms" },
! 158: { "ms", "application/x-troff-ms" },
! 159: { "mv", "video/x-sgi-movie" },
! 160: { "nc", "application/x-netcdf" },
! 161: { "o", "application/octet-stream" },
! 162: { "oda", "application/oda" },
! 163: { "pac", "application/x-ns-proxy-autoconfig" },
! 164: { "pbm", "image/x-portable-bitmap" },
! 165: { "pdf", "application/pdf" },
! 166: { "pgm", "image/x-portable-graymap" },
! 167: { "png", "image/png" },
! 168: { "pnm", "image/x-portable-anymap" },
! 169: { "ppm", "image/x-portable-pixmap" },
! 170: { "ppt", "application/powerpoint" },
! 171: { "ps", "application/postscript" },
! 172: { "qt", "video/quicktime" },
! 173: { "ra", "audio/x-pn-realaudio" },
! 174: { "ram", "audio/x-pn-realaudio" },
! 175: { "rm", "audio/x-pn-realaudio" },
! 176: { "roff", "application/x-troff" },
! 177: { "rpm", "audio/x-pn-realaudio-plugin" },
! 178: { "rtf", "application/rtf" },
! 179: { "rtx", "text/richtext" },
! 180: { "sh", "application/x-shar" },
! 181: { "shar", "application/x-shar" },
! 182: { "sit", "application/x-stuffit" },
! 183: { "snd", "audio/basic" },
! 184: { "spl", "application/futuresplash" },
! 185: { "sv4cpio", "application/x-sv4cpio" },
! 186: { "sv4crc", "application/x-sv4crc" },
! 187: { "swf", "application/x-shockwave-flash" },
! 188: { "tar", "application/x-tar" },
! 189: { "tex", "application/x-tex" },
! 190: { "texi", "application/x-texinfo" },
! 191: { "texinfo", "application/x-texinfo" },
! 192: { "tif", "image/tiff" },
! 193: { "tiff", "image/tiff" },
! 194: { "tmpl", "text/plain" }, /* template file input */
! 195: { "tr", "application/x-troff" },
! 196: { "tsp", "application/dsptype" },
! 197: { "tsv", "text/tab-separated-values" },
! 198: { "txt", "text/plain" },
! 199: { "ustar", "application/x-ustar" },
! 200: { "vrml", "model/vrml" },
! 201: { "vx", "video/x-rad-screenplay" },
! 202: { "wav", "audio/wav" },
! 203: { "wbmp", "image/vnd.wap.wbmp" },
! 204: { "wml", "text/vnd.wap.wml" },
! 205: { "wmlc", "application/vnd.wap.wmlc" },
! 206: { "wmls", "text/vnd.wap.wmlscript" },
! 207: { "wmlsc", "application/vnd.wap.wmlscriptc" },
! 208: { "wrl", "model/vrml" },
! 209: { "wsrc", "application/x-wais-source" },
! 210: { "xbm", "image/x-xbitmap" },
! 211: { "xml", "text/xml" },
! 212: { "xpm", "image/x-xpixmap" },
! 213: { "xwd", "image/x-xwindowdump" },
! 214: { "zip", "application/x-zip-compressed" },
! 215: };
! 216: static const int num_mime_types = sizeof(mime_types) / sizeof(*mime_types);
! 217:
! 218: /*********************************************************************
! 219: MAIN ROUTINES
! 220: *********************************************************************/
! 221:
! 222: /*
! 223: * Create a new response structure.
! 224: */
! 225: int
! 226: _http_response_new(struct http_connection *conn)
! 227: {
! 228: struct http_response *resp;
! 229:
! 230: /* Create response structure */
! 231: assert(conn->resp == NULL);
! 232: if ((resp = MALLOC("http_response", sizeof(*resp))) == NULL) {
! 233: (*conn->logger)(LOG_ERR, "%s: %s", "malloc", strerror(errno));
! 234: return (-1);
! 235: }
! 236: memset(resp, 0, sizeof(*resp));
! 237:
! 238: /* Attach message structure */
! 239: if ((resp->msg = _http_message_new()) == NULL) {
! 240: (*conn->logger)(LOG_ERR, "%s: %s", "malloc", strerror(errno));
! 241: FREE("http_response", resp);
! 242: return (-1);
! 243: }
! 244:
! 245: /* Link it up */
! 246: resp->msg->conn = conn;
! 247: conn->resp = resp;
! 248: return (0);
! 249: }
! 250:
! 251: /*
! 252: * Read in, validate, and prep an HTTP response from a connection.
! 253: *
! 254: * In all cases, fill in the error message buffer.
! 255: */
! 256: int
! 257: _http_response_read(struct http_connection *conn, char *errbuf, int size)
! 258: {
! 259: struct http_response *const resp = conn->resp;
! 260: const char *hval;
! 261:
! 262: /* Load in message from HTTP connection */
! 263: if (_http_message_read(resp->msg, 0) == -1) {
! 264: switch (errno) {
! 265: case EINVAL:
! 266: strlcpy(errbuf, MALFORMED_RESPONSE_MSG, size);
! 267: break;
! 268:
! 269: case ETIMEDOUT:
! 270: strlcpy(errbuf, TIMEOUT_RESPONSE_MSG, size);
! 271: break;
! 272:
! 273: default:
! 274: strlcpy(errbuf, strerror(errno), size);
! 275: break;
! 276: }
! 277:
! 278: /* fix errno now that we've used it */
! 279: conn->keep_alive = 0;
! 280: errno = EINVAL;
! 281: return (-1);
! 282: }
! 283:
! 284: /* Set code */
! 285: hval = http_response_get_header(resp, HDR_REPLY_STATUS);
! 286: if (sscanf(hval, "%u", &resp->code) != 1) {
! 287: snprintf(errbuf, size, "Invalid response code ``%s''", hval);
! 288: conn->keep_alive = 0;
! 289: errno = EINVAL;
! 290: return (-1);
! 291: }
! 292:
! 293: /* Expect no body from certain responses */
! 294: if (http_response_no_body(resp->code)) {
! 295: resp->msg->input_len = 0;
! 296: resp->msg->no_body = 1;
! 297: } else if (resp->msg->input_len == UINT_MAX
! 298: && _http_head_want_keepalive(resp->msg->head)) {
! 299: snprintf(errbuf, size,
! 300: "Keep-Alive requres %s", HTTP_HEADER_CONTENT_LENGTH);
! 301: conn->keep_alive = 0;
! 302: errno = EINVAL;
! 303: return (-1);
! 304: }
! 305:
! 306: /* Turn off keep alive if not specified by remote side */
! 307: if (!_http_head_want_keepalive(resp->msg->head))
! 308: conn->keep_alive = 0;
! 309:
! 310: /* Done */
! 311: strlcpy(errbuf, http_response_get_header(resp, HDR_REPLY_REASON), size);
! 312: return (0);
! 313: }
! 314:
! 315: /*
! 316: * Free a response
! 317: */
! 318: void
! 319: _http_response_free(struct http_response **respp)
! 320: {
! 321: struct http_response *const resp = *respp;
! 322:
! 323: if (resp == NULL)
! 324: return;
! 325: _http_message_free(&resp->msg);
! 326: FREE("http_response", resp);
! 327: *respp = NULL;
! 328: }
! 329:
! 330: /*
! 331: * Get response code.
! 332: */
! 333: int
! 334: http_response_get_code(struct http_response *resp)
! 335: {
! 336: return (resp->code);
! 337: }
! 338:
! 339: /*********************************************************************
! 340: MESSAGE WRAPPERS
! 341: *********************************************************************/
! 342:
! 343: /*
! 344: * Set a response header.
! 345: */
! 346: int
! 347: http_response_set_header(struct http_response *resp, int append,
! 348: const char *name, const char *valfmt, ...)
! 349: {
! 350: va_list args;
! 351: int ret;
! 352:
! 353: /* Set header */
! 354: va_start(args, valfmt);
! 355: ret = _http_message_vset_header(resp->msg, append, name, valfmt, args);
! 356: va_end(args);
! 357: if (ret == -1)
! 358: return (-1);
! 359:
! 360: /* Remember response code */
! 361: if (name == HDR_REPLY_STATUS) {
! 362: resp->code = atoi(http_response_get_header(resp, name));
! 363: resp->msg->no_body = http_response_no_body(resp->code);
! 364: }
! 365:
! 366: /* Done */
! 367: return (0);
! 368: }
! 369:
! 370: /*
! 371: * Get a response header.
! 372: *
! 373: * For headers listed multiple times, this only gets the first instance.
! 374: */
! 375: const char *
! 376: http_response_get_header(struct http_response *resp, const char *name)
! 377: {
! 378: return (_http_head_get(resp->msg->head, name));
! 379: }
! 380:
! 381: /*
! 382: * Get the number of headers
! 383: */
! 384: int
! 385: http_response_num_headers(struct http_response *resp)
! 386: {
! 387: return (_http_head_num_headers(resp->msg->head));
! 388: }
! 389:
! 390: /*
! 391: * Get header by index.
! 392: */
! 393: int
! 394: http_response_get_header_by_index(struct http_response *resp,
! 395: u_int index, const char **namep, const char **valuep)
! 396: {
! 397: return (_http_head_get_by_index(resp->msg->head, index, namep, valuep));
! 398: }
! 399:
! 400: /*
! 401: * Remove a header.
! 402: */
! 403: int
! 404: http_response_remove_header(struct http_response *resp, const char *name)
! 405: {
! 406: return (_http_message_remove_header(resp->msg, name));
! 407: }
! 408:
! 409: /*
! 410: * Send response headers, if not sent already.
! 411: */
! 412: int
! 413: http_response_send_headers(struct http_response *resp, int unbuffer)
! 414: {
! 415: _http_message_send_headers(resp->msg, unbuffer);
! 416: return (0);
! 417: }
! 418:
! 419: /*
! 420: * Get response input stream.
! 421: */
! 422: FILE *
! 423: http_response_get_input(struct http_response *resp)
! 424: {
! 425: if (resp->msg->conn->server) {
! 426: errno = EINVAL;
! 427: return (NULL);
! 428: }
! 429: return (resp->msg->input);
! 430: }
! 431:
! 432: /*
! 433: * Get response output stream.
! 434: */
! 435: FILE *
! 436: http_response_get_output(struct http_response *resp, int buffer)
! 437: {
! 438: if (!resp->msg->conn->server) {
! 439: errno = EINVAL;
! 440: return (NULL);
! 441: }
! 442: return (_http_message_get_output(resp->msg, buffer));
! 443: }
! 444:
! 445: /*
! 446: * Get raw i/o stream as a file descriptor.
! 447: */
! 448: int
! 449: http_response_get_raw_socket(struct http_response *resp)
! 450: {
! 451: return (_http_message_get_raw_socket(resp->msg));
! 452: }
! 453:
! 454: /*
! 455: * Get remote IP address.
! 456: */
! 457: struct in_addr
! 458: http_response_get_remote_ip(struct http_response *resp)
! 459: {
! 460: return (_http_message_get_remote_ip(resp->msg));
! 461: }
! 462:
! 463: /*
! 464: * Get remote port.
! 465: */
! 466: u_int16_t
! 467: http_response_get_remote_port(struct http_response *resp)
! 468: {
! 469: return (_http_message_get_remote_port(resp->msg));
! 470: }
! 471:
! 472: /*
! 473: * Get SSL context.
! 474: */
! 475: SSL_CTX *
! 476: http_response_get_ssl(struct http_response *resp)
! 477: {
! 478: return (resp->msg->conn->ssl);
! 479: }
! 480:
! 481: /*********************************************************************
! 482: SERVLET HELPERS
! 483: *********************************************************************/
! 484:
! 485: /*
! 486: * Send an HTTP redirect.
! 487: */
! 488: void
! 489: http_response_send_redirect(struct http_response *resp, const char *url)
! 490: {
! 491: const char *name;
! 492: const char *value;
! 493:
! 494: while (_http_head_get_by_index(resp->msg->head, 0, &name, &value) == 0)
! 495: _http_head_remove(resp->msg->head, name);
! 496: http_response_set_header(resp, 0, HDR_REPLY_STATUS,
! 497: "%d", HTTP_STATUS_MOVED_PERMANENTLY);
! 498: http_response_set_header(resp, 0, HDR_REPLY_REASON,
! 499: "%s", http_response_status_msg(HTTP_STATUS_MOVED_PERMANENTLY));
! 500: http_response_set_header(resp, 0, "Location", "%s", url);
! 501: }
! 502:
! 503: /*
! 504: * Send an HTTP authorization failed response.
! 505: */
! 506: void
! 507: http_response_send_basic_auth(struct http_response *resp, const char *realm)
! 508: {
! 509: http_response_set_header(resp, 0, HTTP_HEADER_WWW_AUTHENTICATE,
! 510: "Basic realm=\"%s\"", realm);
! 511: _http_head_remove(resp->msg->head, HTTP_HEADER_LAST_MODIFIED);
! 512: http_response_send_error(resp, HTTP_STATUS_UNAUTHORIZED, NULL);
! 513: }
! 514:
! 515: /*
! 516: * Convert 'errno' into an HTTP error response.
! 517: */
! 518: void
! 519: http_response_send_errno_error(struct http_response *resp)
! 520: {
! 521: int code;
! 522:
! 523: switch (errno) {
! 524: case ENOENT:
! 525: case ENOTDIR:
! 526: code = HTTP_STATUS_NOT_FOUND;
! 527: break;
! 528: case EPERM:
! 529: case EACCES:
! 530: code = HTTP_STATUS_FORBIDDEN;
! 531: break;
! 532: default:
! 533: code = HTTP_STATUS_INTERNAL_SERVER_ERROR;
! 534: break;
! 535: }
! 536: http_response_send_error(resp, code, "%s", strerror(errno));
! 537: }
! 538:
! 539: /*
! 540: * Send back a simple error page
! 541: */
! 542: void
! 543: http_response_send_error(struct http_response *resp,
! 544: int code, const char *fmt, ...)
! 545: {
! 546: struct http_request *const req = resp->msg->conn->req;
! 547: const char *ua;
! 548: FILE *fp;
! 549: int i;
! 550:
! 551: /* Check headers already sent */
! 552: if (resp->msg->hdrs_sent)
! 553: return;
! 554:
! 555: /* Set response line info */
! 556: http_response_set_header(resp, 0, HDR_REPLY_STATUS, "%d", code);
! 557: http_response_set_header(resp, 0, HDR_REPLY_REASON,
! 558: "%s", http_response_status_msg(code));
! 559:
! 560: /* Set additional headers */
! 561: http_response_set_header(resp, 0, HTTP_HEADER_CONTENT_TYPE,
! 562: "text/html; charset=iso-8859-1");
! 563:
! 564: /* Close connection for real errors */
! 565: if (code >= 400) {
! 566: http_response_set_header(resp,
! 567: 0, _http_message_connection_header(resp->msg), "close");
! 568: }
! 569:
! 570: /* Send error page body */
! 571: if ((fp = http_response_get_output(resp, 1)) == NULL)
! 572: return;
! 573: fprintf(fp, "<HTML>\n<HEAD>\n<TITLE>%d %s</TITLE></HEAD>\n",
! 574: code, http_response_status_msg(code));
! 575: fprintf(fp, "<BODY BGCOLOR=\"#FFFFFF\">\n<H3>%d %s</H3>\n",
! 576: code, http_response_status_msg(code));
! 577: if (fmt != NULL) {
! 578: va_list args;
! 579:
! 580: fprintf(fp, "<B>");
! 581: va_start(args, fmt);
! 582: vfprintf(fp, fmt, args);
! 583: va_end(args);
! 584: fprintf(fp, "</B>\n");
! 585: }
! 586: #if 0
! 587: fprintf(fp, "<P></P>\n<HR>\n");
! 588: fprintf(fp, "<FONT SIZE=\"-1\"><EM>%s</EM></FONT>\n",
! 589: serv->server_name);
! 590: #endif
! 591:
! 592: /* Add fillter for IE */
! 593: if ((ua = http_request_get_header(req, HTTP_HEADER_USER_AGENT)) != NULL
! 594: && strstr(ua, "IE") != NULL) {
! 595: for (i = 0; i < 20; i++) {
! 596: fprintf(fp, "<!-- FILLER TO MAKE INTERNET EXPLORER SHOW"
! 597: " THIS PAGE INSTEAD OF ITS OWN PAGE -->\n");
! 598: }
! 599: }
! 600: fprintf(fp, "</BODY>\n</HTML>\n");
! 601: }
! 602:
! 603: /*
! 604: * Try to guess MIME type and encoding from filename suffix.
! 605: */
! 606: void
! 607: http_response_guess_mime(const char *path,
! 608: const char **ctype, const char **cencs, int maxencs)
! 609: {
! 610: static char buf[MAXPATHLEN];
! 611: struct suffix_map *mime;
! 612: int matched_ctype = -1;
! 613: struct suffix_map key;
! 614: const char *slash;
! 615: char *tokctx;
! 616: char *s;
! 617: int i;
! 618:
! 619: /* Set defaults */
! 620: *ctype = "text/plain; charset=iso-8859-1";
! 621: memset(cencs, 0, maxencs * sizeof(*cencs));
! 622:
! 623: /* Strip directories */
! 624: if ((slash = strrchr(path, '/')) != NULL)
! 625: path = slash + 1;
! 626: strlcpy(buf, path, sizeof(buf));
! 627:
! 628: /* Search for suffixes matching MIME types table entry */
! 629: for (i = 0, s = strtok_r(buf, ".", &tokctx);
! 630: s != NULL; i++, s = strtok_r(NULL, ".", &tokctx)) {
! 631: key.suffix = s;
! 632: if ((mime = bsearch(&key, mime_types, num_mime_types,
! 633: sizeof(*mime_types), suffix_cmp)) != NULL) {
! 634: *ctype = mime->mime;
! 635: matched_ctype = i;
! 636: }
! 637: }
! 638: if (matched_ctype == -1)
! 639: return;
! 640:
! 641: /* Skip to the suffix after the last MIME type suffix */
! 642: for (i = 0, s = strtok_r(buf, ".", &tokctx);
! 643: i <= matched_ctype; i++, s = strtok_r(NULL, ".", &tokctx));
! 644:
! 645: /* Get encoding(s) */
! 646: for (i = 0; i < maxencs - 1
! 647: && (s = strtok_r(NULL, ".", &tokctx)) != NULL; i++) {
! 648: key.suffix = s;
! 649: if ((mime = bsearch(&key, mime_encodings, num_mime_encodings,
! 650: sizeof(*mime_encodings), suffix_cmp)) == NULL)
! 651: break;
! 652: cencs[i] = mime->mime;
! 653: }
! 654: }
! 655:
! 656: /*
! 657: * Compare two entries in MIME type/encoding array
! 658: */
! 659: static int
! 660: suffix_cmp(const void *v1, const void *v2)
! 661: {
! 662: const struct suffix_map *const map1 = v1;
! 663: const struct suffix_map *const map2 = v2;
! 664:
! 665: return (strcasecmp(map1->suffix, map2->suffix));
! 666: }
! 667:
! 668: /*********************************************************************
! 669: MISC ROUTINES
! 670: *********************************************************************/
! 671:
! 672: /*
! 673: * Certain response codes are required to not have any body.
! 674: */
! 675: int
! 676: http_response_no_body(int code)
! 677: {
! 678: switch (code) {
! 679: case HTTP_STATUS_NO_CONTENT:
! 680: case HTTP_STATUS_NOT_MODIFIED:
! 681: return (1);
! 682: }
! 683: return (0);
! 684: }
! 685:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_response.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / http