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