[0001] [0002] [0003] [0004] [0005] [0006] [0007] [0008] [0009] [0010] [0011] [0012] [0013] [0014] [0015] [0016] [0017] [0018] [0019] [0020] [0021] [0022] [0023] [0024] [0025] [0026] [0027] [0028] [0029] [0030] [0031] [0032] [0033] [0034] [0035] [0036] [0037] [0038] [0039] [0040] [0041] [0042] [0043] [0044] [0045] [0046] [0047] [0048] [0049] [0050] [0051] [0052] [0053] [0054] [0055] [0056] [0057] [0058] [0059] [0060] [0061] [0062] [0063] [0064] [0065] [0066] [0067] [0068] [0069] [0070] [0071] [0072] [0073] [0074] [0075] [0076] [0077] [0078] [0079] [0080] [0081] [0082] [0083] [0084] [0085] [0086] [0087] [0088] [0089] [0090] [0091] [0092] [0093] [0094] [0095] [0096] [0097] [0098] [0099] [0100] [0101] [0102] [0103] [0104] [0105] [0106] [0107] [0108] [0109] [0110] [0111] [0112] [0113] [0114] [0115] [0116] [0117] [0118] [0119] [0120] [0121] [0122] [0123] [0124] [0125] [0126] [0127] [0128] [0129] [0130] [0131] [0132] [0133] [0134] [0135] [0136] [0137] [0138] [0139] [0140] [0141] [0142] [0143] [0144] [0145] [0146] [0147] [0148] [0149] [0150] [0151] [0152] [0153] [0154] [0155] [0156] [0157] [0158] [0159] [0160] [0161] [0162] [0163] [0164] [0165] [0166] [0167] [0168] [0169] [0170] [0171] [0172] [0173] [0174] [0175] [0176] [0177] [0178] [0179] [0180] [0181] [0182] [0183] [0184] [0185] [0186] [0187] [0188] [0189] [0190] [0191] [0192] [0193] [0194] [0195] [0196] [0197] [0198] [0199] [0200] [0201] [0202] [0203] [0204] [0205] [0206] [0207] [0208] [0209] [0210] [0211] [0212] [0213] [0214] [0215] [0216] [0217] [0218] [0219] [0220] [0221] [0222] [0223] [0224] [0225] [0226] [0227] [0228] [0229] [0230] [0231] [0232] [0233] [0234] [0235] [0236] [0237] [0238] [0239] [0240] [0241] [0242] [0243] [0244] [0245] [0246] [0247] [0248] [0249] [0250] [0251] [0252] [0253] [0254] [0255] [0256] [0257] [0258] [0259] [0260] [0261] [0262] [0263] [0264] [0265] [0266] [0267] [0268] [0269] [0270] [0271] [0272] [0273] [0274] [0275] [0276] [0277] [0278] [0279] [0280] [0281] [0282] [0283] [0284] [0285] [0286] [0287] [0288] [0289] [0290] [0291] [0292] [0293] [0294] [0295] [0296] [0297] [0298] [0299] [0300] [0301] [0302] [0303] [0304] [0305] [0306] [0307] [0308] [0309] [0310] [0311] [0312] [0313] [0314] [0315] [0316] [0317] [0318] [0319] [0320] [0321] [0322] [0323] [0324] [0325] [0326] [0327] [0328] [0329] [0330] [0331] [0332] [0333] [0334] [0335] [0336] [0337] [0338] [0339] [0340] [0341] [0342] [0343] [0344] [0345] [0346] [0347] [0348] [0349] [0350] [0351] [0352] [0353] [0354] [0355] [0356] [0357] [0358] [0359] [0360] [0361] [0362] [0363] [0364] [0365] [0366] [0367] [0368] [0369] [0370] [0371] [0372] [0373] [0374] [0375] [0376] [0377] [0378] [0379] [0380] [0381] [0382] [0383] [0384] [0385] [0386] [0387] [0388] [0389] [0390] [0391] [0392] [0393] [0394] [0395] [0396] [0397] [0398] [0399] [0400] [0401] [0402] [0403] [0404] [0405] [0406] [0407] [0408] [0409] [0410] [0411] [0412] [0413] [0414] [0415] [0416] [0417] [0418] [0419] [0420] [0421] [0422] [0423] [0424] [0425] [0426] [0427] [0428] [0429] [0430] [0431] [0432] [0433] [0434] [0435] [0436] [0437] [0438] [0439] [0440] [0441] [0442] [0443] [0444] [0445] [0446] [0447] [0448] [0449] [0450] [0451] [0452] [0453] [0454] [0455] [0456] [0457] [0458] [0459] [0460] [0461] [0462] [0463] [0464] [0465] [0466] [0467] [0468] [0469] [0470] [0471] [0472] [0473] [0474] [0475] [0476] [0477] [0478] [0479] [0480] [0481] [0482] [0483] [0484] [0485] [0486] [0487] [0488] [0489] [0490] [0491] [0492] [0493] [0494] [0495] [0496] [0497] [0498] [0499] [0500] [0501] [0502] [0503] [0504] [0505] [0506] [0507] [0508] [0509] [0510] [0511] [0512] [0513] [0514] [0515] [0516] [0517] [0518] [0519] [0520] [0521] [0522] [0523] [0524] [0525] [0526] [0527] [0528] [0529] [0530] [0531] [0532] [0533] [0534] [0535] [0536] [0537] [0538] [0539] [0540] [0541] [0542] [0543] [0544] [0545] [0546] [0547] [0548] [0549] [0550] [0551] [0552] [0553] [0554] [0555] [0556] [0557] [0558] [0559] [0560] [0561] [0562] [0563] [0564] [0565] [0566] [0567] [0568] [0569] [0570] [0571] [0572] [0573] [0574] [0575] [0576] [0577] [0578] [0579] [0580] [0581] [0582] [0583] [0584] [0585] [0586] [0587] [0588] [0589] [0590] [0591] [0592] [0593] [0594] [0595] [0596] [0597] [0598] [0599] [0600] [0601] [0602] [0603] [0604] [0605] [0606] [0607] [0608] [0609] [0610] [0611] [0612] [0613] [0614] [0615] [0616] [0617] [0618] [0619] [0620] [0621] [0622] [0623] [0624] [0625] [0626] [0627] [0628] [0629] [0630] [0631] [0632] [0633] [0634] [0635] [0636] [0637] [0638] [0639] [0640] [0641] [0642] [0643] [0644] [0645] [0646] [0647] [0648] [0649] [0650] [0651] [0652] [0653] [0654] [0655] [0656] [0657] [0658] [0659] [0660] [0661] [0662] [0663] [0664] [0665] [0666] [0667] [0668] [0669] [0670] [0671] [0672] [0673] [0674] [0675] [0676] [0677] [0678] [0679] [0680] [0681] [0682] [0683] [0684] [0685] [0686] [0687] [0688] [0689] [0690] [0691] [0692] [0693] [0694] [0695] [0696] [0697] [0698] [0699] [0700] [0701] [0702] [0703] [0704] [0705] [0706] [0707] [0708] [0709] [0710] [0711] [0712] [0713] [0714] [0715] [0716] [0717] [0718] [0719] [0720] [0721] [0722] [0723] [0724] [0725] [0726] [0727] [0728] [0729] [0730] [0731] [0732] [0733] [0734] [0735] [0736] [0737] [0738] [0739] [0740] [0741] [0742] [0743] [0744] [0745] [0746] [0747] [0748] [0749] [0750] [0751] [0752] [0753] [0754] [0755] [0756] [0757] [0758] [0759] [0760] [0761] [0762] [0763] [0764] [0765] [0766] [0767] [0768] [0769] [0770] [0771] [0772] [0773] [0774] [0775] [0776] [0777] [0778] [0779] [0780] [0781] [0782] [0783] [0784] [0785] [0786] [0787] [0788] [0789] [0790] [0791] [0792] [0793] [0794] [0795] [0796] [0797] [0798] [0799] [0800] [0801] [0802] [0803] [0804] [0805] [0806] [0807] [0808] [0809] [0810] [0811]
/*****************************************************************************/ /* Redirect.c The 'rqptr->rqResponse.LocationPtr' is non-NULL indicating redirection. This can be local, indicated by a leading '/', or it can be non-local, indicated by anything other than a leading '/', usually a full URL including scheme (e.g. "http:"). If the URL comprises something like "///some/path/or/other" then the request scheme ("http:", "https:") and "Host:" or service host:port is substituted in the appropriate position in the URL. If "//:port/path" (i.e. begins with "//:") the request scheme and host are substituted into the URL and it becomes effectively a redirect to a different port on the same host. If "//host.domain/path/" then just the request scheme is added. If "http:///path/" or "https:///path/" then the service host:port is added to the redirection URL (essentially this provides for a change of request scheme). If the 'rqptr->rqResponse.LocationPtr' has as it's last character a '?' and no query string itself, and if the request contains a query string then that is appended to the redirection URL when building the redirected request. Special case redirect; relies on being able to manipulate host record in the DNS or local name resolution database. If a "*.the.proxy.host" DNS (CNAME) record is resolved it allows any host name ending in ".the.proxy.host" to resolve to the corresponding IP address. Similarly (at least the Compaq TCP/IP Services) local host database allows an alias like "another.host.name.proxy.host.name" for the proxy host name. Both of these would allow a browser to access "another.host.name.proxy.host.name" with it resolved to the proxy service. The request "Host:" field would contain "another.host.name.proxy.host.name". This is specially searched for, detected and processed by this function. See description in PROXY.C for more detail on usage. If authorization is enabled then all redirected requests should be returned to the client in case authorization information needs to be applied to the new request. This may involve reformating a local redirection into a non-local one. If authentication is not enabled then check both local and non-local redirections to see if it can be handled locally. Return normal status to indicate local-redirection (and that the thread should NOT be disposed of), or an error status to indicate client-handled, non-local-redirection, or a legitimate error (and that the thread can go). VERSION HISTORY --------------- 02-FEB-2019 MGD allow a specified port when redirecting, i.e. http[s]//:nnn bugfix; non-local without "Host:" use name not host:port 21-MAR-2017 MGD bugfix; use rqHeader.RequestBody.. for body with header 28-DEC-2015 MGD move from REQUEST.C to indepedent module */ /*****************************************************************************/ #ifdef WASD_VMS_V7 #undef _VMS__V6__SOURCE #define _VMS__V6__SOURCE #undef __VMS_VER #define __VMS_VER 70000000 #undef __CRTL_VER #define __CRTL_VER 70000000 #endif /* standard C header files */ #include <ctype.h> #include <errno.h> #include <stdio.h> #include <string.h> /* application header files */ #include "wasd.h" #define WASD_MODULE "REDIRECT" /******************/ /* global storage */ /******************/ /********************/ /* external storage */ /********************/ #ifdef DBUG extern BOOL Debug; #else #define Debug 0 #endif extern BOOL Http2Enabled; extern int ToLowerCase[], ToUpperCase[]; extern char ErrorSanityCheck[], SoftwareID[]; #define acptr AccountingPtr extern ACCOUNTING_STRUCT *AccountingPtr; extern CONFIG_STRUCT Config; extern MSG_STRUCT Msgs; extern WATCH_STRUCT Watch; /****************************************************************************/ /* */ int RedirectRequest (REQUEST_STRUCT *rqptr) { #define STRCAT(string) { \ for (cptr = string; *cptr && sptr < zptr; *sptr++ = *cptr++); \ } #define CHRCAT(ch) { \ if (sptr < zptr) *sptr++ = ch; \ } static char *SchemeHttp = "/http://", *SchemeHttps = "/https://", *SchemeFtp = "/ftp://"; static BOOL RedirectWildcardChecked, RedirectWildcardEnabled; static char TextContentLength [32]; static $DESCRIPTOR (TextContentLengthDsc, TextContentLength); static $DESCRIPTOR (TextContentLengthFaoDsc, "Content-Length: !UL\r\n\0"); BOOL IncludeQueryString, ConcatQueryString, LocalRedirection; int idx, length, status, AlphaCount, BodyCount, ExciseCount, HostDotCount, PortNumber, ReadBufferSize, RequestHeaderLength, RequestLineLength, SchemeLength, ServiceDotCount, StringDotCount, UrlLength; int64 BytesRx64; char *aptr, *cptr, *sptr, *zptr, *BodyPtr, *HttpMethodNamePtr, *ReadBufferPtr, *RequestLinePtr, *PathPtr, *SchemePtr, *UrlPtr, *UrlEndPtr; char HttpMethodName [32], HostField [128+16], /* allow for agents with silly amounts of request header */ RedirectionUrl [16384]; DICT_STRUCT *dicptr; DICT_ENTRY_STRUCT *denptr; /*********/ /* begin */ /*********/ if (WATCHMOD (rqptr, WATCH_MOD_REQUEST)) WatchThis (WATCHITM(rqptr), WATCH_MOD_REQUEST, "RedirectRequest() !&Z", rqptr->rqResponse.LocationPtr); /* at this stage just to delineate this wildcard annoyance */ #define REDIRECT_WILDCARD 1 #if REDIRECT_WILDCARD if (!RedirectWildcardChecked) { /* bit of a kludge but "Acckkk Alex!" */ RedirectWildcardChecked = true; RedirectWildcardEnabled = (SysTrnLnm(WASD_REDIRECT_WILDCARD) != NULL); } #endif /* REDIRECT_WILDCARD */ if (rqptr->rqPathSet.Alert) RequestAlert (rqptr); if (WATCHING (rqptr, WATCH_REQUEST)) WatchThis (WATCHITM(rqptr), WATCH_REQUEST, "REDIRECT !AZ", rqptr->rqResponse.LocationPtr); if (rqptr->RedirectCount++ > REQUEST_REDIRECTION_MAX) { rqptr->rqResponse.LocationPtr = NULL; rqptr->rqResponse.HttpStatus = 500; ErrorGeneral (rqptr, MsgFor(rqptr,MSG_REQUEST_REDIRECTION), FI_LI); return (STS$K_ERROR); } rqptr->rqResponse.HttpStatus = 302; /* A leading space is normally not possible. This indicates a specific HTTP method must be used. Format is: "<space>METHOD<space><redirection-path>". */ if (rqptr->rqResponse.LocationPtr[0] == ' ') { HttpMethodNamePtr = sptr = HttpMethodName; for (cptr = rqptr->rqResponse.LocationPtr + 1; *cptr && *cptr != ' '; *sptr++ = *cptr++); *sptr = '\0'; rqptr->rqResponse.LocationPtr = cptr + 1; } else HttpMethodNamePtr = rqptr->rqHeader.MethodName; LocalRedirection = true; for (cptr = rqptr->rqResponse.LocationPtr; *cptr && *cptr != '?'; cptr++) { if (*cptr != ':' && *cptr != '/') continue; if (*cptr == ':') LocalRedirection = false; while (*cptr && *cptr != '?') cptr++; break; } if (ConcatQueryString = ((*cptr == '?') && !SAME2(cptr,'?\0'))) while (*cptr && !SAME2(cptr,'?\0')) cptr++; if (IncludeQueryString = SAME2(cptr,'?\0')) { if (!rqptr->rqHeader.QueryStringLength || !rqptr->rqHeader.QueryStringPtr[0]) { IncludeQueryString = ConcatQueryString = false; *cptr = '\0'; } } if (ConcatQueryString) *cptr = '\0'; if (LocalRedirection) UrlLength = MapUrl_VirtualPath (rqptr->rqHeader.PathInfoPtr, rqptr->rqResponse.LocationPtr, RedirectionUrl, sizeof(RedirectionUrl)); else UrlLength = strzcpy (RedirectionUrl, rqptr->rqResponse.LocationPtr, sizeof(RedirectionUrl)); if (IncludeQueryString) UrlLength += rqptr->rqHeader.QueryStringLength; if (UrlLength > sizeof(RedirectionUrl)-1) UrlLength = -1; if (UrlLength < 0) { ErrorNoticed (rqptr, SS$_RESULTOVF, NULL, FI_LI); ErrorGeneralOverflow (rqptr, FI_LI); return (STS$K_ERROR); } /* now ignore old value of location redirection pointer */ rqptr->rqResponse.LocationPtr = NULL; if (RedirectionUrl[0] == '/' && RedirectionUrl[1] != '/') LocalRedirection = true; else LocalRedirection = false; if (LocalRedirection) { /*********************/ /* local redirection */ /*********************/ InstanceGblSecIncrLong (&acptr->RedirectLocalCount); /* create a dictionary to contain the rebuilt request */ dicptr = DictCreate (rqptr, -1); if (!rqptr->Http2Stream.Http2Ptr && rqptr->rqHeader.ContentLength64) { /* allow for any content received along with the header */ BodyCount = rqptr->BytesRx64; BodyCount -= rqptr->rqHeader.RequestHeaderLength; sptr = rqptr->rqHeader.RequestHeaderPtr + rqptr->rqHeader.RequestHeaderLength; if (BodyCount) { BodyPtr = VmGetHeap (rqptr, BodyCount); memcpy (BodyPtr, sptr, BodyCount); } } else BodyCount = 0; HostField[0] = '\0'; if (RedirectionUrl[0] == '/' && (MATCH8 (RedirectionUrl, SchemePtr = SchemeHttp) || MATCH9 (RedirectionUrl, SchemePtr = SchemeHttps) || MATCH7 (RedirectionUrl, SchemePtr = SchemeFtp))) { /************/ /* to proxy */ /************/ if (WATCHMOD (rqptr, WATCH_MOD_REQUEST)) WatchThis (WATCHITM(rqptr), WATCH_MOD_REQUEST, "!&Z", RedirectionUrl); if (SchemePtr == SchemeHttp) SchemeLength = 8; else if (SchemePtr == SchemeHttps) SchemeLength = 9; else SchemeLength = 7; if (!rqptr->rqHeader.HostPtr) { rqptr->rqResponse.HttpStatus = 400; ErrorGeneral (rqptr, MsgFor(rqptr,MSG_PROXY_GATEWAY), FI_LI); return (STS$K_ERROR); } /* If the path has been SET 'proxy=reverse=location=<string>' then this and the original host information is conveyed to the redirected proxy request using redirect-persistent storage made available specifically for this purpose. */ if (rqptr->rqPathSet.ProxyReverseLocationPtr) { length = strlen(rqptr->ServicePtr->RequestSchemeNamePtr) + strlen(rqptr->rqHeader.HostPtr) + strlen(rqptr->rqPathSet.ProxyReverseLocationPtr) + 3; rqptr->ProxyReverseLocationPtr = VmGetHeap (rqptr, length); zptr = (sptr = rqptr->ProxyReverseLocationPtr) + length; STRCAT (rqptr->ServicePtr->RequestSchemeNamePtr) STRCAT ("//") STRCAT (rqptr->rqHeader.HostPtr) STRCAT (rqptr->rqPathSet.ProxyReverseLocationPtr) *sptr = '\0'; } #if REDIRECT_WILDCARD if (RedirectWildcardEnabled) { /* Check for a DNS 'wildcard' leading the service name. That is the "Host:" field contains more domain name components than the proxy service domain name. Do this by counting the number of periods in the strings. Acckkk Alex! Never been quite convinced of the need for this ;^) */ AlphaCount = HostDotCount = ServiceDotCount = 0; for (cptr = rqptr->rqHeader.HostPtr; *cptr; cptr++) { if (isalpha(*cptr)) AlphaCount++; if (*cptr != '.') continue; HostDotCount++; } if (AlphaCount) { /* only bother doing this if it's not dotted-decimal */ for (cptr = rqptr->ServicePtr->ServerHostPort; *cptr; cptr++) { if (*cptr != '.') continue; ServiceDotCount++; } } if (WATCHMOD (rqptr, WATCH_MOD_REQUEST)) WatchDataFormatted ("!UL !UL !&Z !UL !&Z\n", AlphaCount, HostDotCount, rqptr->rqHeader.HostPtr, ServiceDotCount, rqptr->ServicePtr->ServerHostPort); } #endif /* REDIRECT_WILDCARD */ #if REDIRECT_WILDCARD if (RedirectWildcardEnabled && AlphaCount && HostDotCount > ServiceDotCount) { /**********************/ /* wildcard DNS proxy */ /**********************/ /* At this stage the "Host:" field will look something like 'the.host.name.the.proxy.service:port' and the redirection URL '/https://the.proxy.service/http://the.host.name.the.proxy.service:port/path' We need to turn this into a proxy redirection looking like 'https://the.host.name/path'. */ sptr = RedirectionUrl + SchemeLength; if (*sptr && *sptr != '/') { /* count the number of periods 'the.proxy.service/' component */ StringDotCount = 0; for (cptr = sptr; *cptr && *cptr != '/'; cptr++) { if (*cptr != '.') continue; StringDotCount++; } /* possible but not desirable */ if (StringDotCount >= HostDotCount) StringDotCount = HostDotCount; /* find the start of the redirection URL path */ if (*cptr) cptr++; while (*cptr && *cptr != '/') cptr++; PathPtr = cptr; if (WATCHMOD (rqptr, WATCH_MOD_REQUEST)) WatchDataFormatted ("!UL !&Z !UL !&Z\n", HostDotCount, rqptr->rqHeader.HostPtr, StringDotCount, PathPtr); } else { StringDotCount = ServiceDotCount; PathPtr = RedirectionUrl + SchemeLength; } /* recreate the "Host:" field */ zptr = (sptr = HostField) + sizeof(HostField)-1; cptr = rqptr->rqHeader.HostPtr; while (HostDotCount-- > StringDotCount) { if (*cptr == '.') { if (sptr < zptr) *sptr++ = *cptr; cptr++; } while (*cptr && *cptr != '.') { if (sptr < zptr) *sptr++ = *cptr; cptr++; } } *sptr-- = '\0'; /* check if the last 'name' component was actually a 'port' */ while (sptr > HostField && isdigit(*sptr)) sptr--; /* if so change the period to a colon */ if (sptr > HostField && *sptr == '.') *sptr = ':'; if (WATCHMOD (rqptr, WATCH_MOD_REQUEST)) WatchDataFormatted ("!&Z\n", HostField); /* reserve space in redirection dictionary */ length = UrlLength + 256; denptr = DictInsert (dicptr, DICT_TYPE_INTERNAL, "request_line", 12, NULL, length); /* build request line directly in dictionary entry */ RequestLinePtr = DICT_GET_VALUE(denptr); zptr = (sptr = RequestLinePtr) + length; STRCAT (HttpMethodNamePtr) CHRCAT (' ') STRCAT (SchemePtr) STRCAT (HostField) STRCAT (PathPtr) } else #endif /* REDIRECT_WILDCARD */ { /**********************/ /* one-shot DNS proxy */ /**********************/ /* recreate the "Host:" field */ zptr = (sptr = HostField) + sizeof(HostField)-1; cptr = RedirectionUrl + SchemeLength; while (*cptr && *cptr != '/' && sptr < zptr) *sptr++ = *cptr++; *sptr = '\0'; if (WATCHMOD (rqptr, WATCH_MOD_REQUEST)) WatchDataFormatted ("!&Z\n", HostField); /* reserve space in redirection dictionary */ length = UrlLength + 256; denptr = DictInsert (dicptr, DICT_TYPE_INTERNAL, "request_line", 12, NULL, length); /* build request line directly in dictionary entry */ RequestLinePtr = DICT_GET_VALUE(denptr); zptr = (sptr = RequestLinePtr) + length; STRCAT (HttpMethodNamePtr) CHRCAT (' ') STRCAT (RedirectionUrl+1) } } else { /****************/ /* not to proxy */ /****************/ /* reserve space in redirection dictionary */ length = UrlLength + 256; denptr = DictInsert (dicptr, DICT_TYPE_INTERNAL, "request_line", 12, NULL, length); /* build request line directly in dictionary entry */ RequestLinePtr = DICT_GET_VALUE(denptr); zptr = (sptr = RequestLinePtr) + length; STRCAT (HttpMethodNamePtr) CHRCAT (' ') STRCAT (RedirectionUrl) } if (IncludeQueryString) { if (ConcatQueryString) CHRCAT ('&') STRCAT (rqptr->rqHeader.QueryStringPtr) } if (rqptr->rqResponse.HttpVersion == HTTP_VERSION_1_1) STRCAT (" HTTP/1.1") else STRCAT (" HTTP/1.0") /* complete the "request_line" dictionary entry */ RequestLineLength = sptr - RequestLinePtr; DictValueLength (denptr, RequestLineLength); /* add (with some massage) the original request's header fields */ DictIterate (rqptr->rqDictPtr, NULL); while (denptr = DictIterate (rqptr->rqDictPtr, DICT_TYPE_REQUEST)) { cptr = DICT_GET_KEY(denptr); if (TOUP(*cptr) == 'D' && strsame (cptr, "Destination:", 12)) { if (HostField[0]) { /* redirecting to proxy */ aptr = cptr + 12; while (*aptr && *aptr != '/') aptr++; if (*aptr && *(aptr+1) == '/') { aptr += 2; while (*aptr && *aptr != '/') aptr++; } /* reserve space in the dictionary then build value */ length = SchemeLength + strlen(HostField) + strlen(aptr); denptr = DictInsert (dicptr, DICT_TYPE_REQUEST, "destination", 11, NULL, length); zptr = (sptr = DICT_GET_VALUE (denptr)) + length; STRCAT (SchemePtr) STRCAT (HostField) STRCAT (aptr) continue; } } else if (TOUP(*cptr) == 'H' && strsame (cptr, "Host:", 5)) { if (HostField[0]) { /* redirecting to proxy */ DictInsert (dicptr, DICT_TYPE_REQUEST, "host", 4, HostField, -1); continue; } } /** TODO MGD 30-AUG-2005 **/ #if 0 else if (TOUP(*cptr) == 'R' && strsame (cptr, "Referer:", 8)) { /* too complex massaging "Referer:" when redirecting to proxy */ if (HostField[0]) continue; } #endif /* otherwise just include the field */ DictInsert (dicptr, DICT_TYPE_REQUEST, DICT_GET_KEY(denptr), DICT_GET_KEY_LEN(denptr), DICT_GET_VALUE(denptr), DICT_GET_VALUE_LEN(denptr)); } if (rqptr->rqHeader.HttpVersion == HTTP_VERSION_1_0) if (rqptr->PersistentRequest) DictInsert (dicptr, DICT_TYPE_REQUEST, "connection", 10, "keep-alive", 10); /* if generated by a CGI "Location:" */ if (rqptr->rqCgi.HeaderLength) { /* parse CGI response fields into the dictionary */ zptr = (cptr = rqptr->rqCgi.HeaderPtr) + rqptr->rqCgi.HeaderLength; while (cptr < zptr) { int klen, vlen; char *kptr, *vptr; for (kptr = cptr; *cptr != ':' && cptr < zptr; cptr++); if (cptr >= zptr) break; klen = cptr - kptr; for (++cptr; ISLWS(*cptr) && cptr < zptr; cptr++); if (cptr >= zptr) break; for (vptr = cptr; NOTEOL(*cptr) && cptr < zptr; cptr++); if (cptr >= zptr) break; vlen = cptr - vptr; while (ISLWS(*cptr) && cptr < zptr) cptr++; DictInsert (dicptr, DICT_TYPE_REQUEST, kptr, klen, vptr, vlen); } } /*******************/ /* request restart */ /*******************/ if (WATCHING (rqptr, WATCH_INTERNAL)) { WatchThis (WATCHITM(rqptr), WATCH_REQUEST, "REDIRECT dictionary before"); DictWatch (rqptr->rqDictPtr, NULL, "*"); } /* buffer anything that is necessary to retain after memset() */ BytesRx64 = rqptr->BytesRx64; ReadBufferPtr = rqptr->rqNet.ReadBufferPtr; ReadBufferSize = rqptr->rqNet.ReadBufferSize; /* including any directory meta entries from current to new */ DictIterate (rqptr->rqDictPtr, NULL); while (denptr = DictIterate (rqptr->rqDictPtr, DICT_TYPE_CONFIG)) { /* can only be done because the memory belongs to the same request */ DictExtractEntry (denptr); DictInsertEntry (dicptr, denptr); } /* and any notepad entry */ if (denptr = rqptr->NotePadDictEntry) { DictExtractEntry (denptr); DictInsertEntry (dicptr, denptr); } /* zero the portion of the request structure that is not persistent */ memset ((char*)&rqptr->ZeroedBegin, 0, (char*)&rqptr->ZeroedEnd - (char*)&rqptr->ZeroedBegin); /* re-timestamp the transaction */ sys$gettim (&rqptr->rqTime.BeginTime64); sys$numtim (&rqptr->rqTime.BeginTime7, &rqptr->rqTime.BeginTime64); HttpGmTimeString (rqptr->rqTime.GmDateTime, &rqptr->rqTime.BeginTime64); /* initialize the timer for input */ HttpdTimerSet (rqptr, TIMER_INPUT, 0); /* if available then set any initial report to be via the script */ if (rqptr->ServicePtr->ErrorReportPath[0]) rqptr->rqResponse.ErrorReportByRedirect = true; /* restore buffered stuff */ rqptr->BytesRx64 = BytesRx64; rqptr->rqNet.ReadBufferPtr = ReadBufferPtr; rqptr->rqNet.ReadBufferSize = ReadBufferSize; if (BodyCount) { /* restore body supplied with the request header */ memcpy (rqptr->rqNet.ReadBufferPtr, BodyPtr, BodyCount); rqptr->rqHeader.RequestBodyPtr = rqptr->rqNet.ReadBufferPtr; rqptr->rqHeader.RequestBodyCount = BodyCount; VmFreeFromHeap (rqptr, BodyPtr, FI_LI); rqptr->NetIoPtr->ReadCount = BodyCount; /* fudge the bytes received */ rqptr->BytesRx64 += BodyCount; rqptr->NetIoPtr->BytesRawRx64 += BodyCount; } /* destroy the current request dictionary */ DictDestroy (rqptr->rqDictPtr); /* use the redirect dictionary just built */ rqptr->rqDictPtr = dicptr; /* restore from when the entry was placed in the dictionary */ rqptr->rqHeader.RequestLinePtr = RequestLinePtr; rqptr->rqHeader.RequestLineLength = RequestLineLength; if (WATCHING (rqptr, WATCH_INTERNAL)) { WatchThis (WATCHITM(rqptr), WATCH_REQUEST, "REDIRECT dictionary after"); DictWatch (rqptr->rqDictPtr, NULL, "*"); } /* normal status indicates its a local redirection */ return (SS$_NORMAL); } else { /*************************/ /* non-local redirection */ /*************************/ InstanceGblSecIncrLong (&acptr->RedirectRemoteCount); /* there will three occasions the URL is used */ length = (UrlLength * 3) + (256 * 3); aptr = VmGetHeap (rqptr, length); zptr = (sptr = aptr) + length; /* begin building the textual (body) redirection information */ STRCAT (HttpStatusCodeText(302)); STRCAT (" <a href=\""); /* bit convoluted but it saves extra copying and stuff */ UrlPtr = sptr; /* note the start of the redirection URL */ if (MATCH3 (RedirectionUrl, "///")) { /* request scheme and host:port need to be supplied locally */ STRCAT (rqptr->ServicePtr->RequestSchemeNamePtr) STRCAT ("//") if (rqptr->rqHeader.HostPtr && rqptr->rqHeader.HostPtr[0]) STRCAT (rqptr->rqHeader.HostPtr) else STRCAT (rqptr->ServicePtr->ServerHostPort) STRCAT (RedirectionUrl+2) } else if (MATCH3 (RedirectionUrl, "//:")) { /* request scheme and host needs to be supplied locally */ STRCAT (rqptr->ServicePtr->RequestSchemeNamePtr) STRCAT ("//") if (rqptr->rqHeader.HostPtr && rqptr->rqHeader.HostPtr[0]) for (cptr = rqptr->rqHeader.HostPtr; *cptr && *cptr != ':' && sptr < zptr; *sptr++ = *cptr++); else STRCAT (rqptr->ServicePtr->ServerHostName); STRCAT (RedirectionUrl+2) } else if (MATCH2 (RedirectionUrl, "//")) { /* request scheme needs to be supplied locally */ STRCAT (rqptr->ServicePtr->RequestSchemeNamePtr) STRCAT (RedirectionUrl) } else if (MATCH8 (RedirectionUrl, "http:///") || MATCH8 (RedirectionUrl, "http://:")) { /* host needs to be supplied locally */ STRCAT ("http://") if (rqptr->rqHeader.HostPtr && rqptr->rqHeader.HostPtr[0]) for (cptr = rqptr->rqHeader.HostPtr; *cptr && *cptr != ':' && sptr < zptr; *sptr++ = *cptr++); else STRCAT (rqptr->ServicePtr->ServerHostName); STRCAT (RedirectionUrl+7) } else if (MATCH9 (RedirectionUrl, "https:///") || MATCH9 (RedirectionUrl, "https://:")) { /* host needs to be supplied locally */ STRCAT ("https://") if (rqptr->rqHeader.HostPtr && rqptr->rqHeader.HostPtr[0]) for (cptr = rqptr->rqHeader.HostPtr; *cptr && *cptr != ':' && sptr < zptr; *sptr++ = *cptr++); else STRCAT (rqptr->ServicePtr->ServerHostName) STRCAT (RedirectionUrl+8) } else { /* redirection contains full URL */ STRCAT (RedirectionUrl) } if (IncludeQueryString) { if (ConcatQueryString) CHRCAT ('&') STRCAT (rqptr->rqHeader.QueryStringPtr); } UrlEndPtr = sptr; /* note the end of the redirection URL */ STRCAT ("\">") for (cptr = UrlPtr; cptr < UrlEndPtr && sptr < zptr; *sptr++ = *cptr++); STRCAT ("</a>\n") *sptr = '\0'; length = sptr - aptr; /* now (somewhat shonkily) use remaining buffer for location header */ sptr++; for (cptr = "Location:"; *cptr && sptr < zptr; *sptr++ = *cptr++); for (cptr = UrlPtr; cptr < UrlEndPtr && sptr < zptr; *sptr++ = *cptr++); *sptr = '\0'; if (sptr >= zptr) ErrorNoticed (rqptr, SS$_BUFFEROVF, ErrorSanityCheck, FI_LI); ResponseHeader (rqptr, 302, "text/html", length, NULL, aptr+length+1); /* return response to client */ NetWrite (rqptr, &RequestEnd, aptr, length); /* indicate it's non-local redirection */ return (SS$_NONLOCAL); } #undef STRCAT #undef CHRCAT } /*****************************************************************************/