Annotation of libwww/Library/src/HTTPReq.c, revision 2.45
2.1 frystyk 1: /* HTTPReq.c
2.23 frystyk 2: ** HTTP REQUEST GENERATION
2.1 frystyk 3: **
2.32 frystyk 4: ** (c) COPYRIGHT MIT 1995.
5: ** Please first read the full copyright statement in the file COPYRIGH.
2.45 ! frystyk 6: ** @(#) $Id: HTTPReq.c,v 2.44 1996/09/13 02:05:35 frystyk Exp $
2.32 frystyk 7: **
2.1 frystyk 8: ** This module implements the output stream for HTTP used for sending
9: ** requests with or without a entity body.
10: **
11: ** History:
12: ** Jan 95 HFN Written from scratch
13: */
14:
15: /* Library Includes */
2.29 frystyk 16: #include "sysdep.h"
2.28 frystyk 17: #include "WWWUtil.h"
2.32 frystyk 18: #include "WWWCore.h"
19:
2.23 frystyk 20: #include "HTTPGen.h"
2.21 frystyk 21: #include "HTTPUtil.h"
2.1 frystyk 22: #include "HTTPReq.h" /* Implements */
23:
2.24 frystyk 24: #define PUTC(c) (*me->target->isa->put_character)(me->target, c)
25: #define PUTS(s) (*me->target->isa->put_string)(me->target, s)
2.1 frystyk 26: #define PUTBLOCK(b, l) (*me->target->isa->put_block)(me->target, b, l)
27:
28: struct _HTStream {
2.29 frystyk 29: const HTStreamClass * isa;
2.1 frystyk 30: HTStream * target;
31: HTRequest * request;
2.18 frystyk 32: SOCKET sockfd;
2.11 frystyk 33: int version;
2.38 frystyk 34: int state;
35: char * url;
2.1 frystyk 36: BOOL transparent;
37: };
38:
39: /* ------------------------------------------------------------------------- */
40: /* HTTP Output Request Stream */
41: /* ------------------------------------------------------------------------- */
42:
2.11 frystyk 43: /* HTTP09Request
44: ** -------------
45: ** Makes a HTTP/0.9 request
2.1 frystyk 46: */
2.38 frystyk 47: PRIVATE int HTTP09Request (HTStream * me, HTRequest * request)
2.11 frystyk 48: {
2.34 frystyk 49: HTParentAnchor * anchor = HTRequest_anchor(request);
50: char * addr = HTAnchor_physical(anchor);
2.38 frystyk 51: if (!me->url) me->url = HTParse(addr, "", PARSE_PATH|PARSE_PUNCTUATION);
52: if (me->state == 0) {
53: PUTS("GET ");
54: me->state++;
55: }
56: if (me->state == 1) {
57: int status = PUTS(me->url);
58: if (status != HT_OK) return status;
59: me->state++;
60: }
2.24 frystyk 61: PUTC(CR);
62: PUTC(LF);
2.38 frystyk 63: return HT_OK;
2.11 frystyk 64: }
65:
66: /* HTTPMakeRequest
67: ** ---------------
68: ** Makes a HTTP/1.0-1.1 request header.
69: */
2.38 frystyk 70: PRIVATE int HTTPMakeRequest (HTStream * me, HTRequest * request)
2.1 frystyk 71: {
2.39 frystyk 72: HTMethod method = HTRequest_method(request);
73: HTRqHd request_mask = HTRequest_rqHd(request);
74: HTParentAnchor * anchor = HTRequest_anchor(request);
2.43 frystyk 75: char * etag = HTAnchor_etag(anchor);
2.24 frystyk 76: char crlf[3];
77: char qstr[10];
78: *crlf = CR; *(crlf+1) = LF; *(crlf+2) = '\0';
2.1 frystyk 79:
2.41 frystyk 80: /* Generate the HTTP/1.x RequestLine */
2.38 frystyk 81: if (me->state == 0) {
2.34 frystyk 82: if (method != METHOD_INVALID) {
83: PUTS(HTMethod_name(method));
84: PUTC(' ');
85: } else
86: PUTS("GET ");
2.38 frystyk 87: me->state++;
2.34 frystyk 88: }
2.1 frystyk 89:
2.39 frystyk 90: /*
2.45 ! frystyk 91: ** Generate the Request URI. If we are using full request URI then it's
! 92: ** easy. Otherwise we must filter out the path part of the URI.
! 93: ** In case it's a OPTIONS request then if there is no pathinfo then use
! 94: ** a * instead. If we use a method different from GET or HEAD then use
! 95: ** the content-location if available.
2.39 frystyk 96: */
2.45 ! frystyk 97: if (me->state == 1) {
! 98: char * abs_location = NULL;
2.38 frystyk 99: char * addr = HTAnchor_physical(anchor);
2.45 ! frystyk 100:
! 101: /*
! 102: ** If we are using a method different from HEAD and GET then use
! 103: ** the Content-Location if available, else the Request-URI.
! 104: */
! 105: if (!HTMethod_isSafe(method)) {
! 106: char * location = HTAnchor_location(anchor);
! 107: if (location) {
! 108: if (HTURL_isAbsolute(location))
! 109: addr = location;
! 110: else {
! 111: /*
! 112: ** We have a content-location but it is relative and
! 113: ** must expand it either to the content-base or to
! 114: ** the Request-URI itself.
! 115: */
! 116: char * base = HTAnchor_base(anchor);
! 117: abs_location = HTParse(location, base, PARSE_ALL);
! 118: addr = abs_location;
! 119: }
! 120: }
! 121: }
! 122:
! 123: /*
! 124: ** If we are using a proxy or newer versions of HTTP then we can
! 125: ** send the full URL. Otherwise we only send the path.
! 126: */
! 127: if (HTRequest_fullURI(request))
! 128: StrAllocCopy(me->url, addr);
! 129: else {
! 130: me->url = HTParse(addr, "", PARSE_PATH | PARSE_PUNCTUATION);
2.39 frystyk 131: if (method == METHOD_OPTIONS) {
132: /*
133: ** We don't preserve the final slash or lack of same through
134: ** out the code. This is mainly for optimization reasons
2.44 frystyk 135: ** but it gives a problem OPTIONS. We can either send a "*"
136: ** or a "/" but not both. For now we send a "*".
2.39 frystyk 137: */
2.45 ! frystyk 138: if (!strcmp(me->url, "/")) *me->url = '*';
2.39 frystyk 139: }
2.1 frystyk 140: }
2.45 ! frystyk 141: HT_FREE(abs_location);
! 142: me->state++;
! 143: }
! 144:
! 145: /*
! 146: ** Now send the URL that we have put together
! 147: */
! 148: if (me->state == 2) {
! 149: int status = HT_OK;
! 150: if ((status = PUTS(me->url)) != HT_OK) return status;
2.38 frystyk 151: me->state++;
2.1 frystyk 152: }
2.25 frystyk 153: PUTC(' ');
2.41 frystyk 154:
155: /*
156: ** Send out the version number. If we know it is a HTTP/1.0 server we
157: ** are talking to then use HTTP/1.0, else use HTTP/1.1 as default version
158: ** number
159: */
160: if (me->version == HTTP_10)
161: PUTS(HTTP_VERSION_10);
162: else
163: PUTS(HTTP_VERSION);
2.24 frystyk 164: PUTBLOCK(crlf, 2);
2.1 frystyk 165:
2.4 frystyk 166: /* Request Headers */
2.34 frystyk 167: if (request_mask & HT_C_ACCEPT_TYPE) {
2.37 frystyk 168: /*
169: ** If caller has specified a specific output format then use this.
170: ** Otherwise use all the registered converters to generate the
171: ** accept header
172: */
173: if (HTRequest_outputFormat(request) == WWW_PRESENT) {
174: int list;
175: HTList *cur;
176: BOOL first=YES;
177: for (list=0; list<2; list++) {
178: if ((!list && ((cur = HTFormat_conversion()) != NULL)) ||
179: (list && ((cur = HTRequest_conversion(request))!=NULL))) {
180: HTPresentation * pres;
181: while ((pres=(HTPresentation *) HTList_nextObject(cur))) {
182: if (pres->rep_out==WWW_PRESENT && pres->quality<=1.0) {
183: if (first) {
184: PUTS("Accept: ");
185: first=NO;
186: } else
187: PUTC(',');
188: PUTS(HTAtom_name(pres->rep));
189: if (pres->quality != 1.0) {
190: sprintf(qstr, ";q=%1.1f", pres->quality);
191: PUTS(qstr);
192: }
2.1 frystyk 193: }
194: }
195: }
196: }
2.37 frystyk 197: if (!first) PUTBLOCK(crlf, 2);
198: } else {
199: PUTS("Accept: ");
200: PUTS(HTAtom_name(HTRequest_outputFormat(request)));
201: PUTBLOCK(crlf, 2);
202: }
2.1 frystyk 203: }
2.34 frystyk 204: if (request_mask & HT_C_ACCEPT_CHAR) {
2.4 frystyk 205: int list;
206: HTList *cur;
2.24 frystyk 207: BOOL first=YES;
2.4 frystyk 208: for (list=0; list<2; list++) {
2.14 frystyk 209: if ((!list && ((cur = HTFormat_charset()) != NULL)) ||
210: (list && ((cur = HTRequest_charset(request)) != NULL))) {
2.4 frystyk 211: HTAcceptNode *pres;
212: while ((pres = (HTAcceptNode *) HTList_nextObject(cur))) {
2.5 frystyk 213: if (first) {
2.24 frystyk 214: PUTS("Accept-Charset: ");
2.5 frystyk 215: first=NO;
2.24 frystyk 216: } else
217: PUTC(',');
218: PUTS(HTAtom_name(pres->atom));
2.4 frystyk 219: }
220: }
221: }
2.31 frystyk 222: if (!first) PUTBLOCK(crlf, 2);
2.4 frystyk 223: }
2.34 frystyk 224: if (request_mask & HT_C_ACCEPT_ENC) {
2.4 frystyk 225: int list;
226: HTList *cur;
2.24 frystyk 227: BOOL first=YES;
2.4 frystyk 228: for (list=0; list<2; list++) {
2.33 frystyk 229: if ((!list && ((cur = HTFormat_contentCoding()) != NULL)) ||
2.14 frystyk 230: (list && ((cur = HTRequest_encoding(request)) != NULL))) {
2.33 frystyk 231: HTCoding * pres;
232: while ((pres = (HTCoding *) HTList_nextObject(cur))) {
2.5 frystyk 233: if (first) {
2.24 frystyk 234: PUTS("Accept-Encoding: ");
2.32 frystyk 235: first = NO;
2.24 frystyk 236: } else
237: PUTC(',');
2.33 frystyk 238: PUTS(HTCoding_name(pres));
2.4 frystyk 239: }
240: }
241: }
2.31 frystyk 242: if (!first) PUTBLOCK(crlf, 2);
2.4 frystyk 243: }
2.34 frystyk 244: if (request_mask & HT_C_ACCEPT_LAN) {
2.4 frystyk 245: int list;
246: HTList *cur;
2.24 frystyk 247: BOOL first=YES;
2.4 frystyk 248: for (list=0; list<2; list++) {
2.14 frystyk 249: if ((!list && ((cur = HTFormat_language()) != NULL)) ||
250: (list && ((cur = HTRequest_language(request)) != NULL))) {
2.4 frystyk 251: HTAcceptNode *pres;
252: while ((pres = (HTAcceptNode *) HTList_nextObject(cur))) {
2.5 frystyk 253: if (first) {
2.24 frystyk 254: PUTS("Accept-Language: ");
2.5 frystyk 255: first=NO;
2.24 frystyk 256: } else
257: PUTC(',');
258: PUTS(HTAtom_name(pres->atom));
259: if (pres->quality != 1.0) {
260: sprintf(qstr, ";q=%1.1f", pres->quality);
261: PUTS(qstr);
2.5 frystyk 262: }
2.4 frystyk 263: }
264: }
265: }
2.31 frystyk 266: if (!first) PUTBLOCK(crlf, 2);
2.4 frystyk 267: }
2.36 frystyk 268: if (request_mask & HT_C_AUTH) {
2.34 frystyk 269: HTAssocList * cur = HTRequest_credentials(request);
270: if (cur) { /* Access authentication */
271: HTAssoc * pres;
272: while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
273: PUTS(HTAssoc_name(pres));
274: PUTS(": ");
275: PUTS(HTAssoc_value(pres));
276: PUTBLOCK(crlf, 2);
277: }
2.28 frystyk 278: }
2.1 frystyk 279: }
2.34 frystyk 280: if (request_mask & HT_C_FROM) {
281: HTUserProfile * up = HTRequest_userProfile(request);
282: const char * mailaddress = HTUserProfile_email(up);
2.1 frystyk 283: if (mailaddress) {
2.24 frystyk 284: PUTS("From: ");
285: PUTS(mailaddress);
286: PUTBLOCK(crlf, 2);
2.1 frystyk 287: }
288: }
2.34 frystyk 289: if (request_mask & HT_C_HOST) {
2.13 frystyk 290: char *orig = HTAnchor_address((HTAnchor *) anchor);
2.12 frystyk 291: char *host = HTParse(orig, "", PARSE_HOST);
2.34 frystyk 292: #if 0
293: /* Keep the port number for HTTP/1.1 compliance */
2.12 frystyk 294: char *ptr = strchr(host, ':'); /* Chop off port number */
295: if (ptr) *ptr = '\0';
2.34 frystyk 296: #endif
2.24 frystyk 297: PUTS("Host: ");
298: PUTS(host);
299: PUTBLOCK(crlf, 2);
2.26 frystyk 300: HT_FREE(orig);
301: HT_FREE(host);
2.39 frystyk 302: }
2.42 frystyk 303:
304: /*
305: ** In the "If-*" series of headers, the ones related to etags have higher
306: ** priority than the date relates ones. That is, if we have a etag then
2.45 ! frystyk 307: ** use that, otherwise use the date. First we check for range, match, and
! 308: ** unmodified-since.
2.42 frystyk 309: */
2.45 ! frystyk 310: if (request_mask & HT_C_IF_RANGE && etag) {
! 311: PUTS("If-Range: \"");
! 312: PUTS(etag);
! 313: PUTC('"');
! 314: PUTBLOCK(crlf, 2);
! 315: if (PROT_TRACE) HTTrace("HTTP........ If-Range using etag `%s\'\n", etag);
! 316: } else if (request_mask & HT_C_IF_MATCH && etag) {
2.43 frystyk 317: PUTS("If-Match: \"");
318: PUTS(etag);
319: PUTC('"');
320: PUTBLOCK(crlf, 2);
321: if (PROT_TRACE) HTTrace("HTTP........ If-Match using etag `%s\'\n", etag);
322: } else if (request_mask & HT_C_IF_UNMOD_SINCE) {
2.42 frystyk 323: time_t lm = HTAnchor_lastModified(anchor);
324: if (lm > 0) {
2.43 frystyk 325: PUTS("If-Unmodified-Since: ");
2.42 frystyk 326: PUTS(HTDateTimeStr(&lm, NO));
327: PUTBLOCK(crlf, 2);
2.43 frystyk 328: if (PROT_TRACE) HTTrace("HTTP........ If-Unmodified-Since\n");
2.42 frystyk 329: }
330: }
2.45 ! frystyk 331:
! 332: /*
! 333: ** If-None-Match and If-Modified-Since are equivalent except that the
! 334: ** first uses etags and the second uses dates. Etags have precedence over
! 335: ** dates.
! 336: */
2.43 frystyk 337: if (request_mask & HT_C_IF_NONE_MATCH && etag) {
338: PUTS("If-None-Match: \"");
339: PUTS(etag);
340: PUTC('"');
341: PUTBLOCK(crlf, 2);
342: if (PROT_TRACE) HTTrace("HTTP........ If-None-Match using etag `%s\'\n", etag);
343: } else if (request_mask & HT_C_IMS) {
2.42 frystyk 344: time_t lm = HTAnchor_lastModified(anchor);
345: if (lm > 0) {
2.43 frystyk 346: PUTS("If-Modified-Since: ");
2.42 frystyk 347: PUTS(HTDateTimeStr(&lm, NO));
348: PUTBLOCK(crlf, 2);
2.43 frystyk 349: if (PROT_TRACE) HTTrace("HTTP........ If-Modified-Since\n");
2.42 frystyk 350: }
351: }
352:
2.45 ! frystyk 353: /*
! 354: ** Max forwards is mainly for TRACE where we want to be able to stop the
! 355: ** TRACE at a specific location un the message path.
! 356: */
2.39 frystyk 357: if (request_mask & HT_C_MAX_FORWARDS) {
358: int hops = HTRequest_maxForwards(request);
359: if (hops >= 0) {
360: sprintf(qstr, "%d", hops);
361: PUTS("Max-Forwards: ");
362: PUTS(qstr);
363: PUTBLOCK(crlf, 2);
364: }
2.42 frystyk 365: }
2.45 ! frystyk 366:
! 367: /*
! 368: ** Range requests. For now, we only take the first entry registered for
! 369: ** this request. This means that you can only send a single "unit" and
! 370: ** then a set of range within this unit. This is in accordance with
! 371: ** HTTP/1.1. Multiple units will go on multiple lines.
! 372: */
2.42 frystyk 373: if (request_mask & HT_C_RANGE) {
2.45 ! frystyk 374: HTAssocList * cur = HTRequest_range(request);
! 375: if (cur) { /* Range requests */
! 376: HTAssoc * pres;
! 377: while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
! 378: PUTS("Range: ");
! 379: PUTS(HTAssoc_name(pres)); /* Unit */
! 380: PUTS("=");
! 381: PUTS(HTAssoc_value(pres)); /* Ranges within this unit */
! 382: PUTBLOCK(crlf, 2);
! 383: }
! 384: }
2.1 frystyk 385: }
2.34 frystyk 386: if (request_mask & HT_C_REFERER) {
387: HTParentAnchor * parent_anchor = HTRequest_parent(request);
388: if (parent_anchor) {
389: char * act = HTAnchor_address((HTAnchor *) anchor);
390: char * parent = HTAnchor_address((HTAnchor *) parent_anchor);
391: char * relative = HTParse(parent, act,
392: PARSE_ACCESS|PARSE_HOST|PARSE_PATH|PARSE_PUNCTUATION);
393: if (relative && *relative) {
394: PUTS("Referer: ");
395: PUTS(parent);
396: PUTBLOCK(crlf, 2);
397: }
398: HT_FREE(act);
399: HT_FREE(parent);
400: HT_FREE(relative);
2.1 frystyk 401: }
402: }
2.34 frystyk 403: if (request_mask & HT_C_USER_AGENT) {
2.24 frystyk 404: PUTS("User-Agent: ");
405: PUTS(HTLib_appName());
406: PUTC('/');
407: PUTS(HTLib_appVersion());
408: PUTC(' ');
409: PUTS(HTLib_name());
410: PUTC('/');
411: PUTS(HTLib_version());
412: PUTBLOCK(crlf, 2);
2.1 frystyk 413: }
2.27 eric 414: if (PROT_TRACE)HTTrace("HTTP........ Generating Request Headers\n");
2.38 frystyk 415: return HT_OK;
2.1 frystyk 416: }
417:
2.29 frystyk 418: PRIVATE int HTTPRequest_put_block (HTStream * me, const char * b, int l)
2.1 frystyk 419: {
2.7 frystyk 420: if (!me->target) {
2.1 frystyk 421: return HT_WOULD_BLOCK;
2.7 frystyk 422: } else if (me->transparent)
2.11 frystyk 423: return b ? PUTBLOCK(b, l) : HT_OK;
2.1 frystyk 424: else {
2.38 frystyk 425: int status = HT_OK;
426: if (me->version == HTTP_09) {
427: status = HTTP09Request(me, me->request);
428: if (status != HT_OK) return status;
429: } else {
430: status = HTTPMakeRequest(me, me->request);
431: if (status != HT_OK) return status;
2.1 frystyk 432: me->transparent = YES;
2.11 frystyk 433: return b ? PUTBLOCK(b, l) : HT_OK;
2.1 frystyk 434: }
435: return status;
436: }
437: }
438:
2.16 frystyk 439: PRIVATE int HTTPRequest_put_character (HTStream * me, char c)
2.1 frystyk 440: {
2.11 frystyk 441: return HTTPRequest_put_block(me, &c, 1);
2.1 frystyk 442: }
443:
2.29 frystyk 444: PRIVATE int HTTPRequest_put_string (HTStream * me, const char * s)
2.1 frystyk 445: {
2.11 frystyk 446: return HTTPRequest_put_block(me, s, strlen(s));
2.1 frystyk 447: }
448:
449: /*
450: ** Flushes data but doesn't free stream object
451: */
2.16 frystyk 452: PRIVATE int HTTPRequest_flush (HTStream * me)
2.1 frystyk 453: {
2.13 frystyk 454: int status = HTTPRequest_put_block(me, NULL, 0);
455: return status==HT_OK ? (*me->target->isa->flush)(me->target) : status;
2.1 frystyk 456: }
457:
458: /*
459: ** Flushes data and frees stream object
460: */
2.16 frystyk 461: PRIVATE int HTTPRequest_free (HTStream * me)
2.1 frystyk 462: {
2.11 frystyk 463: int status = HTTPRequest_flush(me);
464: if (status != HT_WOULD_BLOCK) {
465: if ((status = (*me->target->isa->_free)(me->target)) == HT_WOULD_BLOCK)
466: return HT_WOULD_BLOCK;
2.38 frystyk 467: HT_FREE(me->url);
2.26 frystyk 468: HT_FREE(me);
2.1 frystyk 469: }
2.7 frystyk 470: return status;
2.1 frystyk 471: }
472:
2.16 frystyk 473: PRIVATE int HTTPRequest_abort (HTStream * me, HTList * e)
2.1 frystyk 474: {
2.13 frystyk 475: if (me->target) (*me->target->isa->abort)(me->target, e);
2.38 frystyk 476: HT_FREE(me->url);
2.26 frystyk 477: HT_FREE(me);
2.27 eric 478: if (PROT_TRACE) HTTrace("HTTPRequest. ABORTING...\n");
2.1 frystyk 479: return HT_ERROR;
480: }
481:
482: /* HTTPRequest Stream
483: ** -----------------
484: */
2.29 frystyk 485: PRIVATE const HTStreamClass HTTPRequestClass =
2.1 frystyk 486: {
487: "HTTPRequest",
488: HTTPRequest_flush,
489: HTTPRequest_free,
490: HTTPRequest_abort,
491: HTTPRequest_put_character,
492: HTTPRequest_put_string,
493: HTTPRequest_put_block
494: };
495:
2.23 frystyk 496: PUBLIC HTStream * HTTPRequest_new (HTRequest * request, HTStream * target,
2.45 ! frystyk 497: BOOL endHeader, int version)
2.1 frystyk 498: {
2.26 frystyk 499: HTStream * me;
500: if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL)
501: HT_OUTOFMEM("HTTPRequest_new");
2.1 frystyk 502: me->isa = &HTTPRequestClass;
503: me->target = target;
504: me->request = request;
2.45 ! frystyk 505: me->version = version;
2.1 frystyk 506: me->transparent = NO;
2.23 frystyk 507:
508: /* Return general HTTP header stream */
2.45 ! frystyk 509: return HTTPGen_new(request, me, endHeader, version);
2.1 frystyk 510: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTTPReq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src