/* HTMIME_anchor2response
* Copies the anchor HTTP headers into a response object by means
* of the generic _dispatchParsers function. Written so that we can
* copy the HTTP headers stored in the cache to the response object.
*/
PRIVATE void HTMIME_anchor2response (HTRequest * req)
{
char * token;
char * value;
HTAssocList * header;
HTAssoc * pres;
HTResponse * res;
HTParentAnchor * anchor;
if (!req)
return;
anchor = HTRequest_anchor (req);
header = HTAnchor_header (anchor);
if (!anchor || !header)
return;
while ((pres = (HTAssoc *) HTAssocList_nextObject (header)))
{
token = HTAssoc_name (pres);
value = HTAssoc_value (pres);
_dispatchParsers (req, token, value);
}
/*
** Notify the response object not to delete the lists that we
** have inherited from the anchor object
*/
res = HTRequest_response (req);
HTResponse_isCached (res, YES);
}
/*
** Check whether the application provides us with a cookie or more.
*/
PRIVATE int HTCookie_beforeFilter (HTRequest * request, void * param, int mode)
{
if ((CookieMode & HT_COOKIE_SEND) && FindCookie) {
HTAssocList * cookies = (*FindCookie)(request, FindCookieContext);
if (cookies) {
HTChunk * cookie_header = HTChunk_new(64);
HTAssocList * cur = cookies;
HTAssoc * pres;
BOOL first=YES;
while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
if (!first) HTChunk_putc(cookie_header, ';');
HTChunk_puts(cookie_header, HTAssoc_name(pres));
HTChunk_putc(cookie_header, '=');
HTChunk_puts(cookie_header, HTAssoc_value(pres));
first = NO;
}
HTRequest_addExtraHeader(request, "Cookie", HTChunk_data(cookie_header));
HTChunk_delete(cookie_header);
/* Also delete the association list */
HTAssocList_delete(cookies);
}
}
return HT_OK;
}
PRIVATE int terminate_handler (HTRequest * request, HTResponse * response,
void * param, int status)
{
HTParentAnchor * anchor = HTRequest_anchor(request);
HTAssocList * headers = HTAnchor_header(anchor);
/*
** Write out the remaining list of headers that we not already store
** in the index file.
*/
if (headers) {
HTAssocList * cur = headers;
HTAssoc * pres;
while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
char * name = HTAssoc_name(pres);
char * value = HTAssoc_value(pres);
/* Now see if we have a match for this header field */
if (match && HTStrCaseMatch(match, name))
HTPrint("%s: %s\n", name, value);
}
}
/* stop the event loop */
HTEventList_stopLoop ();
/* stop here */
return HT_ERROR;
}
PUBLIC char * HTAssocList_findObjectCaseSensitiveExact (HTAssocList * list, const char * name)
{
if (list && name) {
HTAssocList * cur = list;
HTAssoc * assoc;
while ((assoc = (HTAssoc *) HTAssocList_nextObject(cur))) {
if (!strcmp(HTAssoc_name(assoc), name))
return HTAssoc_value(assoc);
}
}
return NULL;
}
/*
** my_headers : shows anchor's headers
** Parameters : HTRequest * request
*/
PRIVATE void my_headers (HTRequest *request) {
HTAssoc * h = NULL;
HTAssocList * headers = NULL;
HTParentAnchor * anchor = NULL;
HTPrint ("%s: Searching headers...\n",APP_NAME);
anchor = HTRequest_anchor (request);
headers = HTAnchor_header(anchor);
HTPrint ("\tanchor %s\n",(anchor)?"OK":"NULL");
h = HTAssocList_nextObject(headers);
while (anchor && headers && h ) {
HTPrint ("\t%s : %s\n",HTAssoc_name(h),HTAssoc_value(h));
h = HTAssocList_nextObject(headers);
}
}
/* HTTPMakeRequest
** ---------------
** Makes a HTTP/1.0-1.1 request header.
*/
PRIVATE int HTTPMakeRequest (HTStream * me, HTRequest * request)
{
HTMethod method = HTRequest_method(request);
HTRqHd request_mask = HTRequest_rqHd(request);
HTParentAnchor * anchor = HTRequest_anchor(request);
char * etag = HTAnchor_etag(anchor);
char crlf[3];
char qstr[10];
*crlf = CR; *(crlf+1) = LF; *(crlf+2) = '\0';
/* Generate the HTTP/1.x RequestLine */
if (me->state == 0) {
if (method != METHOD_INVALID) {
PUTS(HTMethod_name(method));
PUTC(' ');
} else
PUTS("GET ");
me->state++;
}
/*
** Generate the Request URI. If we are using full request URI then it's
** easy. Otherwise we must filter out the path part of the URI.
** In case it's a OPTIONS request then if there is no pathinfo then use
** a * instead. If we use a method different from GET or HEAD then use
** the content-location if available.
*/
if (me->state == 1) {
char * abs_location = NULL;
char * addr = HTAnchor_physical(anchor);
char * location;
/* JK: If the application specified a content-location (which is
stored in the request in default put-name!), we use it instead
of the URL that's being saved to. This is like having a user
defined Content-Location */
location = HTRequest_defaultPutName (request);
if (location)
{
if (HTURL_isAbsolute (location))
{
char * relative;
relative = HTRelative (location, location);
abs_location = HTParse (relative + 2, addr, PARSE_ALL);
HT_FREE (relative);
}
else
abs_location = HTParse (location, addr, PARSE_ALL);
addr = abs_location;
}
#if 0
/*
** We don't use the content-location any more as it is superseeded
** by etags and the combination of the two might do more harm than
** good (The etag is not guaranteed to be unique over multiple URIs)
*/
/*
** If we are using a method different from HEAD and GET then use
** the Content-Location if available, else the Request-URI.
*/
if (!HTMethod_isSafe(method)) {
char * location = HTAnchor_location(anchor);
if (location) {
if (HTURL_isAbsolute(location))
addr = location;
else {
/*
** We have a content-location but it is relative and
** must expand it either to the content-base or to
** the Request-URI itself.
*/
char * base = HTAnchor_base(anchor);
abs_location = HTParse(location, base, PARSE_ALL);
addr = abs_location;
}
}
}
#endif
/*
** If we are using a proxy or newer versions of HTTP then we can
** send the full URL. Otherwise we only send the path.
*/
if (HTRequest_fullURI(request))
StrAllocCopy(me->url, addr);
else {
me->url = HTParse(addr, "", PARSE_PATH | PARSE_PUNCTUATION);
if (method == METHOD_OPTIONS) {
/*
** We don't preserve the final slash or lack of same through
** out the code. This is mainly for optimization reasons
** but it gives a problem OPTIONS. We can either send a "*"
** or a "/" but not both. For now we send a "*".
*/
if (!strcmp(me->url, "/")) *me->url = '*';
}
}
HT_FREE(abs_location);
me->state++;
}
/*
** Now send the URL that we have put together
*/
if (me->state == 2) {
int status = HT_OK;
if ((status = PUTS(me->url)) != HT_OK) return status;
me->state++;
#if 0
fprintf(stderr, "Requesting '%s'\n", me->url);
#endif
}
PUTC(' ');
/*
** Send out the version number. If we know it is a HTTP/1.0 server we
** are talking to then use HTTP/1.0, else use HTTP/1.1 as default version
** number
*/
if (me->version == HTTP_10)
PUTS(HTTP_VERSION_10);
else
PUTS(HTTP_VERSION);
PUTBLOCK(crlf, 2);
/* Request Headers */
if (request_mask & HT_C_ACCEPT_TYPE) {
HTFormat format = HTRequest_outputFormat(request);
/*
** If caller has specified a specific output format then use this.
** Otherwise use all the registered converters to generate the
** accept header
*/
if (format == WWW_PRESENT) {
int list;
HTList *cur;
BOOL first=YES;
for (list=0; list<2; list++) {
if ((!list && ((cur = HTFormat_conversion()) != NULL)) ||
(list && ((cur = HTRequest_conversion(request))!=NULL))) {
HTPresentation * pres;
while ((pres=(HTPresentation *) HTList_nextObject(cur))) {
if (pres->rep_out==WWW_PRESENT && pres->quality<=1.0) {
if (first) {
PUTS("Accept: ");
first=NO;
} else
PUTC(',');
PUTS(HTAtom_name(pres->rep));
if (pres->quality < 1.0 && pres->quality >= 0.0) {
sprintf(qstr, ";q=%1.1f", pres->quality);
PUTS(qstr);
}
}
}
}
}
if (!first) PUTBLOCK(crlf, 2);
} else {
/*
** If we have an explicit output format then only send
** this one if not this is an internal libwww format
** of type www/<star>
*/
if (!HTMIMEMatch(WWW_INTERNAL, format)) {
PUTS("Accept: ");
PUTS(HTAtom_name(format));
PUTBLOCK(crlf, 2);
}
}
}
if (request_mask & HT_C_ACCEPT_CHAR) {
int list;
HTList *cur;
BOOL first=YES;
for (list=0; list<2; list++) {
if ((!list && ((cur = HTFormat_charset()) != NULL)) ||
(list && ((cur = HTRequest_charset(request)) != NULL))) {
HTAcceptNode *pres;
while ((pres = (HTAcceptNode *) HTList_nextObject(cur))) {
if (first) {
PUTS("Accept-Charset: ");
first=NO;
} else
PUTC(',');
PUTS(HTAtom_name(pres->atom));
if (pres->quality < 1.0 && pres->quality >= 0.0) {
sprintf(qstr, ";q=%1.1f", pres->quality);
PUTS(qstr);
}
}
}
}
if (!first) PUTBLOCK(crlf, 2);
}
if (request_mask & HT_C_ACCEPT_ENC) {
int list;
HTList *cur;
BOOL first=YES;
for (list=0; list<2; list++) {
if ((!list && ((cur = HTFormat_contentCoding()) != NULL)) ||
(list && ((cur = HTRequest_encoding(request)) != NULL))) {
HTCoding * pres;
while ((pres = (HTCoding *) HTList_nextObject(cur))) {
double quality = HTCoding_quality(pres);
if (first) {
PUTS("Accept-Encoding: ");
first = NO;
} else
PUTC(',');
PUTS(HTCoding_name(pres));
if (quality < 1.0 && quality >= 0.0) {
sprintf(qstr, ";q=%1.1f", quality);
PUTS(qstr);
}
}
}
}
if (!first) PUTBLOCK(crlf, 2);
}
if (request_mask & HT_C_ACCEPT_TE) {
int list;
HTList *cur;
BOOL first=YES;
for (list=0; list<2; list++) {
if ((!list && ((cur = HTFormat_transferCoding()) != NULL)) ||
(list && ((cur = HTRequest_transfer(request)) != NULL))) {
HTCoding * pres;
while ((pres = (HTCoding *) HTList_nextObject(cur))) {
double quality = HTCoding_quality(pres);
const char * coding = HTCoding_name(pres);
if (first) {
PUTS("TE: ");
first = NO;
} else
PUTC(',');
/* Special check for "chunked" which is translated to "trailers" */
if (!strcasecomp(coding, "chunked"))
PUTS("trailers");
else
PUTS(coding);
if (quality < 1.0 && quality >= 0.0) {
sprintf(qstr, ";q=%1.1f", quality);
PUTS(qstr);
}
}
}
}
if (!first) PUTBLOCK(crlf, 2);
}
if (request_mask & HT_C_ACCEPT_LAN) {
int list;
HTList *cur;
BOOL first=YES;
for (list=0; list<2; list++) {
if ((!list && ((cur = HTFormat_language()) != NULL)) ||
(list && ((cur = HTRequest_language(request)) != NULL))) {
HTAcceptNode *pres;
while ((pres = (HTAcceptNode *) HTList_nextObject(cur))) {
if (first) {
PUTS("Accept-Language: ");
first=NO;
} else
PUTC(',');
PUTS(HTAtom_name(pres->atom));
if (pres->quality < 1.0 && pres->quality >= 0.0) {
sprintf(qstr, ";q=%1.1f", pres->quality);
PUTS(qstr);
}
}
}
}
if (!first) PUTBLOCK(crlf, 2);
}
if (request_mask & HT_C_AUTH) {
HTAssocList * cur = HTRequest_credentials(request);
if (cur) { /* Access authentication */
HTAssoc * pres;
while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
PUTS(HTAssoc_name(pres));
PUTS(": ");
PUTS(HTAssoc_value(pres));
PUTBLOCK(crlf, 2);
}
}
}
if (request_mask & HT_C_EXPECT) {
HTAssocList * cur = HTRequest_expect(request);
if (cur) {
BOOL first=YES;
HTAssoc * pres;
while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
char * value = HTAssoc_value(pres);
if (first) {
PUTS("Expect: ");
first = NO;
} else
PUTC(',');
/* Output the name */
PUTS(HTAssoc_name(pres));
/* Only output the value if not empty string */
if (*value) {
PUTS("=");
PUTS(value);
}
}
PUTBLOCK(crlf, 2);
}
}
if (request_mask & HT_C_FROM) {
HTUserProfile * up = HTRequest_userProfile(request);
const char * mailaddress = HTUserProfile_email(up);
if (mailaddress) {
PUTS("From: ");
PUTS(mailaddress);
PUTBLOCK(crlf, 2);
}
}
if (request_mask & HT_C_HOST) {
char *orig = HTAnchor_address((HTAnchor *) anchor);
char *host = HTParse(orig, "", PARSE_HOST);
char hostace[256];
#if 0
/* Keep the port number for HTTP/1.1 compliance */
char *ptr = strchr(host, ':'); /* Chop off port number */
if (ptr) *ptr = '\0';
#endif
PUTS("Host: ");
/****** still have to check UTF8toACE with port number */
if (!HTACEfromUTF8 (host, hostace, 255)) {
PUTS(hostace);
}
else {
PUTS(host); /* this may be dangerous, but helps server side debugging */
HTTRACE(PROT_TRACE, "HTTP........ Error: Cannot convert to ACE: `%s\'\n" _ host);
}
PUTBLOCK(crlf, 2);
HT_FREE(orig);
HT_FREE(host);
}
/*
** In the "If-*" series of headers, the ones related to etags have higher
** priority than the date relates ones. That is, if we have a etag then
** use that, otherwise use the date. First we check for range, match, and
** unmodified-since.
*/
if (request_mask & HT_C_IF_RANGE && etag) {
PUTS("If-Range: \"");
PUTS(etag);
PUTC('"');
PUTBLOCK(crlf, 2);
HTTRACE(PROT_TRACE, "HTTP........ If-Range using etag `%s\'\n" _ etag);
} else if (request_mask & HT_C_IF_MATCH_ANY) {
PUTS("If-Match: *");
PUTBLOCK(crlf, 2);
HTTRACE(PROT_TRACE, "HTTP........ If-Match using `*\'\n");
} else if (request_mask & HT_C_IF_MATCH && etag) {
PUTS("If-Match: \"");
PUTS(etag);
PUTC('"');
PUTBLOCK(crlf, 2);
HTTRACE(PROT_TRACE, "HTTP........ If-Match using etag `%s\'\n" _ etag);
} else if (request_mask & HT_C_IF_UNMOD_SINCE) {
time_t lm = HTAnchor_lastModified(anchor);
if (lm > 0) {
PUTS("If-Unmodified-Since: ");
PUTS(HTDateTimeStr(&lm, NO));
PUTBLOCK(crlf, 2);
HTTRACE(PROT_TRACE, "HTTP........ If-Unmodified-Since `%s\'\n" _ HTDateTimeStr(&lm, NO));
}
}
/*
** If-None-Match and If-Modified-Since are equivalent except that the
** first uses etags and the second uses dates. Etags have precedence over
** dates.
*/
if (request_mask & HT_C_IF_NONE_MATCH_ANY) {
PUTS("If-None-Match: *");
PUTBLOCK(crlf, 2);
HTTRACE(PROT_TRACE, "HTTP........ If-None-Match using `*\'\n");
} else if (request_mask & HT_C_IF_NONE_MATCH && etag) {
PUTS("If-None-Match: \"");
PUTS(etag);
PUTC('"');
PUTBLOCK(crlf, 2);
HTTRACE(PROT_TRACE, "HTTP........ If-None-Match `%s\'\n" _ etag);
}
if (request_mask & HT_C_IMS) {
time_t lm = HTAnchor_lastModified(anchor);
if (lm > 0) {
PUTS("If-Modified-Since: ");
PUTS(HTDateTimeStr(&lm, NO));
PUTBLOCK(crlf, 2);
HTTRACE(PROT_TRACE, "HTTP........ If-Modified-Since `%s\'\n" _ HTDateTimeStr(&lm, NO));
}
}
/*
** Max forwards is mainly for TRACE where we want to be able to stop the
** TRACE at a specific location un the message path.
*/
if (request_mask & HT_C_MAX_FORWARDS) {
int hops = HTRequest_maxForwards(request);
if (hops >= 0) {
sprintf(qstr, "%d", hops);
PUTS("Max-Forwards: ");
PUTS(qstr);
PUTBLOCK(crlf, 2);
}
}
/*
** Range requests. For now, we only take the first entry registered for
** this request. This means that you can only send a single "unit" and
** then a set of range within this unit. This is in accordance with
** HTTP/1.1. Multiple units will go on multiple lines.
*/
if (request_mask & HT_C_RANGE) {
HTAssocList * cur = HTRequest_range(request);
if (cur) { /* Range requests */
HTAssoc * pres;
while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
PUTS("Range: ");
PUTS(HTAssoc_name(pres)); /* Unit */
PUTS("=");
PUTS(HTAssoc_value(pres)); /* Ranges within this unit */
PUTBLOCK(crlf, 2);
}
}
}
if (request_mask & HT_C_REFERER) {
HTParentAnchor * parent_anchor = HTRequest_parent(request);
if (parent_anchor) {
char * act = HTAnchor_address((HTAnchor *) anchor);
char * parent = HTAnchor_address((HTAnchor *) parent_anchor);
#if 1
char * relative = HTRelative(parent, act);
#else
char * relative = HTParse(parent, act,
PARSE_ACCESS|PARSE_HOST|PARSE_PATH|PARSE_PUNCTUATION);
#endif
if (relative && *relative) {
PUTS("Referer: ");
PUTS(relative);
PUTBLOCK(crlf, 2);
}
HT_FREE(act);
HT_FREE(parent);
HT_FREE(relative);
}
}
if (request_mask & HT_C_USER_AGENT) {
PUTS("User-Agent: ");
PUTS(HTLib_appName());
PUTC('/');
PUTS(HTLib_appVersion());
PUTC(' ');
PUTS(HTLib_name());
PUTC('/');
PUTS(HTLib_version());
PUTBLOCK(crlf, 2);
}
HTTRACE(PROT_TRACE, "HTTP........ Generating HTTP/1.x Request Headers\n");
return HT_OK;
}
