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