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