Annotation of libwww/Library/src/HTTPReq.c, revision 2.44
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.44 ! frystyk 6: ** @(#) $Id: HTTPReq.c,v 2.43 1996/09/08 22:08:49 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: /*
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.
95: */
96: if (me->state == 1) {
2.38 frystyk 97: char * addr = HTAnchor_physical(anchor);
2.39 frystyk 98: int status = HT_OK;
2.35 frystyk 99: if (HTRequest_fullURI(request)) {
2.40 frystyk 100: status = PUTS(addr);
2.1 frystyk 101: } else {
2.39 frystyk 102: if (method == METHOD_OPTIONS) {
103: /*
104: ** We don't preserve the final slash or lack of same through
105: ** out the code. This is mainly for optimization reasons
2.44 ! frystyk 106: ** but it gives a problem OPTIONS. We can either send a "*"
! 107: ** or a "/" but not both. For now we send a "*".
2.39 frystyk 108: */
2.44 ! frystyk 109: if (!me->url) {
! 110: me->url = HTParse(addr, "", PARSE_PATH|PARSE_PUNCTUATION);
! 111: if (!strcmp(me->url, "/")) *me->url = '*';
! 112: }
2.39 frystyk 113: status = PUTS(me->url);
114: } else {
115: if (!me->url)
116: me->url = HTParse(addr, "", PARSE_PATH|PARSE_PUNCTUATION);
117: status = PUTS(me->url);
118: }
2.1 frystyk 119: }
2.38 frystyk 120: if (status != HT_OK) return status;
121: me->state++;
2.1 frystyk 122: }
2.25 frystyk 123: PUTC(' ');
2.41 frystyk 124:
125: /*
126: ** Send out the version number. If we know it is a HTTP/1.0 server we
127: ** are talking to then use HTTP/1.0, else use HTTP/1.1 as default version
128: ** number
129: */
130: if (me->version == HTTP_10)
131: PUTS(HTTP_VERSION_10);
132: else
133: PUTS(HTTP_VERSION);
2.24 frystyk 134: PUTBLOCK(crlf, 2);
2.1 frystyk 135:
2.4 frystyk 136: /* Request Headers */
2.34 frystyk 137: if (request_mask & HT_C_ACCEPT_TYPE) {
2.37 frystyk 138: /*
139: ** If caller has specified a specific output format then use this.
140: ** Otherwise use all the registered converters to generate the
141: ** accept header
142: */
143: if (HTRequest_outputFormat(request) == WWW_PRESENT) {
144: int list;
145: HTList *cur;
146: BOOL first=YES;
147: for (list=0; list<2; list++) {
148: if ((!list && ((cur = HTFormat_conversion()) != NULL)) ||
149: (list && ((cur = HTRequest_conversion(request))!=NULL))) {
150: HTPresentation * pres;
151: while ((pres=(HTPresentation *) HTList_nextObject(cur))) {
152: if (pres->rep_out==WWW_PRESENT && pres->quality<=1.0) {
153: if (first) {
154: PUTS("Accept: ");
155: first=NO;
156: } else
157: PUTC(',');
158: PUTS(HTAtom_name(pres->rep));
159: if (pres->quality != 1.0) {
160: sprintf(qstr, ";q=%1.1f", pres->quality);
161: PUTS(qstr);
162: }
2.1 frystyk 163: }
164: }
165: }
166: }
2.37 frystyk 167: if (!first) PUTBLOCK(crlf, 2);
168: } else {
169: PUTS("Accept: ");
170: PUTS(HTAtom_name(HTRequest_outputFormat(request)));
171: PUTBLOCK(crlf, 2);
172: }
2.1 frystyk 173: }
2.34 frystyk 174: if (request_mask & HT_C_ACCEPT_CHAR) {
2.4 frystyk 175: int list;
176: HTList *cur;
2.24 frystyk 177: BOOL first=YES;
2.4 frystyk 178: for (list=0; list<2; list++) {
2.14 frystyk 179: if ((!list && ((cur = HTFormat_charset()) != NULL)) ||
180: (list && ((cur = HTRequest_charset(request)) != NULL))) {
2.4 frystyk 181: HTAcceptNode *pres;
182: while ((pres = (HTAcceptNode *) HTList_nextObject(cur))) {
2.5 frystyk 183: if (first) {
2.24 frystyk 184: PUTS("Accept-Charset: ");
2.5 frystyk 185: first=NO;
2.24 frystyk 186: } else
187: PUTC(',');
188: PUTS(HTAtom_name(pres->atom));
2.4 frystyk 189: }
190: }
191: }
2.31 frystyk 192: if (!first) PUTBLOCK(crlf, 2);
2.4 frystyk 193: }
2.34 frystyk 194: if (request_mask & HT_C_ACCEPT_ENC) {
2.4 frystyk 195: int list;
196: HTList *cur;
2.24 frystyk 197: BOOL first=YES;
2.4 frystyk 198: for (list=0; list<2; list++) {
2.33 frystyk 199: if ((!list && ((cur = HTFormat_contentCoding()) != NULL)) ||
2.14 frystyk 200: (list && ((cur = HTRequest_encoding(request)) != NULL))) {
2.33 frystyk 201: HTCoding * pres;
202: while ((pres = (HTCoding *) HTList_nextObject(cur))) {
2.5 frystyk 203: if (first) {
2.24 frystyk 204: PUTS("Accept-Encoding: ");
2.32 frystyk 205: first = NO;
2.24 frystyk 206: } else
207: PUTC(',');
2.33 frystyk 208: PUTS(HTCoding_name(pres));
2.4 frystyk 209: }
210: }
211: }
2.31 frystyk 212: if (!first) PUTBLOCK(crlf, 2);
2.4 frystyk 213: }
2.34 frystyk 214: if (request_mask & HT_C_ACCEPT_LAN) {
2.4 frystyk 215: int list;
216: HTList *cur;
2.24 frystyk 217: BOOL first=YES;
2.4 frystyk 218: for (list=0; list<2; list++) {
2.14 frystyk 219: if ((!list && ((cur = HTFormat_language()) != NULL)) ||
220: (list && ((cur = HTRequest_language(request)) != NULL))) {
2.4 frystyk 221: HTAcceptNode *pres;
222: while ((pres = (HTAcceptNode *) HTList_nextObject(cur))) {
2.5 frystyk 223: if (first) {
2.24 frystyk 224: PUTS("Accept-Language: ");
2.5 frystyk 225: first=NO;
2.24 frystyk 226: } else
227: PUTC(',');
228: PUTS(HTAtom_name(pres->atom));
229: if (pres->quality != 1.0) {
230: sprintf(qstr, ";q=%1.1f", pres->quality);
231: PUTS(qstr);
2.5 frystyk 232: }
2.4 frystyk 233: }
234: }
235: }
2.31 frystyk 236: if (!first) PUTBLOCK(crlf, 2);
2.4 frystyk 237: }
2.36 frystyk 238: if (request_mask & HT_C_AUTH) {
2.34 frystyk 239: HTAssocList * cur = HTRequest_credentials(request);
240: if (cur) { /* Access authentication */
241: HTAssoc * pres;
242: while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
243: PUTS(HTAssoc_name(pres));
244: PUTS(": ");
245: PUTS(HTAssoc_value(pres));
246: PUTBLOCK(crlf, 2);
247: }
2.28 frystyk 248: }
2.1 frystyk 249: }
2.34 frystyk 250: if (request_mask & HT_C_FROM) {
251: HTUserProfile * up = HTRequest_userProfile(request);
252: const char * mailaddress = HTUserProfile_email(up);
2.1 frystyk 253: if (mailaddress) {
2.24 frystyk 254: PUTS("From: ");
255: PUTS(mailaddress);
256: PUTBLOCK(crlf, 2);
2.1 frystyk 257: }
258: }
2.34 frystyk 259: if (request_mask & HT_C_HOST) {
2.13 frystyk 260: char *orig = HTAnchor_address((HTAnchor *) anchor);
2.12 frystyk 261: char *host = HTParse(orig, "", PARSE_HOST);
2.34 frystyk 262: #if 0
263: /* Keep the port number for HTTP/1.1 compliance */
2.12 frystyk 264: char *ptr = strchr(host, ':'); /* Chop off port number */
265: if (ptr) *ptr = '\0';
2.34 frystyk 266: #endif
2.24 frystyk 267: PUTS("Host: ");
268: PUTS(host);
269: PUTBLOCK(crlf, 2);
2.26 frystyk 270: HT_FREE(orig);
271: HT_FREE(host);
2.39 frystyk 272: }
2.42 frystyk 273:
274: /*
275: ** In the "If-*" series of headers, the ones related to etags have higher
276: ** priority than the date relates ones. That is, if we have a etag then
277: ** use that, otherwise use the date
278: */
2.43 frystyk 279: if (request_mask & HT_C_IF_MATCH && etag) {
280: PUTS("If-Match: \"");
281: PUTS(etag);
282: PUTC('"');
283: PUTBLOCK(crlf, 2);
284: if (PROT_TRACE) HTTrace("HTTP........ If-Match using etag `%s\'\n", etag);
285: } else if (request_mask & HT_C_IF_UNMOD_SINCE) {
2.42 frystyk 286: time_t lm = HTAnchor_lastModified(anchor);
287: if (lm > 0) {
2.43 frystyk 288: PUTS("If-Unmodified-Since: ");
2.42 frystyk 289: PUTS(HTDateTimeStr(&lm, NO));
290: PUTBLOCK(crlf, 2);
2.43 frystyk 291: if (PROT_TRACE) HTTrace("HTTP........ If-Unmodified-Since\n");
2.42 frystyk 292: }
293: }
2.43 frystyk 294: if (request_mask & HT_C_IF_NONE_MATCH && etag) {
295: PUTS("If-None-Match: \"");
296: PUTS(etag);
297: PUTC('"');
298: PUTBLOCK(crlf, 2);
299: if (PROT_TRACE) HTTrace("HTTP........ If-None-Match using etag `%s\'\n", etag);
300: } else if (request_mask & HT_C_IMS) {
2.42 frystyk 301: time_t lm = HTAnchor_lastModified(anchor);
302: if (lm > 0) {
2.43 frystyk 303: PUTS("If-Modified-Since: ");
2.42 frystyk 304: PUTS(HTDateTimeStr(&lm, NO));
305: PUTBLOCK(crlf, 2);
2.43 frystyk 306: if (PROT_TRACE) HTTrace("HTTP........ If-Modified-Since\n");
2.42 frystyk 307: }
308: }
309:
310: if (request_mask & HT_C_IF_RANGE) {
311:
312: /* Not supported */
313:
314: }
2.39 frystyk 315: if (request_mask & HT_C_MAX_FORWARDS) {
316: int hops = HTRequest_maxForwards(request);
317: if (hops >= 0) {
318: sprintf(qstr, "%d", hops);
319: PUTS("Max-Forwards: ");
320: PUTS(qstr);
321: PUTBLOCK(crlf, 2);
322: }
2.42 frystyk 323: }
324: if (request_mask & HT_C_RANGE) {
325:
326: /* Not supported */
327:
2.1 frystyk 328: }
2.34 frystyk 329: if (request_mask & HT_C_REFERER) {
330: HTParentAnchor * parent_anchor = HTRequest_parent(request);
331: if (parent_anchor) {
332: char * act = HTAnchor_address((HTAnchor *) anchor);
333: char * parent = HTAnchor_address((HTAnchor *) parent_anchor);
334: char * relative = HTParse(parent, act,
335: PARSE_ACCESS|PARSE_HOST|PARSE_PATH|PARSE_PUNCTUATION);
336: if (relative && *relative) {
337: PUTS("Referer: ");
338: PUTS(parent);
339: PUTBLOCK(crlf, 2);
340: }
341: HT_FREE(act);
342: HT_FREE(parent);
343: HT_FREE(relative);
2.1 frystyk 344: }
345: }
2.34 frystyk 346: if (request_mask & HT_C_USER_AGENT) {
2.24 frystyk 347: PUTS("User-Agent: ");
348: PUTS(HTLib_appName());
349: PUTC('/');
350: PUTS(HTLib_appVersion());
351: PUTC(' ');
352: PUTS(HTLib_name());
353: PUTC('/');
354: PUTS(HTLib_version());
355: PUTBLOCK(crlf, 2);
2.1 frystyk 356: }
2.27 eric 357: if (PROT_TRACE)HTTrace("HTTP........ Generating Request Headers\n");
2.38 frystyk 358: return HT_OK;
2.1 frystyk 359: }
360:
2.29 frystyk 361: PRIVATE int HTTPRequest_put_block (HTStream * me, const char * b, int l)
2.1 frystyk 362: {
2.7 frystyk 363: if (!me->target) {
2.1 frystyk 364: return HT_WOULD_BLOCK;
2.7 frystyk 365: } else if (me->transparent)
2.11 frystyk 366: return b ? PUTBLOCK(b, l) : HT_OK;
2.1 frystyk 367: else {
2.38 frystyk 368: int status = HT_OK;
369: if (me->version == HTTP_09) {
370: status = HTTP09Request(me, me->request);
371: if (status != HT_OK) return status;
372: } else {
373: status = HTTPMakeRequest(me, me->request);
374: if (status != HT_OK) return status;
2.1 frystyk 375: me->transparent = YES;
2.11 frystyk 376: return b ? PUTBLOCK(b, l) : HT_OK;
2.1 frystyk 377: }
378: return status;
379: }
380: }
381:
2.16 frystyk 382: PRIVATE int HTTPRequest_put_character (HTStream * me, char c)
2.1 frystyk 383: {
2.11 frystyk 384: return HTTPRequest_put_block(me, &c, 1);
2.1 frystyk 385: }
386:
2.29 frystyk 387: PRIVATE int HTTPRequest_put_string (HTStream * me, const char * s)
2.1 frystyk 388: {
2.11 frystyk 389: return HTTPRequest_put_block(me, s, strlen(s));
2.1 frystyk 390: }
391:
392: /*
393: ** Flushes data but doesn't free stream object
394: */
2.16 frystyk 395: PRIVATE int HTTPRequest_flush (HTStream * me)
2.1 frystyk 396: {
2.13 frystyk 397: int status = HTTPRequest_put_block(me, NULL, 0);
398: return status==HT_OK ? (*me->target->isa->flush)(me->target) : status;
2.1 frystyk 399: }
400:
401: /*
402: ** Flushes data and frees stream object
403: */
2.16 frystyk 404: PRIVATE int HTTPRequest_free (HTStream * me)
2.1 frystyk 405: {
2.11 frystyk 406: int status = HTTPRequest_flush(me);
407: if (status != HT_WOULD_BLOCK) {
408: if ((status = (*me->target->isa->_free)(me->target)) == HT_WOULD_BLOCK)
409: return HT_WOULD_BLOCK;
2.38 frystyk 410: HT_FREE(me->url);
2.26 frystyk 411: HT_FREE(me);
2.1 frystyk 412: }
2.7 frystyk 413: return status;
2.1 frystyk 414: }
415:
2.16 frystyk 416: PRIVATE int HTTPRequest_abort (HTStream * me, HTList * e)
2.1 frystyk 417: {
2.13 frystyk 418: if (me->target) (*me->target->isa->abort)(me->target, e);
2.38 frystyk 419: HT_FREE(me->url);
2.26 frystyk 420: HT_FREE(me);
2.27 eric 421: if (PROT_TRACE) HTTrace("HTTPRequest. ABORTING...\n");
2.1 frystyk 422: return HT_ERROR;
423: }
424:
425: /* HTTPRequest Stream
426: ** -----------------
427: */
2.29 frystyk 428: PRIVATE const HTStreamClass HTTPRequestClass =
2.1 frystyk 429: {
430: "HTTPRequest",
431: HTTPRequest_flush,
432: HTTPRequest_free,
433: HTTPRequest_abort,
434: HTTPRequest_put_character,
435: HTTPRequest_put_string,
436: HTTPRequest_put_block
437: };
438:
2.23 frystyk 439: PUBLIC HTStream * HTTPRequest_new (HTRequest * request, HTStream * target,
440: BOOL endHeader)
2.1 frystyk 441: {
2.34 frystyk 442: HTNet * net = HTRequest_net(request);
443: HTHost * host = HTNet_host(net);
2.26 frystyk 444: HTStream * me;
445: if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL)
446: HT_OUTOFMEM("HTTPRequest_new");
2.1 frystyk 447: me->isa = &HTTPRequestClass;
448: me->target = target;
449: me->request = request;
2.32 frystyk 450: me->version = HTHost_version(host);
2.1 frystyk 451: me->transparent = NO;
2.23 frystyk 452:
453: /* Return general HTTP header stream */
454: return HTTPGen_new(request, me, endHeader);
2.1 frystyk 455: }
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