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