[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]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
[1230]
[1231]
[1232]
[1233]
[1234]
[1235]
[1236]
[1237]
[1238]
[1239]
[1240]
[1241]
[1242]
[1243]
[1244]
[1245]
[1246]
[1247]
[1248]
[1249]
[1250]
[1251]
[1252]
[1253]
[1254]
[1255]
[1256]
[1257]
[1258]
[1259]
[1260]
[1261]
[1262]
[1263]
[1264]
[1265]
[1266]
[1267]
[1268]
[1269]
[1270]
[1271]
[1272]
[1273]
[1274]
[1275]
[1276]
[1277]
[1278]
[1279]
[1280]
[1281]
[1282]
[1283]
[1284]
[1285]
[1286]
[1287]
[1288]
[1289]
[1290]
[1291]
[1292]
[1293]
[1294]
[1295]
[1296]
[1297]
[1298]
[1299]
[1300]
[1301]
[1302]
[1303]
[1304]
[1305]
[1306]
[1307]
[1308]
[1309]
[1310]
[1311]
[1312]
[1313]
[1314]
[1315]
[1316]
[1317]
[1318]
[1319]
[1320]
[1321]
[1322]
[1323]
[1324]
[1325]
[1326]
[1327]
[1328]
[1329]
[1330]
[1331]
[1332]
[1333]
[1334]
[1335]
[1336]
[1337]
[1338]
[1339]
[1340]
[1341]
[1342]
[1343]
[1344]
[1345]
[1346]
[1347]
[1348]
[1349]
[1350]
[1351]
[1352]
[1353]
[1354]
[1355]
[1356]
[1357]
[1358]
[1359]
[1360]
[1361]
[1362]
[1363]
[1364]
[1365]
[1366]
[1367]
[1368]
[1369]
[1370]
[1371]
[1372]
[1373]
[1374]
[1375]
[1376]
[1377]
[1378]
[1379]
[1380]
[1381]
[1382]
[1383]
[1384]
[1385]
[1386]
[1387]
[1388]
[1389]
[1390]
[1391]
[1392]
[1393]
[1394]
[1395]
[1396]
[1397]
[1398]
[1399]
[1400]
[1401]
[1402]
[1403]
[1404]
[1405]
[1406]
[1407]
[1408]
[1409]
[1410]
[1411]
[1412]
[1413]
[1414]
[1415]
[1416]
[1417]
[1418]
[1419]
[1420]
[1421]
[1422]
[1423]
[1424]
[1425]
[1426]
[1427]
[1428]
[1429]
[1430]
[1431]
[1432]
[1433]
[1434]
[1435]
[1436]
[1437]
[1438]
[1439]
[1440]
[1441]
[1442]
[1443]
[1444]
[1445]
[1446]
[1447]
[1448]
[1449]
[1450]
[1451]
[1452]
[1453]
[1454]
[1455]
[1456]
[1457]
[1458]
[1459]
[1460]
[1461]
/*****************************************************************************/
/*
ProxyNet.c
*************
** CAUTION **
*************
THIS MODULE IS TASK-ORIENTED, NOT REQUEST-ORIENTED.
That is, most of the functions take a pointer to proxy task rather than a
pointer to request as do other modules. The reason is simple. Many of these
functions are designed for use independently of a request.
This module provides the essential networking functionality for proxy
processing. It also maintains the pool of persistent proxy->origin server
connections.
VERSION HISTORY
---------------
27-APR-2021 MGD BSD 4.4 sockaddr.. IO$M_EXTEND to $QIO
19-JAN-2020 MGD more proxy persistent connection (per JPP)
11-AUG-2015 MGD restructure of network I/O abstractions
09-APR-2011 MGD ProxyNetLocalPort() for access logging purposes
08-NOV-2006 JPP bugfix; ProxyNetConnectPersist() rejects all further
requests once ProxyConnectPersistMax has been hit
04-JUL-2006 MGD use PercentOf32() for more accurate percentages
21-APR-2006 JPP client to origin server affinity
20-JUL-2005 JPP proxy to origin server failover
(support multiple IP addresses per name in the host cache)
09-JUN-2005 MGD bugfix; ProxyEnd(rqptr) should be ProxyEnd(tkptr) in
ProxyNetHostConnectAst() (jpp@esme.fr)
20-SEP-2004 MGD extracted functionality from PROXY.C
*/
/*****************************************************************************/
#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>
/* VMS related header files */
#include <descrip.h>
#include <dvidef.h>
#include <iodef.h>
#include <psldef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application-related header files */
#include "wasd.h"
#define WASD_MODULE "PROXYNET"
/******************/
/* global storage */
/******************/
int ProxyNetConnectCount,
ProxyNetConnectCountMax,
ProxyNetConnectFreeCount;
int64 ProxyNetConnectTimeoutDelta;
LIST_HEAD ProxyNetConnectList,
ProxyNetConnectFreeList;
/********************/
/* external storage */
/********************/
extern BOOL LoggingProxyLocalPort;
extern int EfnWait,
EfnNoWait,
HttpdTickSecond,
OptionEnabled,
ProxyConnectPersistMax,
ProxyConnectPersistSeconds,
ProxyConnectTimeoutSeconds;
extern int ToLowerCase[],
ToUpperCase[];
extern char ErrorSanityCheck[],
SoftwareID[];
extern struct dsc$descriptor TcpIpDeviceDsc;
extern ACCOUNTING_STRUCT *AccountingPtr;
extern PROXY_ACCOUNTING_STRUCT *ProxyAccountingPtr;
extern MSG_STRUCT Msgs;
extern TCP_SOCKET_ITEM TcpIpSocket4,
TcpIpSocket6;
extern VMS_ITEM_LIST2 ReuseAddress,
ReuseAddressSocketOption,
TcpIpFullDuplexCloseOption;
extern WATCH_STRUCT Watch;
/****************************************************************************/
/*
*/
ProxyNetInit ()
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_PROXY))
WatchThis (WATCHALL, WATCH_MOD_PROXY, "ProxyNetInit()");
if (ProxyConnectPersistMax < 0 || ProxyConnectPersistMax > 1000)
ProxyConnectPersistMax = 0;
if (ProxyConnectPersistSeconds < 0 || ProxyConnectPersistSeconds > 3600)
ProxyConnectPersistSeconds = 0;
if (ProxyConnectTimeoutSeconds < 0 || ProxyConnectTimeoutSeconds > 60)
ProxyConnectTimeoutSeconds = 0;
else
if (ProxyConnectTimeoutSeconds)
ProxyNetConnectTimeoutDelta = DELTA64_ONE_SEC *
ProxyConnectTimeoutSeconds;
ProxyNetConnectSupervisor (0);
}
/****************************************************************************/
/*
No need to resolve if this proxy server chains to another. Otherwise, allow
TcpIpNameToAddress() to asynchronously resolve the name or numeric address into
the IP address and then call ProxyNetHostConnect() when ready.
*/
ProxyNetResolveHost (PROXY_TASK *tkptr)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetResolveHost() !&Z", tkptr->RequestHostName);
if (IPADDRESS_IS_RESET (&tkptr->ChainIpAddress))
{
tkptr->ConnectPort = tkptr->RequestPort;
tkptr->ConnectHostPortPtr = tkptr->RequestHostPort;
if ((tkptr->ServicePtr->ProxyAffinity ||
tkptr->RequestPtr->rqPathSet.ProxyAffinity) &&
tkptr->RequestPtr->rqHeader.CookiePtr)
ProxyNetCheckAffinityCookie (tkptr);
else
TcpIpNameToAddress (&tkptr->HostLookup,
tkptr->RequestHostName,
tkptr->ProxyLookupRetryCount,
&ProxyNetHostConnect,
tkptr);
return;
}
/*********************************************************/
/* this proxy server requests from another proxy server! */
/*********************************************************/
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"HOST-PROXY-CHAIN !AZ", tkptr->ChainHostPortPtr);
tkptr->ConnectPort = tkptr->ChainIpPort;
tkptr->ConnectHostPortPtr = tkptr->ChainHostPortPtr;
tkptr->HostLookup.LookupIOsb.Status = SS$_NORMAL;
ProxyNetHostConnect (tkptr);
}
/****************************************************************************/
/*
Resolve host using TCP/IP lookup unless cookie indicates a preferred IP
address. Remove the affinity cookie from the cookie field. If that is the
only cookie data then remove the cookie field entirely from the request.
*/
ProxyNetCheckAffinityCookie (PROXY_TASK *tkptr)
{
int status,
RequestHostNameLength;
char ch;
char *cptr, *sptr, *zptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_PROXY))
WatchThis (WATCHALL, WATCH_MOD_PROXY, "ProxyNetCheckAffinityCookie()");
rqptr = tkptr->RequestPtr;
RequestHostNameLength = strlen(tkptr->RequestHostName);
cptr = rqptr->rqHeader.CookiePtr;
while (*cptr)
{
while (*cptr && *cptr != PROXY_AFFINITY_COOKIE_PREFIX[0]) cptr++;
if (!*cptr) break;
if (!MATCH0 (cptr, PROXY_AFFINITY_COOKIE_PREFIX,
sizeof(PROXY_AFFINITY_COOKIE_PREFIX)-1))
{
cptr++;
continue;
}
/* note start of affinity cookie */
sptr = cptr;
cptr += sizeof(PROXY_AFFINITY_COOKIE_PREFIX)-1;
if (MATCH0 (cptr, tkptr->RequestHostName, RequestHostNameLength))
{
cptr += RequestHostNameLength;
if (*cptr == '=')
{
for (zptr = ++cptr; *zptr && *zptr != ';'; zptr++);
ch = *zptr;
*zptr = '\0';
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"AFFINITY with !AZ", cptr);
tkptr->HostLookup.LookupIOsb.Status =
TcpIpStringToAddress (cptr, &tkptr->HostLookup.IpAddress);
*zptr = ch;
if (*zptr) zptr++;
while (*zptr && ISLWS(*zptr)) zptr++;
/* remove the affinity cookie */
while (*zptr) *sptr++ = *zptr++;
*sptr = '\0';
/* ensure it's not now an empty field */
for (cptr = rqptr->rqHeader.CookiePtr;
*cptr && ISLWS(*cptr);
cptr++);
if (!*cptr)
{
/* just an empty cookie jar! */
rqptr->rqHeader.CookiePtr = NULL;
DictRemove (rqptr->rqDictPtr, DICT_TYPE_REQUEST, "cookie", 6);
}
/* try to validate IP address from cache */
/* (prevents forged cookies that would allow open proxy) */
status = TcpIpCacheAddresstoName (&tkptr->HostLookup,
&tkptr->HostLookup.IpAddress);
if (VMSok(status))
{
if (!strcmp (tkptr->HostLookup.HostName,
tkptr->RequestHostName))
{
/* affinity cookie match */
tkptr->ProxyAffinityInUse = true;
ProxyNetHostConnect(tkptr);
return;
}
else
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"AFFINITY hint not correct");
}
else
{
/* not found in cache, try loading it only once */
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"AFFINITY hint not in cache");
if (!tkptr->ProxyAffinityInUse)
{
tkptr->ProxyAffinityInUse = true;
TcpIpNameToAddress (&tkptr->HostLookup,
tkptr->RequestHostName,
tkptr->ProxyLookupRetryCount,
&ProxyNetResolveHost,
tkptr);
return;
}
}
}
if (*cptr) cptr++;
}
}
/* no applicable affinity cookie present */
TcpIpNameToAddress (&tkptr->HostLookup,
tkptr->RequestHostName,
tkptr->ProxyLookupRetryCount,
&ProxyNetHostConnect,
tkptr);
}
/****************************************************************************/
/*
Called as an AST by TcpIpNameToAddress(). Check that the host name has been
resolved. If not report the error. Create a socket and attempt to connect to
the remote, proxied server host. AST to ProxyNetHostConnectAst().
*/
ProxyNetHostConnect (PROXY_TASK *tkptr)
{
static BOOL UseFullDuplexClose = true;
int qiofun, status;
unsigned long *gwcptr;
void *BindSocketNamePtr;
IO_SB IOsb;
REQUEST_STRUCT *rqptr;
SOCKADDRIN *sin4ptr;
SOCKADDRIN6 *sin6ptr;
TCP_SOCKET_ITEM *TcpSocketPtr;
VMS_ITEM_LIST2 *il2ptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetHostConnect() !&Z !&S",
tkptr->ConnectHostPortPtr,
tkptr->HostLookup.LookupIOsb.Status);
rqptr = tkptr->RequestPtr;
if (VMSnok (tkptr->HostLookup.LookupIOsb.Status))
{
/*********************************/
/* host address resolution error */
/*********************************/
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"HOST-LOOKUP !AZ !&S",
tkptr->RequestHostName,
tkptr->HostLookup.LookupIOsb.Status);
/* dispose of the non-connected channel/socket used for the lookup */
ProxyNetCloseSocket (tkptr);
tkptr->ResponseStatusCode = 502;
if (rqptr)
{
/* request associated with task */
rqptr->rqResponse.HttpStatus = 502;
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
if (tkptr->HostLookup.LookupIOsb.Status == SS$_ENDOFFILE)
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_PROXY_HOST_UNKNOWN), FI_LI);
else
ErrorVmsStatus (rqptr, tkptr->HostLookup.LookupIOsb.Status, FI_LI);
}
ProxyEnd (tkptr);
return;
}
/*****************/
/* host resolved */
/*****************/
IPADDRESS_COPY (&tkptr->RequestHostIpAddress, &tkptr->HostLookup.IpAddress)
/* if not chaining use resolved address, otherwise the specified chain */
if (IPADDRESS_IS_RESET (&tkptr->ChainIpAddress))
IPADDRESS_COPY (&tkptr->ConnectIpAddress, &tkptr->HostLookup.IpAddress)
else
IPADDRESS_COPY (&tkptr->ConnectIpAddress, &tkptr->ChainIpAddress)
if (ProxyConnectPersistMax)
{
/* search for an existing connection */
ProxyNetConnectSearch (tkptr);
if (tkptr->NetIoPtr->Channel)
{
/***************************************/
/* persistent proxy->origin connection */
/***************************************/
/* peek to ensure it's still connected and there's nothing buffered */
static char ThrowAwayBuffer [1];
status = sys$qio (EfnNoWait, tkptr->NetIoPtr->Channel,
IO$_READVBLK,
&tkptr->ProxyConnectIOsb,
&ProxyNetHostConnectAst, tkptr,
ThrowAwayBuffer, sizeof(ThrowAwayBuffer),
0, TCPIP$C_MSG_PEEK|TCPIP$C_MSG_NBIO, 0, 0);
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->ProxyConnectIOsb.Status = status;
SysDclAst (ProxyNetHostConnectAst, tkptr);
}
return;
}
}
/*******************/
/* connect to host */
/*******************/
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"CONNECT !&I,!UL as !&I", &tkptr->ConnectIpAddress,
tkptr->ConnectPort, &tkptr->BindIpAddress);
tkptr->ConnectionCount = 1;
/* assign a channel to the internet template device */
status = sys$assign (&TcpIpDeviceDsc, &tkptr->NetIoPtr->Channel, 0, 0);
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->ProxyConnectIOsb.Status = status;
SysDclAst (ProxyNetHostConnectAst, tkptr);
return;
}
if (IPADDRESS_IS_SET (&tkptr->BindIpAddress))
{
/* bind the proxy socket to a specific IP address */
if (IPADDRESS_IS_V4 (&tkptr->BindIpAddress))
{
SOCKADDRESS_ZERO4 (&tkptr->ProxyBindSocketName)
sin4ptr = &tkptr->ProxyBindSocketName.sa.v4;
sin4ptr->SIN$B_FAMILY = TCPIP$C_AF_INET;
sin4ptr->SIN$W_PORT = 0;
IPADDRESS_SET4 (&sin4ptr->SIN$L_ADDR, &tkptr->BindIpAddress)
il2ptr = &tkptr->ProxyBindSocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN);
il2ptr->item = 0;
il2ptr->buf_addr = sin4ptr;
}
else
if (IPADDRESS_IS_V6 (&tkptr->BindIpAddress))
{
SOCKADDRESS_ZERO6 (&tkptr->ProxyBindSocketName)
sin6ptr = &tkptr->ProxyBindSocketName.sa.v6;
sin6ptr->SIN6$B_FAMILY = TCPIP$C_AF_INET6;
sin6ptr->SIN6$W_PORT = 0;
IPADDRESS_SET6 (sin6ptr->SIN6$R_ADDR_OVERLAY.SIN6$T_ADDR,
&tkptr->BindIpAddress)
il2ptr = &tkptr->ProxyBindSocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN);
il2ptr->item = 0;
il2ptr->buf_addr = sin6ptr;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
BindSocketNamePtr = (void*)il2ptr;
}
else
BindSocketNamePtr = 0;
if (IPADDRESS_IS_V4 (&tkptr->ConnectIpAddress))
{
TcpSocketPtr = &TcpIpSocket4;
qiofun = IO$_SETMODE;
}
else
if (IPADDRESS_IS_V6 (&tkptr->ConnectIpAddress))
{
TcpSocketPtr = &TcpIpSocket6;
qiofun = IO$_SETMODE | IO$M_EXTEND;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
/* make the channel a TCP, connection-oriented socket */
for (;;)
{
status = sys$qiow (EfnWait, tkptr->NetIoPtr->Channel,
qiofun, &tkptr->ProxyConnectIOsb, 0, 0,
TcpSocketPtr, 0, BindSocketNamePtr,
0, UseFullDuplexClose ?
&TcpIpFullDuplexCloseOption : 0, 0);
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY, "sys$qiow() !&S !&S",
status, tkptr->ProxyConnectIOsb.Status);
if (VMSok (status) && VMSok (tkptr->ProxyConnectIOsb.Status)) break;
if (!UseFullDuplexClose) break;
UseFullDuplexClose = false;
/* Multinet 3.2 UCX driver barfs on FULL_DUPLEX_CLOSE, try without */
if (VMSok (status) && VMSnok (tkptr->ProxyConnectIOsb.Status))
{
/* assign a new channel before retrying */
sys$dassgn (tkptr->NetIoPtr->Channel);
status = sys$assign (&TcpIpDeviceDsc, &tkptr->NetIoPtr->Channel, 0, 0);
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->ProxyConnectIOsb.Status = status;
SysDclAst (ProxyNetHostConnectAst, tkptr);
return;
}
}
}
/* it's a $QIOW so the IO status block is valid */
if (VMSok (status) && VMSnok (tkptr->ProxyConnectIOsb.Status))
status = tkptr->ProxyConnectIOsb.Status;
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->ProxyConnectIOsb.Status = status;
SysDclAst (ProxyNetHostConnectAst, tkptr);
return;
}
if (IPADDRESS_IS_V4 (&tkptr->ConnectIpAddress))
{
SOCKADDRESS_ZERO4 (&tkptr->ProxySocketName);
sin4ptr = &tkptr->ProxySocketName.sa.v4;
sin4ptr->SIN$B_FAMILY = TCPIP$C_AF_INET;
sin4ptr->SIN$W_PORT = htons (tkptr->ConnectPort);
IPADDRESS_SET4 (&sin4ptr->SIN$L_ADDR, &tkptr->ConnectIpAddress)
il2ptr = &tkptr->ProxySocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN);
il2ptr->item = TCPIP$C_SOCK_NAME;
il2ptr->buf_addr = sin4ptr;
qiofun = IO$_ACCESS;
}
else
if (IPADDRESS_IS_V6 (&tkptr->ConnectIpAddress))
{
SOCKADDRESS_ZERO6 (&tkptr->ProxySocketName);
sin6ptr = &tkptr->ProxySocketName.sa.v6;
sin6ptr->SIN6$B_FAMILY = TCPIP$C_AF_INET6;
sin6ptr->SIN6$W_PORT = htons (tkptr->ConnectPort);
IPADDRESS_SET6 (sin6ptr->SIN6$R_ADDR_OVERLAY.SIN6$T_ADDR,
&tkptr->ConnectIpAddress)
il2ptr = &tkptr->ProxySocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN6);
il2ptr->item = TCPIP$C_SOCK_NAME;
il2ptr->buf_addr = sin6ptr;
qiofun = IO$_ACCESS | IO$M_EXTEND;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (ProxyConnectTimeoutSeconds)
{
status = sys$setimr (0, &ProxyNetConnectTimeoutDelta,
&ProxyNetHostConnectTimeoutAst, tkptr, 0);
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->ProxyConnectIOsb.Status = status;
SysDclAst (ProxyNetHostConnectAst, tkptr);
return;
}
}
status = sys$qio (EfnNoWait, tkptr->NetIoPtr->Channel, qiofun,
&tkptr->ProxyConnectIOsb, &ProxyNetHostConnectAst, tkptr,
0, 0, &tkptr->ProxySocketNameItem, 0, 0, 0);
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->ProxyConnectIOsb.Status = status;
SysDclAst (ProxyNetHostConnectAst, tkptr);
return;
}
}
/****************************************************************************/
/*
Called as an AST from ProxyNetHostConnect(). The remote host didn't respond.
*/
ProxyNetHostConnectTimeoutAst (PROXY_TASK *tkptr)
{
sys$cancel (tkptr->NetIoPtr->Channel);
tkptr->ProxyConnectIOsb.Status = SS$_TIMEOUT;
}
/****************************************************************************/
/*
Called as an AST from ProxyNetHostConnect(). The remote server host connect
attempt has completed and either been successful or returned an error status.
If an error then explain it and end proxy processing. If successful then begin
processing the request scheme.
*/
ProxyNetHostConnectAst (PROXY_TASK *tkptr)
{
int status;
char *cptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetHostConnectAst() !&F !&Z !&S", ProxyNetHostConnectAst,
tkptr->ConnectHostPortPtr, tkptr->ProxyConnectIOsb.Status);
/* First cancel the host connection timer */
sys$cantim (tkptr,0);
rqptr = tkptr->RequestPtr;
if (tkptr->ConnectionCount > 1)
{
/***************************************/
/* persistent proxy->origin connection */
/***************************************/
/* of course shouldn't be able to read anything at all at this stage!! */
if (VMSnok (tkptr->ProxyConnectIOsb.Status))
{
if (tkptr->ProxyConnectIOsb.Status == SS$_SUSPENDED)
{
/* this means the non-blocking peek found nothing buffered */
tkptr->ProxyConnectIOsb.Status = SS$_NORMAL;
}
else
{
/* assume just a remote disconnection, close and restart */
ProxyNetCloseSocket (tkptr);
ProxyNetHostConnect (tkptr);
return;
}
}
else
{
/* so now that we did consider it an error, close and restart */
ProxyNetCloseSocket (tkptr);
ProxyNetHostConnect (tkptr);
return;
}
}
/*************************/
/* IP version accounting */
/*************************/
/* after any connection persistence has been taken into account */
if (IPADDRESS_IS_V4 (&tkptr->ConnectIpAddress))
{
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
ProxyAccountingPtr->ConnectIpv4Count++;
/* [ipv4=0,ipv6=1][ipv4=0,ipv6=1] */
if (IPADDRESS_IS_V4 (&tkptr->ServicePtr->ServerIpAddress))
ProxyAccountingPtr->GatewayIpvCount[0][0]++;
else
ProxyAccountingPtr->GatewayIpvCount[1][0]++;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
else
if (IPADDRESS_IS_V6 (&tkptr->ConnectIpAddress))
{
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
ProxyAccountingPtr->ConnectIpv6Count++;
/* [ipv4=0,ipv6=1][ipv4=0,ipv6=1] */
if (IPADDRESS_IS_V4 (&tkptr->ServicePtr->ServerIpAddress))
ProxyAccountingPtr->GatewayIpvCount[0][1]++;
else
ProxyAccountingPtr->GatewayIpvCount[1][1]++;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (VMSnok (tkptr->ProxyConnectIOsb.Status))
{
/*****************/
/* connect error */
/*****************/
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_PROXY,
"CONNECT !&S", tkptr->ProxyConnectIOsb.Status);
/* dispose of the non-connected channel/socket used for the lookup */
ProxyNetCloseSocket (tkptr);
/* if we have some affinity hint, use it */
if (tkptr->ProxyAffinityInUse)
{
ProxyNetResolveHost (tkptr);
return;
}
/* invalidate any entry (still) in the host name/address cache */
IPADDRESS_SET_UNUSABLE (&tkptr->HostLookup.IpAddress);
TcpIpCacheSetEntry (&tkptr->HostLookup);
/* if we have an other address cached for this host, retry */
status = TcpIpCacheNameToAddress (&tkptr->HostLookup,
tkptr->RequestHostName,
strlen(tkptr->RequestHostName));
if (VMSok(status))
{
ProxyNetHostConnect (tkptr);
return;
}
tkptr->ResponseStatusCode = 502;
if (rqptr->ServicePtr->ProxyTunnel == PROXY_TUNNEL_RAW ||
rqptr->ServicePtr->ProxyTunnel == PROXY_TUNNEL_FIREWALL)
{
/* can end up here with chained CONNECT requests */
ProxyEnd (tkptr);
return;
}
if (rqptr)
{
/* request associated with task */
rqptr->rqResponse.HttpStatus = 502;
switch (tkptr->ProxyConnectIOsb.Status)
{
case PROXY_ERROR_CONNECT_REFUSED :
if (IPADDRESS_IS_SET (&tkptr->ChainIpAddress))
cptr = MsgFor(rqptr,MSG_PROXY_CHAIN_REFUSED);
else
cptr = MsgFor(rqptr,MSG_PROXY_CONNECT_REFUSED);
if (rqptr->rqHeader.UpgradeSocks5Ptr)
ProxySocks5Reply (rqptr, SOCKS5_REPLY_REFUSED);
else
ErrorGeneral (rqptr, cptr, FI_LI);
break;
case PROXY_ERROR_HOST_UNREACHABLE :
if (IPADDRESS_IS_SET (&tkptr->ChainIpAddress))
cptr = MsgFor(rqptr,MSG_PROXY_CHAIN_UNREACHABLE);
else
cptr = MsgFor(rqptr,MSG_PROXY_HOST_UNREACHABLE);
if (rqptr->rqHeader.UpgradeSocks5Ptr)
ProxySocks5Reply (rqptr, SOCKS5_REPLY_HOSTREACH);
else
ErrorGeneral (rqptr, cptr, FI_LI);
break;
case PROXY_ERROR_HOST_TIMEOUT :
if (IPADDRESS_IS_SET (&tkptr->ChainIpAddress))
cptr = MsgFor(rqptr,MSG_PROXY_CHAIN_UNREACHABLE);
else
cptr = MsgFor(rqptr,MSG_PROXY_HOST_UNREACHABLE);
if (rqptr->rqHeader.UpgradeSocks5Ptr)
ProxySocks5Reply (rqptr, SOCKS5_REPLY_HOSTREACH);
else
ErrorGeneral (rqptr, cptr, FI_LI);
break;
default :
if (IPADDRESS_IS_SET (&tkptr->ChainIpAddress))
{
rqptr->rqResponse.ErrorTextPtr =
MsgFor(rqptr,MSG_PROXY_CHAIN_FAILURE);
rqptr->rqResponse.ErrorOtherTextPtr =
tkptr->ChainHostPortPtr;
}
else
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
if (rqptr->rqHeader.UpgradeSocks5Ptr)
ProxySocks5Reply (rqptr, SOCKS5_REPLY_FAILURE);
else
ErrorVmsStatus (rqptr, tkptr->ProxyConnectIOsb.Status, FI_LI);
}
}
ProxyEnd (tkptr);
return;
}
if (LoggingProxyLocalPort)
rqptr->ProxyLocalPort = ProxyNetLocalPort (tkptr);
/* it's successful if the remote host accepts it */
if (rqptr) rqptr->rqResponse.HttpStatus = 200;
/* once we start reading into the buffer the request header is kaput */
rqptr->rqHeader.RequestHeaderPtrInvalid = true;
if (tkptr->ProxyTunnel)
{
/**************/
/* tunnelling */
/**************/
if (IPADDRESS_IS_SET (&tkptr->ChainIpAddress))
ProxyTunnelChainConnect (tkptr);
else
if (tkptr->ProxyTunnel == PROXY_TUNNEL_HTTPS)
SesolaNetClientBegin (tkptr);
else
ProxyTunnelBegin (tkptr);
return;
}
/*************************************/
/* HTTP "GET", "POST", etc., methods */
/*************************************/
/* if affinity required and wasn't previouly set, do it now */
if ((tkptr->ServicePtr->ProxyAffinity ||
rqptr->rqPathSet.ProxyAffinity) &&
!tkptr->ProxyAffinityInUse)
ProxyNetSetAffinityCookie (tkptr);
if (tkptr->ConnectPort == DEFAULT_HTTPS_PORT ||
tkptr->RequestScheme == PROXY_SCHEME_HTTPSSL)
{
if (tkptr->ServicePtr->SSLclientEnabled)
{
if (tkptr->ConnectionCount > 1)
ProxyWriteRequest (tkptr);
else
SesolaNetClientBegin (tkptr);
}
else
{
if (WATCHING (rqptr, WATCH_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_PROXY,
"CLIENT SSL not configured");
rqptr->rqResponse.HttpStatus = 503;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_PROXY_GATEWAY), FI_LI);
ProxyEnd (tkptr);
return;
}
}
else
if (tkptr->RequestScheme == PROXY_SCHEME_HTTP)
ProxyWriteRequest (tkptr);
else
if (tkptr->RequestScheme == PROXY_SCHEME_FTP)
ProxyFtpLifeCycle (tkptr);
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
/*****************************************************************************/
/*
Get the local port of the outgoing connection (only for access log purposes).
*/
int ProxyNetLocalPort (PROXY_TASK *tkptr)
{
int qiofun, status,
SocketNameLength;
IO_SB IOsb;
REQUEST_STRUCT *rqptr;
SOCKADDRESS SocketName;
VMS_ITEM_LIST3 SocketNameItem;
VMS_ITEM_LIST3 *il3ptr;
/*********/
/* begin */
/*********/
rqptr = tkptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_PROXY, "ProxyNetLocalPort()");
il3ptr = &SocketNameItem;
if (IPADDRESS_IS_V4 (&tkptr->ConnectIpAddress))
{
il3ptr->buf_len = sizeof(SOCKADDRIN);
il3ptr->item = 0;
il3ptr->buf_addr = &SocketName.sa.v4;
il3ptr->ret_len = &SocketNameLength;
qiofun = IO$_SENSEMODE;
}
else
if (IPADDRESS_IS_V6 (&tkptr->ConnectIpAddress))
{
il3ptr->buf_len = sizeof(SOCKADDRIN6);
il3ptr->item = 0;
il3ptr->buf_addr = &SocketName.sa.v6;
il3ptr->ret_len = &SocketNameLength;
qiofun = IO$_SENSEMODE | IO$M_EXTEND;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
status = sys$qiow (EfnWait, tkptr->NetIoPtr->Channel,
qiofun, &IOsb, 0, 0, 0, 0, il3ptr, 0, 0, 0);
if (VMSok (status)) status = IOsb.Status;
if (VMSnok (status))
{
ErrorNoticed (rqptr, status, "ProxyNetLocalPort()", FI_LI);
return (0);
}
if (IPADDRESS_IS_V4 (&tkptr->ConnectIpAddress))
return (ntohs(SocketName.sa.v4.SIN$W_PORT));
else
return (ntohs(SocketName.sa.v6.SIN6$W_PORT));
}
/*****************************************************************************/
/*
Create a proxy cookie to set client affinity to the origin server.
*/
ProxyNetSetAffinityCookie (PROXY_TASK *tkptr)
{
int idx;
unsigned short Length;
char *cptr;
char Buffer [256];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = tkptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_PROXY, "ProxyNetSetAffinityCookie()");
/* set proxy preferred origin server cookie */
FaoToBuffer (Buffer, sizeof(Buffer), &Length, "!AZ!AZ=!&I; path=/;",
PROXY_AFFINITY_COOKIE_PREFIX, tkptr->RequestHostName,
&tkptr->ConnectIpAddress);
cptr = VmGetHeap (rqptr, Length+1);
for (idx = 0; idx < RESPONSE_COOKIE_MAX; idx++)
{
if (!rqptr->rqResponse.CookiePtr[idx])
{
memcpy (rqptr->rqResponse.CookiePtr[idx] = cptr, Buffer, Length+1);
break;
}
}
if (WATCHING (rqptr, WATCH_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_PROXY, "AFFINITY cookie set to !&I",
&tkptr->ConnectIpAddress);
}
/*****************************************************************************/
/*
Wrapper for AST parameter |tkptr|.
*/
int ProxyNetWrite
(
PROXY_TASK *tkptr,
PROXY_AST AstFunction,
char *DataPtr,
int DataLength
)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetWrite() !&F !&A !&X !UL", &ProxyNetWrite,
AstFunction, DataPtr, DataLength);
return (NetIoWrite (tkptr->NetIoPtr, AstFunction, tkptr,
DataPtr, DataLength));
}
/*****************************************************************************/
/*
Wrapper for AST parameter |tkptr|.
*/
int ProxyNetRead
(
PROXY_TASK *tkptr,
PROXY_AST AstFunction,
char *DataPtr,
int DataSize
)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetRead() !&F !&A !&X !UL", &ProxyNetRead,
AstFunction, DataPtr, DataSize);
return (NetIoRead (tkptr->NetIoPtr, AstFunction, tkptr, DataPtr, DataSize));
}
/****************************************************************************/
/*
Just shut the socket down, bang!
*/
int ProxyNetCloseSocket (PROXY_TASK *tkptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetCloseSocket() !&F", &ProxyNetCloseSocket);
if (!tkptr->NetIoPtr) return (SS$_NORMAL);
if (!tkptr->NetIoPtr->Channel) return (SS$_NORMAL);
status = sys$dassgn (tkptr->NetIoPtr->Channel);
tkptr->NetIoPtr->Channel = 0;
if (WATCHING (tkptr, WATCH_PROXY))
{
if (VMSok(status))
WatchThis (WATCHITM(tkptr), WATCH_PROXY, "CLOSE !AZ,!UL",
tkptr->RequestHostName, tkptr->RequestPort);
else
WatchThis (WATCHITM(tkptr), WATCH_PROXY, "CLOSE !AZ,!UL !&S",
tkptr->RequestHostName, tkptr->RequestPort, status);
}
return (status);
}
/*****************************************************************************/
/*
*/
BOOL ProxyNetInProgress (PROXY_TASK *tkptr)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetInProgress() inprog:!&B body:!&B",
NETIO_IN_PROGRESS (tkptr->NetIoPtr), tkptr->QueuedBodyRead);
if (NETIO_IN_PROGRESS (tkptr->NetIoPtr)) return (true);
if (tkptr->QueuedBodyRead) return (true);
return (false);
}
/****************************************************************************/
/*
Create a persistent connection structure (using process memory) and add it to
the list. Copy the channel number from the proxy task socket into the
structure (zeroing the task channel), along with the IP address and port of the
connection.
*/
ProxyNetConnectPersist (PROXY_TASK *tkptr)
{
int status;
PROXY_CONNECT *pcptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetConnectPersist() !&I,!UL !UL",
&tkptr->ConnectIpAddress, tkptr->ConnectPort,
tkptr->ConnectionCount);
if (ProxyNetConnectFreeCount &&
ProxyNetConnectCount >= ProxyConnectPersistMax)
{
InstanceGblSecIncrLong (&ProxyAccountingPtr->ConnectPersistFull);
return;
}
if (pcptr = ProxyNetConnectFreeList.HeadPtr)
{
ListRemove (&ProxyNetConnectFreeList, pcptr);
memset (pcptr, 0, sizeof(PROXY_CONNECT));
if (ProxyNetConnectFreeCount) ProxyNetConnectFreeCount--;
}
else
pcptr = (PROXY_CONNECT*)VmGet(sizeof(PROXY_CONNECT));
/* move the network I/O structure from the task */
pcptr->NetIoPtr = tkptr->NetIoPtr;
tkptr->NetIoPtr = NULL;
pcptr->SSLclientEnabled = tkptr->ServicePtr->SSLclientEnabled;
pcptr->EntryTickSecond = HttpdTickSecond;
IPADDRESS_COPY (&pcptr->ConnectIpAddress, &tkptr->ConnectIpAddress);
pcptr->ConnectPort = tkptr->ConnectPort;
pcptr->ConnectionCount = tkptr->ConnectionCount;
ListAddTail (&ProxyNetConnectList, pcptr, LIST_ENTRY_TYPE_PROXY);
ProxyNetConnectCount++;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
if (ProxyNetConnectCount > ProxyAccountingPtr->ConnectPersistPeak)
ProxyAccountingPtr->ConnectPersistPeak = ProxyNetConnectCount;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
/****************************************************************************/
/*
Search through any list of persistent connections comparing the requests IP
address and port to that stored in each list entry. If one matched copy the
channel and persistence count to the proxy task and remove the entry from the
list. Returns with the task connection socket channel non-zero if it found a
match or still as zero if not.
*/
ProxyNetConnectSearch (PROXY_TASK *tkptr)
{
int status;
LIST_ENTRY *leptr;
PROXY_CONNECT *pcptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyNetConnectSearch() !&I,!UL !UL",
&tkptr->ConnectIpAddress, tkptr->ConnectPort,
ProxyNetConnectCount);
/* important these be zeroed to indicate search failure */
tkptr->NetIoPtr->Channel = tkptr->ConnectionCount = 0;
if (!ProxyNetConnectCount) return;
for (leptr = ProxyNetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
pcptr = (PROXY_CONNECT*)leptr;
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY, "!&I,!UL !UL !UL !&B !&B",
&pcptr->ConnectIpAddress, pcptr->ConnectPort,
pcptr->ConnectionCount,
pcptr->NetIoPtr->Channel,
pcptr->SSLclientEnabled,
tkptr->ServicePtr->SSLclientEnabled);
if (!IPADDRESS_IS_SAME (&pcptr->ConnectIpAddress,
&tkptr->ConnectIpAddress)) continue;
if (pcptr->ConnectPort != tkptr->ConnectPort) continue;
if (pcptr->SSLclientEnabled !=
tkptr->ServicePtr->SSLclientEnabled) continue;
/*******/
/* hit */
/*******/
/* move the network I/O structure to the task */
tkptr->NetIoPtr = pcptr->NetIoPtr;
pcptr->NetIoPtr;
if (tkptr->NetIoPtr->SesolaPtr)
SesolaNetSetProxyTask (tkptr);
tkptr->ConnectionCount = pcptr->ConnectionCount + 1;
ListRemove (&ProxyNetConnectList, pcptr);
if (ProxyNetConnectCount) ProxyNetConnectCount--;
ListAddTail (&ProxyNetConnectFreeList, pcptr, LIST_ENTRY_TYPE_PROXY);
ProxyNetConnectFreeCount++;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
ProxyAccountingPtr->ConnectPersistCount++;
if (tkptr->ConnectionCount > ProxyAccountingPtr->ConnectPersistMax)
ProxyAccountingPtr->ConnectPersistMax = tkptr->ConnectionCount;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"PERSISTENT !UL !AZ,!UL",
tkptr->ConnectionCount,
tkptr->RequestHostName, tkptr->RequestPort);
return;
}
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY, "NOT FOUND");
}
/****************************************************************************/
/*
Called by HttpdTick() once a second. Scan the list of persistent proxy->origin
connections looking for those that have timed-out. For each timeout just close
the socket by deassigning the channel and remove and free the entry from the
list. If 'TimeoutSeconds' is negative use the configuration parameter. If
zero then timeout all of the connections (purge the list). If a positive
integer use this as the timeout period.
*/
int ProxyNetConnectSupervisor (int TimeoutPeriod)
{
int status,
TimeoutSeconds;
LIST_ENTRY *leptr;
PROXY_CONNECT *pcptr;
/*********/
/* begin */
/*********/
/**
if (WATCH_MODULE(WATCH_MOD_PROXY))
WatchThis (WATCHALL, WATCH_MOD_PROXY,
"ProxyNetConnectSupervisor() !SL !UL !UL !UL",
TimeoutPeriod, ProxyConnectPersistSeconds,
HttpdTickSecond, ProxyNetConnectCount);
**/
if (!ProxyNetConnectCount) return (false);
if (!TimeoutPeriod)
TimeoutSeconds = 0;
else
if (TimeoutPeriod < 0)
TimeoutSeconds = ProxyConnectPersistSeconds;
else
TimeoutSeconds = TimeoutPeriod;
for (leptr = ProxyNetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
pcptr = (PROXY_CONNECT*)leptr;
if (WATCH_MODULE(WATCH_MOD_PROXY))
WatchThis (WATCHALL, WATCH_MOD_PROXY,
"!&I,!UL !UL+!UL(!&B) !UL !UL",
&pcptr->ConnectIpAddress, pcptr->ConnectPort,
pcptr->EntryTickSecond, TimeoutSeconds,
pcptr->EntryTickSecond + TimeoutSeconds <= HttpdTickSecond,
pcptr->ConnectionCount,
pcptr->NetIoPtr->Channel);
if (pcptr->EntryTickSecond + TimeoutSeconds < HttpdTickSecond)
{
if (pcptr->NetIoPtr)
{
NetIoEnd (pcptr->NetIoPtr);
pcptr->NetIoPtr = NULL;
}
ListRemove (&ProxyNetConnectList, pcptr);
if (ProxyNetConnectCount) ProxyNetConnectCount--;
ListAddTail (&ProxyNetConnectFreeList, pcptr, LIST_ENTRY_TYPE_PROXY);
ProxyNetConnectFreeCount++;
}
}
if (ProxyNetConnectCount) return (true);
return (false);
}
/*****************************************************************************/
/*
Return a report on proxy->origin server persistent connections.
*/
ProxyNetPersistentReport (REQUEST_STRUCT *rqptr)
{
static char BeginPageFao [] =
"<p><table class=\"ctgry\">\n\
<tr><td>\n\
<table class=\"rghtlft\">\n\
<tr><th>Persist:</th><td colspan=\"2\">!AZ</td></tr>\n\
<tr><th>Limit:</th><td>!UL</td></tr>\n\
<tr><th>Current:</th>\
<td>!UL</td><td>(!UL)</td></tr>\n\
<tr><th>Full:</th><td>!UL</td></tr>\n\
<tr><th>Peak:</th><td>!UL</td></tr>\n\
<tr><th>Max:</th><td>!UL</td></tr>\n\
<tr><th>Count:</th>\
<td>!UL</td><td>(!UL%)</td></tr>\n\
</table>\n\
</td></tr>\n\
</table>\n\
\
<p><table class=\"rghtrght\">\n\
<tr>\
<th></th>\
<th class=\"sbttl\">Address</th>\
<th class=\"sbttl\">Port</th>\
<th class=\"sbttl\">Count</th>\
<th class=\"sbttl\">Persist</th>\
</tr>\n";
static char ItemFao [] =
"<tr class=\"hlght\"><th>!3ZL</th>\
<td class=\"talft\">!&I</td>\
<td>!UL</td>\
<td>!UL</td>\
<td>!AZ</td>\
<tr>\n";
static char ItemOddFao [] =
"<tr><th>!3ZL</th>\
<td class=\"talft\">!&I </td>\
<td>!UL</td>\
<td>!UL</td>\
<td>!AZ</td>\
<tr>\n";
static char EmptyListFao [] =
"<tr class=\"hlght\"><th>000</th>\
<td class=\"talft\" colspan=\"4\"><i>empty</i></td><tr>\n";
static char EndPageFao [] =
"</table>\n\
!AZ\
</div>\n\
</body>\n\
</html>\n";
int status,
CountItem;
unsigned short Length;
unsigned long FaoVector [32];
unsigned long *vecptr;
LIST_ENTRY *leptr;
PROXY_CONNECT *pcptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_PROXY,
"ProxyNetPersistentReport()");
AdminPageTitle (rqptr, "Proxy Connection Report");
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
vecptr = FaoVector;
*vecptr++ = MetaConShowSeconds (rqptr, ProxyConnectPersistSeconds);
*vecptr++ = ProxyConnectPersistMax;
*vecptr++ = ProxyNetConnectCount;
*vecptr++ = ProxyNetConnectFreeCount;
*vecptr++ = ProxyAccountingPtr->ConnectPersistFull;
*vecptr++ = ProxyAccountingPtr->ConnectPersistPeak;
*vecptr++ = ProxyAccountingPtr->ConnectPersistMax;
*vecptr++ = ProxyAccountingPtr->ConnectPersistCount;
*vecptr++ = PercentOf32 (ProxyAccountingPtr->ConnectPersistCount,
ProxyAccountingPtr->ConnectIpv4Count +
ProxyAccountingPtr->ConnectIpv6Count);
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
status = FaolToNet (rqptr, BeginPageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
CountItem = 0;
for (leptr = ProxyNetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
pcptr = (PROXY_CONNECT*)leptr;
vecptr = FaoVector;
*vecptr++ = ++CountItem;
*vecptr++ = &pcptr->ConnectIpAddress;
*vecptr++ = pcptr->ConnectPort;
*vecptr++ = pcptr->ConnectionCount;
*vecptr++ = MetaConShowSeconds (rqptr,
HttpdTickSecond - pcptr->EntryTickSecond);
if (CountItem & 1)
status = FaolToNet (rqptr, ItemOddFao, &FaoVector);
else
status = FaolToNet (rqptr, ItemFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
if (!ProxyNetConnectList.HeadPtr)
{
status = FaolToNet (rqptr, EmptyListFao, NULL);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
status = FaoToNet (rqptr, EndPageFao, AdminRefresh());
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
rqptr->rqResponse.PreExpired = PRE_EXPIRE_ADMIN;
ResponseHeader200 (rqptr, "text/html", &rqptr->NetWriteBufferDsc);
AdminEnd (rqptr);
}
/****************************************************************************/