[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]
[1462]
[1463]
[1464]
[1465]
[1466]
[1467]
[1468]
[1469]
[1470]
[1471]
[1472]
[1473]
[1474]
[1475]
[1476]
[1477]
[1478]
[1479]
[1480]
[1481]
[1482]
[1483]
[1484]
[1485]
[1486]
[1487]
[1488]
[1489]
[1490]
[1491]
[1492]
[1493]
[1494]
[1495]
[1496]
[1497]
[1498]
[1499]
[1500]
[1501]
[1502]
[1503]
[1504]
[1505]
[1506]
[1507]
[1508]
[1509]
[1510]
[1511]
[1512]
[1513]
[1514]
[1515]
[1516]
[1517]
[1518]
[1519]
[1520]
[1521]
[1522]
[1523]
[1524]
[1525]
[1526]
[1527]
[1528]
[1529]
[1530]
[1531]
[1532]
[1533]
[1534]
[1535]
[1536]
[1537]
[1538]
[1539]
[1540]
[1541]
[1542]
[1543]
[1544]
[1545]
[1546]
[1547]
[1548]
[1549]
[1550]
[1551]
[1552]
[1553]
[1554]
[1555]
[1556]
[1557]
[1558]
[1559]
[1560]
[1561]
[1562]
[1563]
[1564]
[1565]
[1566]
[1567]
[1568]
[1569]
[1570]
[1571]
[1572]
[1573]
[1574]
[1575]
[1576]
[1577]
[1578]
[1579]
[1580]
[1581]
[1582]
[1583]
[1584]
[1585]
[1586]
[1587]
[1588]
[1589]
[1590]
[1591]
[1592]
[1593]
[1594]
[1595]
[1596]
[1597]
[1598]
[1599]
[1600]
[1601]
[1602]
[1603]
[1604]
[1605]
[1606]
[1607]
[1608]
[1609]
[1610]
[1611]
[1612]
[1613]
[1614]
[1615]
[1616]
[1617]
[1618]
[1619]
[1620]
[1621]
[1622]
[1623]
[1624]
[1625]
[1626]
[1627]
[1628]
[1629]
[1630]
[1631]
[1632]
[1633]
[1634]
[1635]
[1636]
[1637]
[1638]
[1639]
[1640]
[1641]
[1642]
[1643]
[1644]
[1645]
[1646]
[1647]
[1648]
[1649]
[1650]
[1651]
[1652]
[1653]
[1654]
[1655]
[1656]
[1657]
[1658]
[1659]
[1660]
[1661]
[1662]
[1663]
[1664]
[1665]
[1666]
[1667]
[1668]
[1669]
[1670]
[1671]
[1672]
[1673]
[1674]
[1675]
[1676]
[1677]
[1678]
[1679]
[1680]
[1681]
[1682]
[1683]
[1684]
[1685]
[1686]
[1687]
[1688]
[1689]
[1690]
[1691]
[1692]
[1693]
[1694]
[1695]
[1696]
[1697]
[1698]
[1699]
[1700]
[1701]
[1702]
[1703]
[1704]
[1705]
[1706]
[1707]
[1708]
[1709]
[1710]
[1711]
[1712]
[1713]
[1714]
[1715]
[1716]
[1717]
[1718]
[1719]
[1720]
[1721]
[1722]
[1723]
[1724]
[1725]
[1726]
[1727]
[1728]
[1729]
[1730]
[1731]
[1732]
[1733]
[1734]
[1735]
[1736]
[1737]
[1738]
[1739]
[1740]
[1741]
[1742]
[1743]
[1744]
[1745]
[1746]
[1747]
[1748]
[1749]
[1750]
[1751]
[1752]
[1753]
[1754]
[1755]
[1756]
[1757]
[1758]
[1759]
[1760]
[1761]
[1762]
[1763]
[1764]
[1765]
[1766]
[1767]
[1768]
[1769]
[1770]
[1771]
[1772]
[1773]
[1774]
[1775]
[1776]
[1777]
[1778]
[1779]
[1780]
[1781]
[1782]
[1783]
[1784]
[1785]
[1786]
[1787]
[1788]
[1789]
[1790]
[1791]
[1792]
[1793]
[1794]
[1795]
[1796]
[1797]
[1798]
[1799]
[1800]
[1801]
[1802]
[1803]
[1804]
[1805]
[1806]
[1807]
[1808]
[1809]
[1810]
[1811]
[1812]
[1813]
[1814]
[1815]
[1816]
[1817]
[1818]
[1819]
[1820]
[1821]
[1822]
[1823]
[1824]
[1825]
[1826]
[1827]
[1828]
[1829]
[1830]
[1831]
[1832]
[1833]
[1834]
[1835]
[1836]
[1837]
[1838]
[1839]
[1840]
[1841]
[1842]
[1843]
[1844]
[1845]
[1846]
[1847]
[1848]
[1849]
[1850]
[1851]
[1852]
[1853]
[1854]
[1855]
[1856]
[1857]
[1858]
[1859]
[1860]
[1861]
[1862]
[1863]
[1864]
[1865]
[1866]
[1867]
[1868]
[1869]
[1870]
[1871]
[1872]
[1873]
[1874]
[1875]
[1876]
[1877]
[1878]
[1879]
[1880]
[1881]
[1882]
[1883]
[1884]
[1885]
[1886]
[1887]
[1888]
[1889]
[1890]
[1891]
[1892]
[1893]
[1894]
[1895]
[1896]
[1897]
[1898]
[1899]
[1900]
[1901]
[1902]
[1903]
[1904]
[1905]
[1906]
[1907]
[1908]
[1909]
[1910]
[1911]
[1912]
[1913]
[1914]
[1915]
[1916]
[1917]
[1918]
[1919]
[1920]
[1921]
[1922]
[1923]
[1924]
[1925]
[1926]
[1927]
[1928]
[1929]
[1930]
[1931]
[1932]
[1933]
[1934]
[1935]
[1936]
[1937]
[1938]
[1939]
[1940]
[1941]
[1942]
[1943]
[1944]
[1945]
[1946]
[1947]
[1948]
[1949]
[1950]
[1951]
[1952]
[1953]
[1954]
[1955]
[1956]
[1957]
[1958]
[1959]
[1960]
[1961]
[1962]
[1963]
[1964]
[1965]
[1966]
[1967]
[1968]
[1969]
[1970]
[1971]
[1972]
[1973]
[1974]
[1975]
[1976]
[1977]
[1978]
[1979]
[1980]
[1981]
[1982]
[1983]
[1984]
[1985]
[1986]
[1987]
[1988]
[1989]
[1990]
[1991]
[1992]
[1993]
[1994]
[1995]
[1996]
[1997]
[1998]
[1999]
[2000]
[2001]
[2002]
[2003]
[2004]
[2005]
[2006]
[2007]
[2008]
[2009]
[2010]
[2011]
[2012]
[2013]
[2014]
[2015]
[2016]
[2017]
[2018]
[2019]
[2020]
[2021]
[2022]
[2023]
[2024]
[2025]
[2026]
[2027]
[2028]
[2029]
[2030]
[2031]
[2032]
[2033]
[2034]
[2035]
[2036]
[2037]
[2038]
[2039]
[2040]
[2041]
[2042]
[2043]
[2044]
[2045]
[2046]
[2047]
[2048]
[2049]
[2050]
[2051]
[2052]
[2053]
[2054]
[2055]
[2056]
[2057]
[2058]
[2059]
[2060]
[2061]
[2062]
[2063]
[2064]
[2065]
[2066]
[2067]
[2068]
[2069]
[2070]
[2071]
[2072]
[2073]
[2074]
[2075]
[2076]
[2077]
[2078]
[2079]
[2080]
[2081]
[2082]
[2083]
[2084]
[2085]
[2086]
[2087]
[2088]
[2089]
[2090]
[2091]
[2092]
[2093]
[2094]
[2095]
[2096]
[2097]
[2098]
[2099]
[2100]
[2101]
[2102]
[2103]
[2104]
[2105]
[2106]
[2107]
[2108]
[2109]
[2110]
[2111]
[2112]
[2113]
[2114]
[2115]
[2116]
[2117]
[2118]
[2119]
[2120]
[2121]
[2122]
[2123]
[2124]
[2125]
[2126]
[2127]
[2128]
[2129]
[2130]
[2131]
[2132]
[2133]
[2134]
[2135]
[2136]
[2137]
[2138]
[2139]
[2140]
[2141]
[2142]
[2143]
[2144]
[2145]
[2146]
[2147]
[2148]
[2149]
[2150]
[2151]
[2152]
[2153]
[2154]
[2155]
[2156]
[2157]
[2158]
[2159]
[2160]
[2161]
[2162]
[2163]
[2164]
[2165]
[2166]
[2167]
[2168]
[2169]
[2170]
[2171]
[2172]
[2173]
[2174]
[2175]
[2176]
[2177]
[2178]
[2179]
[2180]
[2181]
[2182]
[2183]
[2184]
[2185]
[2186]
[2187]
[2188]
[2189]
[2190]
[2191]
[2192]
[2193]
[2194]
[2195]
[2196]
[2197]
[2198]
[2199]
[2200]
[2201]
[2202]
[2203]
[2204]
[2205]
[2206]
[2207]
[2208]
[2209]
[2210]
[2211]
[2212]
[2213]
[2214]
[2215]
[2216]
[2217]
[2218]
[2219]
[2220]
[2221]
[2222]
[2223]
[2224]
[2225]
[2226]
[2227]
[2228]
[2229]
[2230]
[2231]
[2232]
[2233]
[2234]
[2235]
[2236]
[2237]
[2238]
[2239]
[2240]
[2241]
[2242]
[2243]
[2244]
[2245]
[2246]
[2247]
[2248]
[2249]
[2250]
[2251]
[2252]
[2253]
[2254]
[2255]
[2256]
[2257]
[2258]
[2259]
[2260]
[2261]
[2262]
[2263]
[2264]
[2265]
[2266]
[2267]
[2268]
[2269]
[2270]
[2271]
[2272]
[2273]
[2274]
[2275]
[2276]
[2277]
[2278]
[2279]
[2280]
[2281]
[2282]
[2283]
[2284]
[2285]
[2286]
[2287]
[2288]
[2289]
[2290]
[2291]
[2292]
[2293]
[2294]
[2295]
[2296]
[2297]
[2298]
[2299]
[2300]
[2301]
[2302]
[2303]
[2304]
[2305]
[2306]
[2307]
[2308]
[2309]
[2310]
[2311]
[2312]
[2313]
[2314]
[2315]
[2316]
[2317]
[2318]
[2319]
[2320]
[2321]
[2322]
[2323]
[2324]
[2325]
[2326]
[2327]
[2328]
[2329]
[2330]
[2331]
[2332]
[2333]
[2334]
[2335]
[2336]
[2337]
[2338]
[2339]
[2340]
[2341]
[2342]
[2343]
[2344]
[2345]
[2346]
[2347]
[2348]
[2349]
[2350]
[2351]
[2352]
[2353]
[2354]
[2355]
[2356]
[2357]
[2358]
[2359]
[2360]
[2361]
[2362]
[2363]
[2364]
[2365]
[2366]
[2367]
[2368]
[2369]
[2370]
[2371]
[2372]
[2373]
[2374]
[2375]
[2376]
[2377]
[2378]
[2379]
[2380]
[2381]
[2382]
[2383]
[2384]
[2385]
[2386]
[2387]
[2388]
[2389]
[2390]
[2391]
[2392]
[2393]
[2394]
[2395]
[2396]
[2397]
[2398]
[2399]
[2400]
[2401]
[2402]
[2403]
[2404]
[2405]
[2406]
[2407]
[2408]
[2409]
[2410]
[2411]
[2412]
[2413]
[2414]
[2415]
[2416]
[2417]
[2418]
[2419]
[2420]
[2421]
[2422]
[2423]
[2424]
[2425]
[2426]
[2427]
[2428]
[2429]
[2430]
[2431]
[2432]
[2433]
[2434]
[2435]
[2436]
[2437]
[2438]
[2439]
[2440]
[2441]
[2442]
[2443]
[2444]
[2445]
[2446]
[2447]
[2448]
[2449]
[2450]
[2451]
[2452]
[2453]
[2454]
[2455]
[2456]
[2457]
[2458]
[2459]
[2460]
[2461]
[2462]
[2463]
[2464]
[2465]
[2466]
[2467]
[2468]
[2469]
[2470]
[2471]
[2472]
[2473]
[2474]
[2475]
[2476]
[2477]
[2478]
[2479]
[2480]
[2481]
[2482]
[2483]
[2484]
[2485]
[2486]
[2487]
[2488]
[2489]
[2490]
[2491]
[2492]
[2493]
[2494]
[2495]
[2496]
[2497]
[2498]
[2499]
[2500]
[2501]
[2502]
[2503]
[2504]
[2505]
[2506]
[2507]
[2508]
[2509]
[2510]
[2511]
[2512]
[2513]
[2514]
[2515]
[2516]
[2517]
[2518]
[2519]
[2520]
[2521]
[2522]
[2523]
[2524]
[2525]
[2526]
[2527]
[2528]
[2529]
[2530]
[2531]
[2532]
[2533]
[2534]
[2535]
[2536]
[2537]
[2538]
[2539]
[2540]
[2541]
[2542]
[2543]
[2544]
[2545]
[2546]
[2547]
[2548]
[2549]
[2550]
[2551]
[2552]
[2553]
[2554]
[2555]
[2556]
[2557]
[2558]
[2559]
[2560]
[2561]
[2562]
[2563]
[2564]
[2565]
[2566]
[2567]
[2568]
[2569]
[2570]
[2571]
[2572]
[2573]
[2574]
[2575]
[2576]
[2577]
[2578]
[2579]
[2580]
[2581]
[2582]
[2583]
[2584]
[2585]
[2586]
[2587]
[2588]
[2589]
[2590]
[2591]
[2592]
[2593]
[2594]
[2595]
[2596]
[2597]
[2598]
[2599]
[2600]
[2601]
[2602]
[2603]
[2604]
[2605]
[2606]
[2607]
[2608]
[2609]
[2610]
[2611]
[2612]
[2613]
[2614]
[2615]
[2616]
[2617]
[2618]
[2619]
[2620]
[2621]
[2622]
[2623]
[2624]
[2625]
[2626]
[2627]
[2628]
[2629]
[2630]
[2631]
[2632]
[2633]
[2634]
[2635]
[2636]
[2637]
[2638]
[2639]
[2640]
[2641]
[2642]
[2643]
[2644]
[2645]
[2646]
[2647]
[2648]
[2649]
[2650]
[2651]
[2652]
[2653]
[2654]
[2655]
[2656]
[2657]
[2658]
[2659]
[2660]
[2661]
[2662]
[2663]
[2664]
[2665]
[2666]
[2667]
[2668]
[2669]
[2670]
[2671]
[2672]
[2673]
[2674]
[2675]
[2676]
[2677]
[2678]
[2679]
[2680]
[2681]
[2682]
[2683]
[2684]
[2685]
[2686]
[2687]
[2688]
[2689]
[2690]
[2691]
[2692]
[2693]
[2694]
[2695]
[2696]
[2697]
[2698]
[2699]
[2700]
[2701]
[2702]
[2703]
[2704]
[2705]
[2706]
[2707]
[2708]
[2709]
[2710]
[2711]
[2712]
[2713]
[2714]
[2715]
[2716]
[2717]
[2718]
[2719]
[2720]
[2721]
[2722]
[2723]
[2724]
[2725]
[2726]
[2727]
[2728]
[2729]
[2730]
[2731]
[2732]
[2733]
[2734]
[2735]
[2736]
[2737]
[2738]
[2739]
[2740]
[2741]
[2742]
[2743]
[2744]
[2745]
[2746]
[2747]
[2748]
[2749]
[2750]
[2751]
[2752]
[2753]
[2754]
[2755]
[2756]
[2757]
[2758]
[2759]
[2760]
[2761]
[2762]
[2763]
[2764]
[2765]
[2766]
[2767]
[2768]
[2769]
[2770]
[2771]
[2772]
[2773]
[2774]
[2775]
[2776]
[2777]
[2778]
[2779]
[2780]
[2781]
[2782]
[2783]
[2784]
[2785]
[2786]
[2787]
[2788]
[2789]
[2790]
[2791]
[2792]
[2793]
[2794]
[2795]
[2796]
[2797]
[2798]
[2799]
[2800]
[2801]
[2802]
[2803]
[2804]
[2805]
[2806]
[2807]
[2808]
[2809]
[2810]
[2811]
[2812]
[2813]
[2814]
[2815]
[2816]
[2817]
[2818]
[2819]
[2820]
[2821]
[2822]
[2823]
[2824]
[2825]
[2826]
[2827]
[2828]
[2829]
[2830]
[2831]
[2832]
[2833]
[2834]
[2835]
[2836]
[2837]
[2838]
[2839]
[2840]
[2841]
[2842]
[2843]
[2844]
[2845]
[2846]
[2847]
[2848]
[2849]
[2850]
[2851]
[2852]
[2853]
[2854]
[2855]
[2856]
[2857]
[2858]
[2859]
[2860]
[2861]
[2862]
[2863]
[2864]
[2865]
[2866]
[2867]
[2868]
[2869]
[2870]
[2871]
[2872]
[2873]
[2874]
[2875]
[2876]
[2877]
[2878]
[2879]
[2880]
[2881]
[2882]
[2883]
[2884]
[2885]
[2886]
[2887]
[2888]
[2889]
[2890]
[2891]
[2892]
[2893]
[2894]
[2895]
[2896]
[2897]
[2898]
[2899]
[2900]
[2901]
[2902]
[2903]
[2904]
[2905]
[2906]
[2907]
[2908]
[2909]
[2910]
[2911]
[2912]
[2913]
[2914]
[2915]
[2916]
[2917]
[2918]
[2919]
[2920]
[2921]
[2922]
[2923]
[2924]
[2925]
[2926]
[2927]
[2928]
[2929]
[2930]
[2931]
[2932]
[2933]
[2934]
[2935]
[2936]
[2937]
[2938]
[2939]
[2940]
[2941]
[2942]
[2943]
[2944]
[2945]
[2946]
[2947]
[2948]
[2949]
[2950]
[2951]
[2952]
[2953]
[2954]
[2955]
[2956]
[2957]
[2958]
[2959]
[2960]
[2961]
[2962]
[2963]
[2964]
[2965]
[2966]
[2967]
[2968]
[2969]
[2970]
[2971]
[2972]
[2973]
[2974]
[2975]
[2976]
[2977]
[2978]
[2979]
[2980]
[2981]
[2982]
[2983]
[2984]
[2985]
[2986]
[2987]
[2988]
[2989]
[2990]
[2991]
[2992]
[2993]
[2994]
[2995]
[2996]
[2997]
[2998]
[2999]
[3000]
[3001]
[3002]
[3003]
[3004]
[3005]
[3006]
[3007]
[3008]
[3009]
[3010]
[3011]
[3012]
[3013]
[3014]
[3015]
[3016]
[3017]
[3018]
[3019]
[3020]
[3021]
[3022]
[3023]
[3024]
[3025]
[3026]
[3027]
[3028]
[3029]
[3030]
[3031]
[3032]
[3033]
[3034]
[3035]
[3036]
[3037]
[3038]
[3039]
[3040]
[3041]
[3042]
[3043]
[3044]
[3045]
[3046]
[3047]
[3048]
[3049]
[3050]
[3051]
[3052]
[3053]
[3054]
[3055]
[3056]
[3057]
[3058]
[3059]
[3060]
[3061]
[3062]
[3063]
[3064]
[3065]
[3066]
[3067]
[3068]
[3069]
[3070]
[3071]
[3072]
[3073]
[3074]
[3075]
[3076]
[3077]
[3078]
[3079]
[3080]
[3081]
[3082]
[3083]
[3084]
[3085]
[3086]
[3087]
[3088]
[3089]
[3090]
[3091]
[3092]
[3093]
[3094]
[3095]
[3096]
[3097]
[3098]
[3099]
[3100]
[3101]
[3102]
[3103]
[3104]
[3105]
[3106]
[3107]
[3108]
[3109]
[3110]
[3111]
[3112]
[3113]
[3114]
[3115]
[3116]
[3117]
[3118]
[3119]
[3120]
[3121]
[3122]
[3123]
[3124]
[3125]
[3126]
[3127]
[3128]
[3129]
[3130]
[3131]
[3132]
[3133]
[3134]
[3135]
[3136]
[3137]
[3138]
[3139]
[3140]
[3141]
[3142]
[3143]
[3144]
[3145]
[3146]
[3147]
[3148]
[3149]
[3150]
[3151]
[3152]
[3153]
[3154]
[3155]
[3156]
[3157]
[3158]
[3159]
[3160]
[3161]
[3162]
[3163]
[3164]
[3165]
[3166]
[3167]
[3168]
[3169]
[3170]
[3171]
[3172]
[3173]
[3174]
[3175]
[3176]
[3177]
[3178]
[3179]
[3180]
[3181]
[3182]
[3183]
[3184]
[3185]
[3186]
[3187]
[3188]
[3189]
[3190]
[3191]
[3192]
[3193]
[3194]
[3195]
[3196]
[3197]
[3198]
[3199]
[3200]
[3201]
[3202]
[3203]
[3204]
[3205]
[3206]
[3207]
[3208]
[3209]
[3210]
[3211]
[3212]
[3213]
[3214]
[3215]
[3216]
[3217]
[3218]
[3219]
[3220]
[3221]
[3222]
[3223]
[3224]
[3225]
[3226]
[3227]
[3228]
[3229]
[3230]
[3231]
[3232]
[3233]
[3234]
[3235]
[3236]
[3237]
[3238]
[3239]
[3240]
[3241]
[3242]
[3243]
[3244]
[3245]
[3246]
[3247]
[3248]
[3249]
[3250]
[3251]
[3252]
[3253]
[3254]
[3255]
[3256]
[3257]
[3258]
[3259]
[3260]
[3261]
[3262]
[3263]
[3264]
[3265]
[3266]
[3267]
[3268]
[3269]
[3270]
[3271]
[3272]
[3273]
[3274]
[3275]
[3276]
[3277]
[3278]
[3279]
[3280]
[3281]
[3282]
[3283]
[3284]
[3285]
[3286]
[3287]
[3288]
[3289]
[3290]
[3291]
[3292]
[3293]
[3294]
[3295]
[3296]
[3297]
[3298]
[3299]
[3300]
[3301]
[3302]
[3303]
[3304]
[3305]
[3306]
[3307]
[3308]
[3309]
[3310]
[3311]
[3312]
[3313]
[3314]
[3315]
[3316]
[3317]
[3318]
[3319]
[3320]
[3321]
[3322]
[3323]
[3324]
[3325]
[3326]
[3327]
[3328]
[3329]
[3330]
[3331]
[3332]
[3333]
[3334]
[3335]
[3336]
[3337]
[3338]
[3339]
[3340]
[3341]
[3342]
[3343]
[3344]
[3345]
[3346]
[3347]
[3348]
[3349]
[3350]
[3351]
[3352]
[3353]
[3354]
[3355]
[3356]
[3357]
[3358]
[3359]
[3360]
[3361]
[3362]
[3363]
[3364]
[3365]
[3366]
[3367]
[3368]
[3369]
[3370]
[3371]
[3372]
[3373]
[3374]
[3375]
[3376]
[3377]
[3378]
[3379]
[3380]
[3381]
[3382]
[3383]
[3384]
[3385]
[3386]
[3387]
[3388]
[3389]
[3390]
[3391]
[3392]
[3393]
[3394]
[3395]
[3396]
[3397]
[3398]
[3399]
[3400]
[3401]
[3402]
[3403]
[3404]
[3405]
[3406]
[3407]
[3408]
[3409]
[3410]
[3411]
[3412]
[3413]
[3414]
[3415]
[3416]
[3417]
[3418]
[3419]
[3420]
[3421]
[3422]
[3423]
[3424]
[3425]
[3426]
[3427]
[3428]
[3429]
[3430]
[3431]
[3432]
[3433]
[3434]
[3435]
[3436]
[3437]
[3438]
[3439]
[3440]
[3441]
[3442]
[3443]
[3444]
[3445]
[3446]
[3447]
[3448]
[3449]
[3450]
[3451]
[3452]
[3453]
[3454]
[3455]
[3456]
[3457]
[3458]
[3459]
[3460]
[3461]
[3462]
[3463]
[3464]
[3465]
[3466]
[3467]
[3468]
[3469]
[3470]
[3471]
[3472]
[3473]
[3474]
[3475]
[3476]
[3477]
[3478]
[3479]
[3480]
[3481]
[3482]
[3483]
[3484]
[3485]
[3486]
[3487]
[3488]
[3489]
[3490]
[3491]
[3492]
[3493]
[3494]
[3495]
[3496]
[3497]
[3498]
[3499]
[3500]
[3501]
[3502]
[3503]
[3504]
[3505]
[3506]
[3507]
[3508]
[3509]
[3510]
[3511]
[3512]
[3513]
[3514]
[3515]
[3516]
[3517]
[3518]
[3519]
[3520]
[3521]
[3522]
[3523]
[3524]
[3525]
[3526]
[3527]
[3528]
[3529]
[3530]
[3531]
[3532]
[3533]
[3534]
[3535]
[3536]
[3537]
[3538]
[3539]
[3540]
[3541]
[3542]
[3543]
[3544]
[3545]
[3546]
[3547]
[3548]
[3549]
[3550]
[3551]
[3552]
[3553]
[3554]
[3555]
[3556]
[3557]
[3558]
[3559]
[3560]
[3561]
[3562]
[3563]
[3564]
[3565]
[3566]
[3567]
[3568]
[3569]
[3570]
[3571]
[3572]
[3573]
[3574]
[3575]
[3576]
[3577]
[3578]
[3579]
[3580]
[3581]
[3582]
[3583]
[3584]
[3585]
[3586]
[3587]
[3588]
[3589]
[3590]
[3591]
[3592]
[3593]
[3594]
[3595]
[3596]
[3597]
[3598]
[3599]
[3600]
[3601]
[3602]
[3603]
[3604]
[3605]
[3606]
[3607]
[3608]
[3609]
[3610]
[3611]
[3612]
[3613]
[3614]
[3615]
[3616]
[3617]
[3618]
[3619]
[3620]
[3621]
[3622]
[3623]
[3624]
[3625]
[3626]
[3627]
[3628]
[3629]
[3630]
[3631]
[3632]
[3633]
[3634]
[3635]
[3636]
[3637]
[3638]
[3639]
[3640]
[3641]
[3642]
[3643]
[3644]
[3645]
[3646]
[3647]
[3648]
[3649]
[3650]
[3651]
[3652]
[3653]
[3654]
[3655]
[3656]
[3657]
[3658]
[3659]
[3660]
[3661]
[3662]
[3663]
[3664]
[3665]
[3666]
[3667]
[3668]
[3669]
[3670]
[3671]
[3672]
[3673]
[3674]
[3675]
[3676]
[3677]
[3678]
[3679]
[3680]
[3681]
[3682]
[3683]
[3684]
[3685]
[3686]
[3687]
[3688]
[3689]
[3690]
[3691]
[3692]
[3693]
[3694]
[3695]
[3696]
[3697]
[3698]
[3699]
[3700]
[3701]
[3702]
[3703]
[3704]
[3705]
[3706]
[3707]
[3708]
[3709]
[3710]
[3711]
[3712]
[3713]
[3714]
[3715]
[3716]
[3717]
[3718]
[3719]
[3720]
[3721]
[3722]
[3723]
[3724]
[3725]
[3726]
[3727]
[3728]
[3729]
[3730]
[3731]
[3732]
[3733]
[3734]
[3735]
[3736]
[3737]
[3738]
[3739]
[3740]
[3741]
[3742]
[3743]
[3744]
[3745]
[3746]
[3747]
[3748]
[3749]
[3750]
[3751]
[3752]
[3753]
[3754]
[3755]
[3756]
[3757]
[3758]
[3759]
[3760]
[3761]
[3762]
[3763]
[3764]
[3765]
[3766]
[3767]
[3768]
[3769]
[3770]
[3771]
[3772]
[3773]
[3774]
[3775]
[3776]
[3777]
[3778]
[3779]
[3780]
[3781]
[3782]
[3783]
[3784]
[3785]
[3786]
[3787]
[3788]
[3789]
[3790]
[3791]
[3792]
[3793]
[3794]
[3795]
[3796]
[3797]
[3798]
[3799]
[3800]
[3801]
[3802]
[3803]
[3804]
[3805]
[3806]
[3807]
[3808]
[3809]
[3810]
[3811]
[3812]
[3813]
[3814]
[3815]
[3816]
[3817]
[3818]
[3819]
[3820]
[3821]
[3822]
[3823]
[3824]
[3825]
[3826]
[3827]
[3828]
[3829]
[3830]
[3831]
[3832]
[3833]
[3834]
[3835]
[3836]
[3837]
[3838]
[3839]
[3840]
[3841]
[3842]
[3843]
[3844]
[3845]
[3846]
[3847]
[3848]
[3849]
[3850]
[3851]
[3852]
[3853]
[3854]
[3855]
[3856]
[3857]
[3858]
[3859]
[3860]
[3861]
[3862]
[3863]
[3864]
[3865]
[3866]
[3867]
[3868]
[3869]
[3870]
[3871]
[3872]
[3873]
[3874]
[3875]
[3876]
[3877]
[3878]
[3879]
[3880]
[3881]
[3882]
[3883]
[3884]
[3885]
[3886]
[3887]
[3888]
[3889]
[3890]
[3891]
[3892]
[3893]
[3894]
[3895]
[3896]
[3897]
[3898]
[3899]
[3900]
[3901]
[3902]
[3903]
[3904]
[3905]
[3906]
[3907]
[3908]
[3909]
[3910]
[3911]
[3912]
[3913]
[3914]
[3915]
[3916]
[3917]
[3918]
[3919]
[3920]
[3921]
[3922]
[3923]
[3924]
[3925]
[3926]
[3927]
[3928]
[3929]
[3930]
[3931]
[3932]
[3933]
[3934]
[3935]
[3936]
[3937]
[3938]
[3939]
[3940]
[3941]
[3942]
[3943]
[3944]
[3945]
[3946]
[3947]
[3948]
[3949]
[3950]
[3951]
[3952]
[3953]
[3954]
[3955]
[3956]
[3957]
[3958]
[3959]
[3960]
[3961]
[3962]
[3963]
[3964]
[3965]
[3966]
[3967]
[3968]
[3969]
[3970]
[3971]
[3972]
[3973]
[3974]
[3975]
[3976]
[3977]
[3978]
[3979]
[3980]
[3981]
[3982]
[3983]
[3984]
[3985]
[3986]
[3987]
[3988]
[3989]
[3990]
[3991]
[3992]
[3993]
[3994]
[3995]
[3996]
[3997]
[3998]
[3999]
[4000]
[4001]
[4002]
[4003]
[4004]
[4005]
[4006]
[4007]
[4008]
[4009]
[4010]
[4011]
[4012]
[4013]
[4014]
[4015]
[4016]
[4017]
[4018]
[4019]
[4020]
[4021]
[4022]
[4023]
[4024]
[4025]
[4026]
[4027]
[4028]
[4029]
[4030]
[4031]
[4032]
[4033]
[4034]
[4035]
[4036]
[4037]
[4038]
[4039]
[4040]
[4041]
[4042]
[4043]
[4044]
[4045]
[4046]
[4047]
[4048]
[4049]
[4050]
[4051]
[4052]
[4053]
[4054]
[4055]
[4056]
[4057]
[4058]
[4059]
[4060]
[4061]
[4062]
[4063]
[4064]
[4065]
[4066]
[4067]
[4068]
[4069]
[4070]
[4071]
[4072]
[4073]
[4074]
[4075]
[4076]
[4077]
[4078]
[4079]
[4080]
[4081]
[4082]
[4083]
[4084]
[4085]
[4086]
[4087]
[4088]
[4089]
[4090]
[4091]
[4092]
[4093]
[4094]
[4095]
[4096]
[4097]
[4098]
[4099]
[4100]
[4101]
[4102]
[4103]
[4104]
[4105]
[4106]
[4107]
[4108]
[4109]
[4110]
[4111]
[4112]
[4113]
[4114]
[4115]
[4116]
[4117]
[4118]
[4119]
[4120]
[4121]
[4122]
[4123]
[4124]
[4125]
[4126]
[4127]
[4128]
[4129]
[4130]
[4131]
[4132]
[4133]
[4134]
[4135]
[4136]
[4137]
[4138]
[4139]
[4140]
[4141]
[4142]
[4143]
[4144]
[4145]
[4146]
[4147]
[4148]
[4149]
[4150]
[4151]
[4152]
[4153]
[4154]
[4155]
[4156]
[4157]
[4158]
[4159]
[4160]
[4161]
[4162]
[4163]
[4164]
[4165]
[4166]
[4167]
[4168]
[4169]
[4170]
[4171]
[4172]
[4173]
[4174]
[4175]
[4176]
[4177]
[4178]
[4179]
[4180]
[4181]
[4182]
[4183]
[4184]
[4185]
[4186]
[4187]
[4188]
[4189]
[4190]
[4191]
[4192]
[4193]
[4194]
[4195]
[4196]
[4197]
[4198]
[4199]
[4200]
[4201]
[4202]
[4203]
[4204]
[4205]
[4206]
[4207]
[4208]
[4209]
[4210]
[4211]
[4212]
[4213]
[4214]
[4215]
[4216]
[4217]
[4218]
[4219]
[4220]
[4221]
[4222]
[4223]
[4224]
[4225]
[4226]
[4227]
[4228]
[4229]
[4230]
[4231]
[4232]
[4233]
[4234]
[4235]
[4236]
[4237]
[4238]
[4239]
[4240]
[4241]
[4242]
[4243]
[4244]
[4245]
[4246]
[4247]
[4248]
[4249]
[4250]
[4251]
[4252]
[4253]
[4254]
[4255]
[4256]
[4257]
[4258]
[4259]
[4260]
[4261]
[4262]
[4263]
[4264]
[4265]
[4266]
[4267]
[4268]
[4269]
[4270]
[4271]
[4272]
[4273]
[4274]
[4275]
[4276]
[4277]
[4278]
[4279]
[4280]
[4281]
[4282]
[4283]
[4284]
[4285]
[4286]
/*****************************************************************************/
/*
Net.c
The networking essentials are based on DEC TCP/IP Services for OpenVMS (aka
UCX). The QIO interface was obviously chosen because of its asynchronous,
non-blocking capabilities. Although some functionalilty could have been
implemented using the BSD sockets abstraction and only the asynchronous I/O
done using the QIO I opted for working out the QIOs. It wasn't too difficult
and avoids the (slight) extra overhead of the sockets layer.
With resource wait explicitly enabled all sys$qio()s should wait until
resources become available. The only execption is ASTLM, a fundamental
requirement for this server. If SS$_EXQUOTA is returned from a sys$qio() (i.e.
without wait for completion, and therefore depending on AST delivery) then
EXIT THE SERVER with error status!
The 'ServiceStruct' structure has two groups of fields and performs two basic
roles. First, it provides a linked list which can be traversed to determine
from the destination IP address of a request which host was specified in a
(multi-homed) request. Second, for each unique port specified for the same
server the client components of the structure are used for the accept()ing of
requests. Note that there may be more 'service' structures in the list than
actual sockets created (and client components used) because only one is
allocated against a given port even though the services may specify multiple
host names using that port.
The server identity is derived from the 'ServerHostName' (gethostname()) name
and the 'ServerPort' (which is the first port specified as a service, or the
port specified in the configuration or /PORT= qualifier).
WASD_NET_TEST_BREAK
-------------------
See logical name WASD_NET_TEST_BREAK and NetTestSupervisor() for assistance
with testing server behaviour under less-than ideal circumstances.
VERSION HISTORY
---------------
11-SEP-2021 MGD NetControl() CONTROL_NET_PURGE_HTTP1 and .._HTTP2
27-APR-2021 MGD BSD 4.4 sockaddr.. IO$M_EXTEND to $QIO
20-NOV-2020 MGD NetWriteChunked() 65kB limit removed
30-JAN-2020 MGD NetIoWriteStatus() when request terminated by timeout
19-DEC-2019 MGD bugfix; NetCreateService() only SesolaInitService() once
bugfix; use NetIoWriteStatus() to maintain NETIO ASTs
07-APR-2018 MGD NetWriteBuffered() now writes before reset if necessary
NetWriteStrDsc() can now write synchronously
14-NOV-2017 MGD NetResponseHeaderAst() fudge status as necessary
19-MAY-2016 MGD bugfix; NetWrite() response header write error handling
11-AUG-2015 MGD restructure of network I/O abstractions
09-JUN-2014 MGD accounting for network blocks
07-JUN-2014 MGD NetCreateService() check bind address string instead of
address to allow binding primary to 0.0.0.0 (INADDR_ANY)
15-OCT-2011 MGD NetPurge() becomes NetControl() with expanded capability
12-FEB-2011 MGD NetCloseSocket() using WatchFilterClientService() so
that final close can be noted if required
30-OCT-2010 MGD NetCreateService() set primary service after address
23-JAN-2010 MGD NetPeek() now requires buffer arguments
14-NOV-2009 MGD NetPeek() non-consuming read
bugfix; NetHostNameLookup() IP address zeroed
13-OCT-2009 MGD NetHostNameLookup() now 'resolves' IP address 'host names'
23-SEP-2009 MGD bugfix; NetWriteStrDsc() flush all full descriptors
12-SEP-2009 MGD bugfix; NetWriteGzip() ensure buffer size <= 65535
31-JUL-2009 MGD NetCreateService() use primary if service IP addr reset
26-MAY-2009 MGD NetHostNameLookup() retry attempts from zero to two
26-APR-2008 MGD bugfix; NetRead() redact into DataPtr *not* into
rqNet.ReadBufferPtr (which works until subsequent read :-)
25-NOV-2007 MGD NetRead() redact buffer processing
04-OCT-2007 MGD call TcpIpSocketBufferSize()
10-JUN-2007 MGD use STR_DSC
26-OCT-2006 MGD bugfix; NetAcceptProcess() and NetDirectResponse()
should issue 503 for 'too busy', not 502
12-SEP-2006 MGD bugfix; NetAccept(), NetAcceptAst(), NetAcceptProcess()
nasty problem where multihomed servers 'svptr' confusion
(due to the multihome pointer manipulation) could result
in an attempted re-queue of an accept on a service that
did not correspond to the original accept AST delivery
with the result that no accept ended up being queued
22-AUG-2006 MGD maintenance; there seem to have been some changes in the
underlying TCP/IP Services handling of shared sockets
NetAcceptAst() if [DclGatewayBg] set socket share on client
NetClientSocketCcl() to control BG device carriage-control
(to parallel the APACHE$SET_CCL.EXE functionality)
08-AUG-2006 MGD NetWrite() accomodate 304 (not modified)
15-JUL-2006 MGD NetSuspend() and NetResume() to allow halt and resume
request processing
NetPassive() and NetActive() to allow non-supervisor
instances to be made quiescent
NetPurge() to break idle (and in-progress) connections
01-APR-2006 MGD no kidding; NetRead() cast AST routine and RequestGet
using (char*) to prevent %CC-E-NOEQUALITY compile-time
error under VAX VMS V7.3 and DECC V6.4
30-AUG-2005 JPP bugfix; raw proxy tunnelling requires a contrived connect
request in NetRead() to initiate an AST to RequestGet()
10-JUN-2005 MGD make EXQUOTA (particularly ASTLM) a little more obvious,
handle NetAccept() EXQUOTA via NetAcceptSupervisor()
26-MAY-2005 MGD bugfix; multi-instance socket device name handling
19-APR-2005 MGD revised multihoming so that the client specified IP address
of a accept()ed connection is used to identify the service
(this allows easier isolation of SSL certificates, etc.)
16-MAR-2005 JPP allow client-side GZIPing of proxied responses
28-JAN-2005 MGD bugfix; aarghh! NetWriteGzip()/NetWriteGzipAst()
20-JAN-2005 MGD bugfix; NetWriteChunked() ensure an empty body is
terminated with a chunk of zero
13-JAN-2005 MGD bugfix; NetWrite() distinguish between "empty" data and
end-of-stream (inducing occasional ZLIB buffer errors)
10-JAN-2005 MGD NetWriteGzip() abandon using argument counts to determine
AST usage or direct call, use NetWriteGzipAst() instead
08-JAN-2005 MGD minor mod to handle GZIP buffer flush
21-DEC-2004 MGD bugfix; NetWriteGzip() AST no remaining data length
16-DEC-2004 MGD NetWriteChunked() and NetWriteRawP5()
15-NOV-2004 MGD bugfix; handling of GZIP encoding (with GZIP.C)
(thanks to jpp@esme.fr for isolating this during BETA)
16-OCT-2004 MGD network write changes for GZIP encoding
10-APR-2004 MGD significant modifications to support IPv6
18-FEB-2004 MGD NetWriteBufferedSizeInit()
30-DEC-2003 MGD NetTcpIpAgentInfo() mods for IA64
07-JUL-2003 MGD support response header none/append mappings,
cache loading from network output
26-FEB-2003 MGD disable 'NetMultiHome' (should not be required
for modern virtual service processing)
15-JUL-2002 MGD all 'xray' functionality now performed in RequestScript()
02-JUN-2002 MGD rework NetCreateService() to allow SS$_IVADDR (invalid
media address) service to be supported by using INADDR_ANY
25-APR-2002 MGD NetAcceptSupervisor() and associated NOIOCHAN redress
31-MAR-2002 MGD integrate client connection data into request structure,
make client host name lookup asynchronous
22-JAN-2002 MGD bugfix; NetAcceptAst() deassign channel when connection
dropped during accept processing (jpp@esme.fr)
18-JAN-2002 MGD allow ->BindIpAddressString to specify 0.0.0.0 (INADDR_ANY)
29-SEP-2001 MGD service creation now supports multiple channels to the
one listening socket device for multiple per-node instances
04-AUG-2001 MGD support module WATCHing,
CONNECT method connection cancellation is normal behaviour
04-JUL-2001 MGD bugfix; (completed from 02-JUN, this time for SSL services),
also change behaviour, if a bind to INADDR_ANY fails attempt
to bind to the resolved host name address
02-JUN-2001 MGD bugfix; port check when IP address explicitly supplied
18-APR-2001 MGD rqNet.WriteErrorCount and rqNet.ReadErrorCount,
introduce NetTcpIpAgentInfo() (adapted from WATCH.C),
bugfix; NetThisVirtualService()
13-FEB-2001 MGD ntohs() on client port
22-NOV-2000 MGD rework service creation
17-OCT-2000 MGD modify SSL initialization so that "sharing" conditions
(same port on same IP address) are more easily identified
08-AUG-2000 MGD client sockets C_SHARE for direct script output to BG:
17-JUN-2000 MGD modifications for SERVICE.C requirements
10-MAY-2000 MGD per-service session tracking,
per-service listen queue backlog (for Compaq TCP/IP 5.0ff)
29-APR-2000 MGD proxy authorization
10-NOV-1999 MGD add IO$_NOWAIT to NetWriteDirect()
25-OCT-1999 MGD remove NETLIB support
10-OCT-1999 MGD allow virtual services more latitude,
check for request supervisor request timeout,
add FULL_DUPLEX_CLOSE,
workaround TCPWARE 5.3-3 behaviour (Laishev@SMTP.DeltaTel.RU)
18-AUG-1999 MGD bugfix; parsing certificate/key from service
11-JUN-1999 MGD bugfix; NetTooBusy() sys$fao() charset,
bugfix; NetDummyReadAst() UCX IOsb by reference
26-MAY-1999 MGD bugfix; NetShutdownSocket() AST handling
04-APR-1999 MGD provide HTTP/0.9 header absorbtion (finally!)
15-JAN-1999 MGD changed AST delivery algorithm
07-NOV-1998 MGD WATCH facility
24-OCT-1998 MGD allow SSL certificate to be specified per-service
08-APR-1998 MGD allow legitimate connects to be CANCELed in NetAcceptAst()
19-JAN-1998 MGD redesigned NetWriteBuffered()
27-NOV-1997 MGD hmmm, rationalized AST processing by making network
writes always deliver an AST (implicit or explicit)
(causing ACCVIOs for the last couple of versions)
25-OCT-1997 MGD changes to MsgFor() function
06-SEP-1997 MGD multi-homed hosts and multi-port services
30-AUG-1997 MGD bugfix; get server host name before starting logging
(woops, problem introduced with NETLIB)
09-AUG-1997 MGD message database
23-JUL-1997 MGD HTTPD v4.3, MultiNet dropped, using the NETLIB Library
01-FEB-1997 MGD HTTPd version 4
27-SEP-1996 MGD add dummy read for early error reporting
12-APR-1996 MGD observed Multinet disconnection/zero-byte behaviour
(request now aborts if Multinet returns zero bytes)
03-JAN-1996 MGD support for both DEC TCP/IP Services and TGV MultiNet
01-DEC-1995 MGD NetWriteBuffered() for improving network I/O
20-DEC-1994 MGD multi-threaded version
20-JUN-1994 MGD single-threaded version
*/
/*****************************************************************************/
#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 <stdarg.h>
#include <stdio.h>
#include <string.h>
/* VMS related header files */
#include <brkdef.h>
#include <descrip.h>
#include <dvidef.h>
#include <iodef.h>
#include <lnmdef.h>
#include <prvdef.h>
#include <psldef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application-related header files */
#include "wasd.h"
#define WASD_MODULE "NET"
#define NET_TEST 0
/******************/
/* global storage */
/******************/
BOOL NetAcceptAgent,
NetAcceptExQuota,
NetAcceptFailure,
NetAcceptNoIoChan,
NetConnectSuspend,
NetInstancePassive,
NetMultiHome;
int ConnectCountTotal,
NetAcceptBytLmRequired,
NetConcurrentMax,
NetConcurrentProcessMax,
NetCurrentHttp1Persistent,
NetListenBytLmRequired,
NetReadBufferSize,
NetRequestMax,
OutputBufferSize,
OutputFileBufferSize,
ServerHostNameLength;
ulong NetCurrentConnected [HTTPN],
NetCurrentProcessing [HTTPN];
char ServerHostName [TCPIP_HOSTNAME_MAX+1],
ServerHostPort [TCPIP_HOSTNAME_MAX+1+8];
static char NetAcceptAgentScript [] = "/cgiplus-bin/accagent";
static char ProblemAcceptAgent [] = "Problem initiating accept agent";
#define NET_AGENT_ACTIVE_MAX 8
#define NET_AGENT_BUSY_MAX 100
static int NetAgentActiveCount,
NetAgentActiveMax = NET_AGENT_ACTIVE_MAX,
NetAgentBusyMax = NET_AGENT_BUSY_MAX,
NetAgentBusyCount,
NetAgentBusyLimit;
/********************/
/* external storage */
/********************/
#ifdef DBUG
extern BOOL Debug;
#else
#define Debug 0
#endif
extern BOOL ControlExitRequested,
HttpdServerStartup,
InstanceNodeSupervisor,
ProtocolHttpsAvailable,
ProtocolHttpsConfigured,
TcpIpv6Configured;
extern int ConfigDnsLookupRetryCount,
EfnWait,
EfnNoWait,
InstanceNodeConfig,
InstanceNodeCurrent,
InstanceNumber,
InstanceStatusRequestCount,
OpcomMessages,
ServerPort,
TcpIpSendBufferSize,
TcpIpReceiveBufferSize,
WebSockCurrent;
extern const int64 Delta05Sec,
Delta100mSec;
extern int ToLowerCase[],
ToUpperCase[];
extern char CliLogFileName[],
ControlBuffer[],
ErrorSanityCheck[],
HttpdName[],
HttpdVersion[];
extern struct dsc$descriptor TcpIpDeviceDsc;
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern HTTPD_GBLSEC *HttpdGblSecPtr;
extern MSG_STRUCT Msgs;
extern LIST_HEAD Http2List,
RequestList,
ServiceList;
extern TCP_SOCKET_ITEM TcpIpSocket4,
TcpIpSocket6;
extern VMS_ITEM_LIST2 TcpIpFullDuplexCloseOption;
extern VMS_ITEM_LIST2 TcpIpSocketCclOptionOn;
extern VMS_ITEM_LIST2 TcpIpSocketCclOptionOff;
extern VMS_ITEM_LIST2 TcpIpSocketReuseAddrOption;
extern VMS_ITEM_LIST2 TcpIpSocketShareOption;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Get local host (server) name.
*/
NetGetServerHostName ()
{
int status;
unsigned short Length;
char *cptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetGetServerHostName()");
if (gethostname (ServerHostName, sizeof(ServerHostName)) != 0)
ErrorExitVmsStatus (vaxc$errno, "resolving server hostname", FI_LI);
/* looks better if its all in lower case (host name is sometimes upper) */
for (cptr = ServerHostName; *cptr; cptr++) *cptr = TOLO(*cptr);
ServerHostNameLength = cptr - ServerHostName;
if (!ServerHostNameLength)
ErrorExitVmsStatus (SS$_BUGCHECK, "could not determine local host name",
FI_LI);
}
/*****************************************************************************/
/*
It is only necessary to create one socket for each port port on the same
server, even if that port is specified against a different (multi-home) host
name because the accept()ing socket can be interrogated to determine which
host had been specified. Then in a infinite loop accept connections from
clients.
Binding services to sockets and allied topics ...
A service (host name and IP address) binds to INADDR_ANY and a port (say 80).
This allows the socket to accept connections for any address supported by the
interface, and on that port.
Subsequent services (different host name but same IP address, an alias, CNAME
records?) using the same port does not (indeed could not) bind again (to
INADDR_ANY). It just becomes part of the the existing bound socket's
environment inside the server. Using the HTTP "Host:" field virtual services
are supported (once the HTTP request header is parsed). Different ports are of
course bound to different sockets.
Some further subsequent service, this time with a different IP address (i.e.
implying there is a multi-homed system) wishes to establish a service on a
previously used port (say 80). First it attempts a bind to INADDR_ANY, which
fails because the port is already bound to that (mind you it may not be, in
which case it won't fail). So the server then retries the bind with it's IP
address, which we'll presume is OK.
Another service, with a third IP address tries to bind to INADDR_ANY on port
80, which fails, but it then successfully is bound using it's (so far) unique
address.
So far, no real site admin intervention. It seems to simply and easily support
the potential requirements of SSL services, as well as multi-homed standard
services. All "real" multi-homed services (with autonomous IP addresses) are
always bind against their unqiue address. "Virtual" services using those
addresses only are ever bound once for each port, subsequent services being
software contrivances. The [ServiceIpAddress] is still available to
"hard-wire" a service name to a particular IP address, but the above "cascade"
of binds tends to mean it should be far less important.
Only when a service with an IP address that is not supported by the interface
is attempted to be bound does it fail (with an invalid media address IIRC).
*/
NetCreateService ()
{
int cnt, qiofun, status,
BytLmAfter,
BytLmBefore,
IpPort;
unsigned short Length,
ServerChannel;
char *cptr,
*ProtocolPtr,
*SocketDevNamePtr;
IPADDRESS IpAddress,
PrimaryIpAddress;
SOCKADDRIN *sin4ptr;
SOCKADDRIN6 *sin6ptr;
SERVICE_STRUCT *svptr, *tsvptr;
TCP_SOCKET_ITEM *TcpSocketPtr;
VMS_ITEM_LIST2 SocketNameItem;
VMS_ITEM_LIST2 *il2ptr;
$DESCRIPTOR (BgDevNameDsc, "");
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetCreateService() !UL", ServiceList.EntryCount);
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
NetConnectSuspend = HttpdGblSecPtr->ConnectSuspend;
NetInstancePassive = HttpdGblSecPtr->InstancePassive;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
IPADDRESS_ZERO (&PrimaryIpAddress);
/********************************/
/* process the list of services */
/********************************/
/* block other instances from concurrently attempting to create services */
if (VMSnok (status = InstanceLock (INSTANCE_NODE_SOCKET)))
ErrorExitVmsStatus (status, "InstanceLock()", FI_LI);
LIST_ITERATE (svptr, &ServiceList)
{
FaoToStdout ("%HTTPD-I-SERVICE, !AZ//!AZ\n",
svptr->RequestSchemeNamePtr, svptr->ServerHostPort);
/* if the service has been given a a specific IP address to bind to */
if (svptr->BindIpAddressString[0])
{
IPADDRESS_COPY (&IpAddress, &svptr->BindIpAddress)
IPADDRESS_COPY (&svptr->MultiHomeIpAddress, &svptr->BindIpAddress)
}
else
if (IPADDRESS_IS_SAME (&svptr->ServerIpAddress, &PrimaryIpAddress))
{
/* zeroing these is the equivalent of setting INADDR_ANY */
if (IPADDRESS_IS_V4 (&PrimaryIpAddress))
IPADDRESS_ZERO4 (&IpAddress)
else
if (IPADDRESS_IS_V6 (&PrimaryIpAddress))
IPADDRESS_ZERO6 (&IpAddress)
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
IPADDRESS_COPY (&svptr->MultiHomeIpAddress, &PrimaryIpAddress)
}
else
if (IPADDRESS_IS_RESET (&svptr->ServerIpAddress))
{
IPADDRESS_COPY (&IpAddress, &svptr->ServerIpAddress)
if (IPADDRESS_IS_RESET (&PrimaryIpAddress))
{
IPADDRESS_COPY (&svptr->MultiHomeIpAddress, &IpAddress)
strcpy (&svptr->ServerIpAddressString,
TcpIpAddressToString (&IpAddress, 0));
}
else
{
if (IPADDRESS_IS_V4 (&PrimaryIpAddress))
IPADDRESS_ZERO4 (&IpAddress)
else
if (IPADDRESS_IS_V6 (&PrimaryIpAddress))
IPADDRESS_ZERO6 (&IpAddress)
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
IPADDRESS_COPY (&svptr->MultiHomeIpAddress, &PrimaryIpAddress)
strcpy (&svptr->ServerIpAddressString,
TcpIpAddressToString (&PrimaryIpAddress, 0));
}
}
else
{
IPADDRESS_COPY (&IpAddress, &svptr->ServerIpAddress)
IPADDRESS_COPY (&svptr->MultiHomeIpAddress, &svptr->ServerIpAddress)
}
IpPort = svptr->ServerPort;
/* get the address of the primary (first) service */
if (IPADDRESS_IS_RESET (&PrimaryIpAddress))
IPADDRESS_COPY (&PrimaryIpAddress, &IpAddress);
if (!IPADDRESS_IS_SAME (&svptr->MultiHomeIpAddress, &PrimaryIpAddress))
NetMultiHome = true;
/**********************************/
/* we may need to try this twice */
/**********************************/
/*
Once to try an bind to any non-primary or supplied IP address.
If this fails then a second attempt against address INADDR_ANY.
*/
svptr->ServerBindStatus = SS$_NORMAL;
for (cnt = 0; cnt <= 1; cnt++)
{
/* status explicitly set to zero (is checked for at end of loop!) */
ServerChannel = status = 0;
/* check if this instance has a channel to the socket */
SocketDevNamePtr = InstanceSocket (&IpAddress, IpPort, NULL);
if (SocketDevNamePtr && SocketDevNamePtr[0] == '_')
{
/********************/
/* existing channel */
/********************/
/* find it by device name */
LIST_ITERATE (tsvptr, &ServiceList)
if (strsame (SocketDevNamePtr+1, tsvptr->BgDevName, -1)) break;
if (!tsvptr)
{
char String [256];
FaoToBuffer (String, sizeof(String), NULL, "!&I,!UL !AZ",
&IpAddress, IpPort, SocketDevNamePtr+1);
ErrorExitVmsStatus (SS$_BUGCHECK, String, FI_LI);
}
if (svptr->RequestScheme != tsvptr->RequestScheme)
{
FaoToStdout (
"-SERVICE-W-INUSE, IP address and port already in use for \
!&?SSL\rHTTP\r service\n",
svptr->RequestScheme == SCHEME_HTTP);
break;
}
/* reuse the existing socket's data */
svptr->ServerBindStatus = 0;
IPADDRESS_COPY (&svptr->ServerIpAddress, &tsvptr->ServerIpAddress);
svptr->ServerChannel = tsvptr->ServerChannel;
strcpy (svptr->BgDevName, tsvptr->BgDevName);
}
if (svptr->RequestScheme == SCHEME_HTTPS)
{
/* SSL service, initialize */
if (!cnt)
{
/* but only the first time through */
#if WATCH_OPENSSL_30
int64 dura64;
WatchDuration (&dura64, 0, 0);
#endif
if (!SesolaInitService (svptr))
{
FaoToStdout ("-SERVICE-W-SSL, service not configured\n");
break;
}
#if WATCH_OPENSSL_30
WatchDuration (&dura64, FI_LI);
#endif
}
LIST_ITERATE (tsvptr, &ServiceList)
{
if (tsvptr == svptr) continue;
if (tsvptr->RequestScheme != SCHEME_HTTPS) continue;
if (!IPADDRESS_IS_SAME (&tsvptr->MultiHomeIpAddress,
&svptr->MultiHomeIpAddress)) continue;
if (tsvptr->ServerPort != svptr->ServerPort) continue;
FaoToStdout ("-SERVICE-W-SSL, shares address/port with !AZ\n",
tsvptr->ServerHostPort);
}
}
if (svptr->SSLclientEnabled)
{
/* if HTTP->SSL capable proxy service, initialize */
if (!SesolaInitClientService (svptr))
{
FaoToStdout ("-SERVICE-W-SSL, client not configured\n");
break;
}
}
/* if there is an existing channel to a socket */
if (SocketDevNamePtr && SocketDevNamePtr[0] == '_')
{
svptr->SharedSocket = true;
break;
}
/******************************************/
/* create and/or assign channel to socket */
/******************************************/
if (!NetListenBytLmRequired) BytLmBefore = GetJpiBytLm ();
if (!SocketDevNamePtr)
{
/*****************/
/* create socket */
/*****************/
/* create it now then */
status = sys$assign (&TcpIpDeviceDsc, &ServerChannel, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "sys$assign()", FI_LI);
/* prepare to bind the server socket to the IP address and port */
if (IPADDRESS_IS_V4 (&IpAddress))
{
SOCKADDRESS_ZERO4 (&svptr->ServerSocketName)
sin4ptr = &svptr->ServerSocketName.sa.v4;
sin4ptr->SIN$B_FAMILY = TCPIP$C_AF_INET;
sin4ptr->SIN$W_PORT = htons(IpPort);
IPADDRESS_SET4 (&sin4ptr->SIN$L_ADDR, &IpAddress)
il2ptr = &SocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN);
il2ptr->item = 0;
il2ptr->buf_addr = sin4ptr;
TcpSocketPtr = &TcpIpSocket4;
qiofun = IO$_SETMODE;
}
else
if (IPADDRESS_IS_V6 (&IpAddress))
{
SOCKADDRESS_ZERO6 (&svptr->ServerSocketName)
sin6ptr = &svptr->ServerSocketName.sa.v6;
sin6ptr->SIN6$B_FAMILY = TCPIP$C_AF_INET6;
sin6ptr->SIN6$W_PORT = htons(IpPort);
IPADDRESS_SET6 (&sin6ptr->SIN6$R_ADDR_OVERLAY.SIN6$T_ADDR,
&IpAddress)
il2ptr = &SocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN6);
il2ptr->item = 0;
il2ptr->buf_addr = sin6ptr;
TcpSocketPtr = &TcpIpSocket6;
qiofun = IO$_SETMODE | IO$M_EXTEND;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
/* make the channel a TCP, connection-oriented socket */
status = sys$qiow (EfnWait, ServerChannel, qiofun,
&svptr->ServerIOsb, 0, 0, TcpSocketPtr, 0, 0, 0,
&TcpIpSocketReuseAddrOption, 0);
if (VMSok (status)) status = svptr->ServerIOsb.Status;
if (VMSnok (status))
ErrorExitVmsStatus (status, NULL, FI_LI);
if (VMSok (status) && svptr->AdminService)
{
/* admin service chooses the first available of a range */
while (IpPort < 65535)
{
status = sys$qiow (EfnWait, ServerChannel,
qiofun, &svptr->ServerIOsb, 0, 0,
0, 0, &SocketNameItem,
svptr->ListenBacklog, 0, 0);
if (VMSok (status)) status = svptr->ServerIOsb.Status;
if (status != SS$_DUPLNAM) break;
IpPort++;
if (IPADDRESS_IS_V4 (&IpAddress))
sin4ptr->SIN$W_PORT = htons(IpPort);
else
sin6ptr->SIN6$W_PORT = htons(IpPort);
}
}
else
if (VMSok (status))
{
/* no existing device bound to this address and port */
status = sys$qiow (EfnWait, ServerChannel,
qiofun, &svptr->ServerIOsb, 0, 0,
0, 0, &SocketNameItem,
svptr->ListenBacklog, 0, 0);
if (VMSok (status)) status = svptr->ServerIOsb.Status;
}
if (VMSok (status))
SocketDevNamePtr = NetGetBgDevice(ServerChannel, NULL, 0);
}
else
{
/* socket already exists */
status = SS$_NORMAL;
}
if (VMSok (status))
{
/*********************************************/
/* assign channel to existing/created socket */
/*********************************************/
strcpy (svptr->BgDevName, SocketDevNamePtr);
BgDevNameDsc.dsc$a_pointer = svptr->BgDevName;
BgDevNameDsc.dsc$w_length = strlen(svptr->BgDevName);
status = sys$assign (&BgDevNameDsc, &svptr->ServerChannel, 0, 0);
if (VMSnok (status))
{
FaoToStdout (
"-SERVICE-W-ASSIGN, error assigning channel to !AZ \
(!&I!&?(INADDR_ANY)\r\r!UL)\n-!&M\n",
SocketDevNamePtr,
&IpAddress, IPADDRESS_IS_ANY(&IpAddress),
IpPort, status);
}
}
else
{
FaoToStdout (
"-SERVICE-W-BIND, error binding to !&I!&?(INADDR_ANY)\r\r:!UL\n-\!&M\n",
&IpAddress, IPADDRESS_IS_ANY(&IpAddress), IpPort, status);
}
if (VMSok(status) || IPADDRESS_IS_ANY(&IpAddress)) break;
/* this time try to bind to 'any' address it can! */
if (ServerChannel) sys$dassgn (ServerChannel);
svptr->ServerBindStatus = status;
IPADDRESS_SET_ANY (&IpAddress)
FaoToStdout ("-SERVICE-W-RETRY, try again using INADDR_ANY\n");
/*************/
/* try again */
/*************/
}
/* status explicitly set to zero, just continue with next service */
if (!status) continue;
IPADDRESS_COPY (&svptr->ServerIpAddress, &IpAddress)
if (VMSok (status) && InstanceNodeConfig > 1)
{
/* make the socket shareable (seems to work only if done here) */
status = sys$qiow (EfnWait, svptr->ServerChannel, IO$_SETMODE,
&svptr->ServerIOsb, 0, 0,
0, 0, 0, 0, &TcpIpSocketShareOption, 0);
if (VMSok (status)) status = svptr->ServerIOsb.Status;
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
}
if (VMSnok (status))
{
/***********/
/* problem */
/***********/
if (ServerChannel) sys$dassgn (ServerChannel);
svptr->ServerBindStatus = status;
svptr->ServerChannel = svptr->AdminPort = 0;
svptr->BgDevName[0] = '\0';
continue;
}
/***********/
/* success */
/***********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"LISTEN !AZ !&I!&?(INADDR_ANY)\r\r,!UL (!UL)",
svptr->BgDevName, &IpAddress, IPADDRESS_IS_ANY(&IpAddress),
IpPort, svptr->ListenBacklog);
if (svptr->AdminService)
{
/* set the IP address and port of this instance's admin service */
InstanceSocketAdmin ((short)IpPort);
svptr->AdminPort = IpPort;
}
else
if (ServerChannel)
{
/* inform the instance socket lock and table of the new device name */
InstanceSocket (NULL, 0, svptr->BgDevName);
}
if (ServerChannel) sys$dassgn (ServerChannel);
if (!NetListenBytLmRequired)
{
BytLmAfter = GetJpiBytLm ();
NetListenBytLmRequired = BytLmBefore - BytLmAfter;
}
if (IPADDRESS_IS_V6 (&IpAddress)) TcpIpv6Configured = true;
}
/* finished with service creation */
if (VMSnok (status = InstanceUnLock (INSTANCE_NODE_SOCKET)))
ErrorExitVmsStatus (status, "InstanceUnLock()", FI_LI);
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetMultiHome: !&B", NetMultiHome);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Queue the first accept for every service channel.
Call as an AST so that it's not interrupted during processing.
*/
void NetAcceptBegin ()
{
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetAcceptBegin()");
LIST_ITERATE (svptr, &ServiceList) NetAccept (svptr);
}
/*****************************************************************************/
/*
Just get the "BGnnn:" device name associated with the channel, returning it in
the storage supplied. If the storage pointer is NULL internal, static storage
is used ... good for one call per whatever. If an error occurs the message
string is returned instead.
*/
char* NetGetBgDevice
(
unsigned short Channel,
char *DevName,
int SizeOfDevName
)
{
static char StaticDevName [64];
static unsigned short Length;
static VMS_ITEM_LIST3 DevNamItemList [] =
{
{ 0, DVI$_DEVNAM, 0, &Length },
{ 0, 0, 0, 0 }
};
int status;
IO_SB IOsb;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetGetBgDevice()");
if (!DevName)
{
DevName = StaticDevName;
SizeOfDevName = sizeof(StaticDevName);
}
if (!Channel)
{
/* multiple successive nulls */
*(ULONGPTR)DevName = 0;
return (DevName);
}
DevNamItemList[0].buf_addr = DevName;
DevNamItemList[0].buf_len = SizeOfDevName-1;
status = sys$getdviw (EfnWait, Channel, 0, &DevNamItemList, &IOsb, 0, 0, 0);
if (VMSok (status)) status = IOsb.Status;
if (VMSok (status))
DevName[Length] = '\0';
else
FaoToBuffer (DevName, SizeOfDevName, NULL, "%!&M", status);
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!AZ", DevName);
if (DevName[0] == '_') return (DevName+1);
return (DevName);
}
/*****************************************************************************/
/*
Get the device reference count of the supplied channel.
*/
int NetGetRefCnt (unsigned short Channel)
{
static int DviRefCnt;
static VMS_ITEM_LIST3 DevNamItemList [] =
{
{ sizeof(DviRefCnt), DVI$_REFCNT, &DviRefCnt, 0 },
{ 0, 0, 0, 0 }
};
int status;
IO_SB IOsb;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetGetRefCnt()");
status = sys$getdviw (EfnWait, Channel, 0, &DevNamItemList, &IOsb, 0, 0, 0);
if (VMSok (status)) status = IOsb.Status;
if (VMSok (status)) return (DviRefCnt);
return (0);
}
/*****************************************************************************/
/*
Zero the per-service accounting counters.
*/
NetServiceZeroAccounting ()
{
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetServiceZeroAccounting()");
LIST_ITERATE (svptr, &ServiceList)
{
svptr->ConnectCount = svptr->ReadErrorCount = svptr->WriteErrorCount = 0;
svptr->BytesRawRx64 = 0;
svptr->BytesRawTx64 = 0;
}
}
/*****************************************************************************/
/*
Output service statistics (called from AdminReportServerStats()).
*/
int NetServiceReportStats (REQUEST_STRUCT *rqptr)
{
static char ServicesFao [] =
"<p><table class=\"ctgry\">\n\
<tr><th class=\"ctttl\">!&?\rInstance \rServices</th></tr>\n\
<tr><td>\n\
<table class=\"rghtrght\">\n\
<tr><td></td><td></td>\
<th class=\"sbttl\">IP</th>\
<th class=\"sbttl\">HTTP</th>\
<th class=\"sbttl\">Count</th>\
<th class=\"sbttl\"></th>\
<th class=\"sbttl\">bytes Rx</th>\
<th class=\"sbttl\">err</th>\
<th class=\"sbttl\">bytes Tx</th>\
<th class=\"sbttl\">err</th>\
<th></th></tr>\n";
static char OneServiceFao [] =
"<tr><th>!UL.</th>\
<td style=\"text-align:left;\">!AZ//!AZ</td>\
<td>!&?v4\rv6\r</td>\
<td>!&?2+1\r1\r</td>\
<td>!&L</td>\
<td>!UL%</td>\
<td>!&,@SQ</td>\
<td>!&L</td>\
<td>!&,@SQ</td>\
<td>!&L</td>\
<td>!UL%</td></tr>\n";
static char TotalFao [] =
"<tr><th colspan=\"4\">total:</th>\
<td>!&L</td>\
<td></td>\
<td>!&,@SQ</td>\
<td>!&L</td>\
<td>!&,@SQ</td>\
<td>!&L</td>\
</tr>\n\
<tr><td></td><td style=\"font-size:90%;text-align:left;\">\
<sup>*</sup><i>counts are per-startup only</i></td></tr>\n\
</table>\n\
</td></tr>\n\
</table>\n";
int status,
ServiceListCount,
ServiceTotalCount;
unsigned short Length;
unsigned long *vecptr;
unsigned long NetReadErrorTotal,
NetWriteErrorTotal;
unsigned long FaoVector [32];
int64 BytesRawRx64,
BytesRawTx64,
BytesRxTx64,
BytesTotal64;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetServiceReportStats()");
NetReadErrorTotal = NetWriteErrorTotal = ServiceTotalCount = 0;
BytesRawRx64 = BytesRawTx64 = BytesTotal64 = 0;
/* accumulate the raw (network) bytes for the services */
LIST_ITERATE (svptr, &ServiceList)
{
ServiceTotalCount += svptr->ConnectCount;
BytesRawRx64 += svptr->BytesRawRx64;
BytesRawTx64 += svptr->BytesRawTx64;
}
BytesTotal64 += BytesRawRx64;
BytesTotal64 += BytesRawTx64;
vecptr = FaoVector;
*vecptr++ = (InstanceNodeConfig <= 1);
status = FaolToNet (rqptr, ServicesFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
ServiceListCount = 1;
LIST_ITERATE (svptr, &ServiceList)
{
NetReadErrorTotal += svptr->ReadErrorCount;
NetWriteErrorTotal += svptr->WriteErrorCount;
vecptr = FaoVector;
*vecptr++ = ServiceListCount++;
*vecptr++ = svptr->RequestSchemeNamePtr;
*vecptr++ = svptr->ServerHostPort;
*vecptr++ = IPADDRESS_IS_V4(&svptr->ServerIpAddress);
*vecptr++ = svptr->Http2Enabled;
*vecptr++ = svptr->ConnectCount;
*vecptr++ = PercentOf32 (svptr->ConnectCount, ServiceTotalCount);
*vecptr++ = &svptr->BytesRawRx64;
*vecptr++ = svptr->ReadErrorCount;
*vecptr++ = &svptr->BytesRawTx64;
*vecptr++ = svptr->WriteErrorCount;
BytesRxTx64 = svptr->BytesRawRx64 + svptr->BytesRawTx64;
*vecptr++ = PercentOf64 (&BytesRxTx64, &BytesTotal64);
status = FaolToNet (rqptr, OneServiceFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
vecptr = FaoVector;
*vecptr++ = ServiceTotalCount;
*vecptr++ = &BytesRawRx64;
*vecptr++ = NetReadErrorTotal;
*vecptr++ = &BytesRawTx64;
*vecptr++ = NetWriteErrorTotal;
status = FaolToNet (rqptr, TotalFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Disconnect network connections. If no criteria supplied then disconnects all
persistent connects leaving requests in-progress. If ConnectNumber is positive
then disconnect that number, or if -1 all HTTP/1.n connections, -2 all HTTP/2
connections, negative (not -1 or -2) then *all* connections. Otherwise,
disconnect matching requests in-progress.
*/
NetControl
(
int ConnectNumber,
char *RequestUri
)
{
int PurgeCount = 0;
LIST_ENTRY *leptr;
REQUEST_STRUCT *rqeptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetControl() !SL !&Z", ConnectNumber, RequestUri);
for (leptr = RequestList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
rqeptr = (REQUEST_STRUCT*)leptr;
/* do NOT disconnect any WATCHing client (might be me :-) */
if (rqeptr == Watch.RequestPtr) continue;
if (ConnectNumber < -2)
{
/* purge all */
if (rqeptr->Http2Stream.Http2Ptr)
HttpdTimerSet (rqeptr, TIMER_TERMINATE, 0);
else
NetIoCloseSocket (rqeptr->NetIoPtr);
PurgeCount++;
}
else
if (ConnectNumber == -2 && rqeptr->Http2Stream.Http2Ptr)
{
/* purge all HTTP/2 */
HttpdTimerSet (rqeptr, TIMER_TERMINATE, 0);
}
else
if (ConnectNumber == -1 && !rqeptr->Http2Stream.Http2Ptr)
{
/* purge all HTTP/1.n */
NetIoCloseSocket (rqeptr->NetIoPtr);
}
else
if (ConnectNumber > 0 &&
ConnectNumber == rqeptr->ConnectNumber)
{
/* purge matching number */
if (rqeptr->Http2Stream.Http2Ptr)
HttpdTimerSet (rqeptr, TIMER_TERMINATE, 0);
else
NetIoCloseSocket (rqeptr->NetIoPtr);
PurgeCount++;
}
else
if (ConnectNumber >= 0 &&
RequestUri && RequestUri[0])
{
char *uptr = rqeptr->rqHeader.RequestUriPtr;
if ((RequestUri[0] == '!' && StringMatch (NULL, uptr, RequestUri+1)) ||
StringMatch (NULL, uptr, RequestUri))
{
if (rqeptr->Http2Stream.Http2Ptr)
HttpdTimerSet (rqeptr, TIMER_TERMINATE, 0);
else
NetIoCloseSocket (rqeptr->NetIoPtr);
PurgeCount++;
}
}
else
if (rqeptr->rqNet.PersistentCount &&
!rqeptr->BytesRx64 &&
!rqeptr->BytesTx64)
{
/* purge idle (only HTTP/1.n persistent) */
if (!ConnectNumber) NetIoCloseSocket (rqeptr->NetIoPtr);
PurgeCount++;
}
}
/* and the equivalent for HTTP/2 connections */
PurgeCount += Http2NetControl (ConnectNumber);
FaoToStdout ("%HTTPD-I-NET, !UL connections purged\n", PurgeCount);
if (OpcomMessages)
FaoToOpcom ("%HTTPD-I-NET, !UL connections purged", PurgeCount);
}
/*****************************************************************************/
/*
Suspend request processing by cancelling all queued net-accept socket I/O.
The boolean just aborts any network I/O (request) in-progress.
*/
NetSuspend (BOOL RightNow)
{
LIST_ENTRY *leptr;
REQUEST_STRUCT *rqeptr;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetSuspend()");
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
HttpdGblSecPtr->ConnectSuspend = true;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
if (NetConnectSuspend) return;
NetConnectSuspend = true;
LIST_ITERATE (svptr, &ServiceList) sys$cancel (svptr->ServerChannel);
/* process the request list looking for persistent connections to break */
for (leptr = RequestList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
rqeptr = (REQUEST_STRUCT*)leptr;
if (RightNow)
sys$cancel (rqeptr->NetIoPtr->Channel);
else
if (rqeptr->rqNet.PersistentCount && !rqeptr->BytesRx64)
sys$cancel (rqeptr->NetIoPtr->Channel);
}
FaoToStdout ("%HTTPD-I-NET, request processing suspended\n");
if (OpcomMessages)
FaoToOpcom ("%HTTPD-I-NET, request processing suspended");
}
/*****************************************************************************/
/*
Resume request processing by requeueing net-accept I/O to all sockets.
*/
NetResume ()
{
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetResume()");
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
HttpdGblSecPtr->ConnectSuspend = false;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
if (!NetConnectSuspend) return;
NetConnectSuspend = false;
LIST_ITERATE (svptr, &ServiceList) NetAccept (svptr);
FaoToStdout ("%HTTPD-I-NET, request processing resumed\n");
if (OpcomMessages)
FaoToOpcom ("%HTTPD-I-NET, request processing resumed");
}
/*****************************************************************************/
/*
Cancel all the queued net-accept socket I/O.
Also see description on active/passive modes in INSTANCE.C module.
*/
NetPassive ()
{
LIST_ENTRY *leptr;
REQUEST_STRUCT *rqeptr;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetPassive()");
if (NetInstancePassive) return;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
NetInstancePassive = HttpdGblSecPtr->InstancePassive = true;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
if (InstanceNodeSupervisor)
{
/* adjust to provide greater capacity in this one instance */
NetConcurrentMax *= 2;
NetConcurrentProcessMax *= 2;
/* of course the supervisor is the only one left processing requests! */
return;
}
if (InstanceNodeCurrent == 1 || NetConnectSuspend) return;
LIST_ITERATE (svptr, &ServiceList) sys$cancel (svptr->ServerChannel);
/* process the request list looking for persistent connections to break */
for (leptr = RequestList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
rqeptr = (REQUEST_STRUCT*)leptr;
if (rqeptr->rqNet.PersistentCount && !rqeptr->BytesRx64)
sys$cancel (rqeptr->NetIoPtr->Channel);
}
FaoToStdout ("%HTTPD-I-NET, instance to passive mode\n");
if (OpcomMessages)
FaoToOpcom ("%HTTPD-I-NET, instance to passive mode");
}
/*****************************************************************************/
/*
Requeue the net-accept I/O to all sockets.
Also see description on active/passive modes in INSTANCE.C module.
*/
NetActive (BOOL NowSupervisor)
{
BOOL InstancePassive;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetActive()");
if (!NetInstancePassive) return;
if (NowSupervisor)
{
/* adjust to provide greater capacity in this one instance */
NetConcurrentMax *= 2;
NetConcurrentProcessMax *= 2;
if (NetConnectSuspend) return;
LIST_ITERATE (svptr, &ServiceList) NetAccept (svptr);
}
else
{
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
NetInstancePassive = HttpdGblSecPtr->InstancePassive = false;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
if (InstanceNodeSupervisor)
{
/* restore the original values */
NetConcurrentMax /= 2;
NetConcurrentProcessMax /= 2;
/* the supervisor is already processing requests! */
return;
}
if (InstanceNodeCurrent == 1 || NetConnectSuspend) return;
LIST_ITERATE (svptr, &ServiceList) NetAccept (svptr);
FaoToStdout ("%HTTPD-I-NET, instance to active mode\n");
if (OpcomMessages)
FaoToOpcom ("%HTTPD-I-NET, instance to active mode");
}
}
/*****************************************************************************/
/*
A little convoluted. Will constrain to 80 or 132 wide terminal.
This function runs in the executing server to generate a listing of network
connections on behalf of a /DO=NET=LIST CLI command. The solution chosen to
ensure atomicity was to perform the reporting in the active server at AST
delivery level, written to an allocated buffer, and this then $BRKTHRU()ed
directly to the terminal of the process doing the /DO=NET=LIST.
Use of the $BRKTHRU service requires OPER privilege. No OPER, no list (but an
error -W-NOTICED). The $BRKTHRU buffer size is also constrained so busy sites
may eventually truncate.
*/
void NetListFor (char *terminal)
{
static ulong OperMask [2] = { PRV$M_OPER, 0 };
static $DESCRIPTOR (TermDsc, "");
int blen, brem, cnt1, cnt2, cntvia2, mlen, status,
width1, width2, width3, width4;
int64 dura64, time64;
ushort slen;
char *bptr, *dptr, *eptr, *mptr, *uptr;
char BytBuf [64],
ConBuf [64],
MsgBuf [16350],
PerBuf [64],
SerBuf [126];
$DESCRIPTOR (MsgBufDsc, MsgBuf);
HTTP2_STRUCT *h2ptr;
LIST_ENTRY *leptr;
REQUEST_STRUCT *rqeptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetListFor() !AZ", terminal);
sys$gettim (&time64);
/********************/
/* calculate widths */
/********************/
cnt1 = cnt2 = width1 = width2 = width3 = 0;
for (leptr = RequestList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
cnt1++;
rqeptr = (REQUEST_STRUCT*)leptr;
if (rqeptr->Http2Stream.Http2Ptr)
FaoToBuffer (ConBuf, sizeof(ConBuf), &slen, "!UL->!UL",
rqeptr->ConnectNumber,
rqeptr->Http2Stream.Http2Ptr->ConnectNumber);
else
FaoToBuffer (ConBuf, sizeof(ConBuf), &slen, "!UL",
rqeptr->ConnectNumber);
if (slen > width1) width1 = slen;
slen = strlen(rqeptr->ServicePtr->RequestSchemeNamePtr) +
strlen(rqeptr->ServicePtr->ServerHostPort);
if (slen > width2) width2 = slen;
slen = strlen(rqeptr->ClientPtr->Lookup.HostName);
if (slen > width3) width3 = slen;
}
for (leptr = Http2List.HeadPtr; leptr; leptr = leptr->NextPtr)
{
cnt2++;
h2ptr = (HTTP2_STRUCT*)leptr;
FaoToBuffer (ConBuf, sizeof(ConBuf), &slen, "->!UL",
h2ptr->ConnectNumber);
if (slen > width1) width1 = slen;
slen = strlen(h2ptr->ServicePtr->RequestSchemeNamePtr) +
strlen(h2ptr->ServicePtr->ServerHostPort);
if (slen > width2) width2 = slen;
slen = strlen(h2ptr->ClientPtr->Lookup.HostName);
if (slen > width3) width3 = slen;
}
if (width1 < 7) width1 = 7;
if (width2 < 17) width2 = 17;
if (width3 < 10) width3 = 10;
/* calculate the width of the URI to fit into 80 or 132 */
width4 = width1 + 2 + width2 + 2 + width3 + 2 + 8 + 2 + 8;
if (width4 >= 132)
width4 = 132;
else
if (width4 <= 80)
width4 = 80;
width4 -= width1 + 2;
/*******************/
/* generate report */
/*******************/
bptr = MsgBuf;
blen = 0;
brem = sizeof(MsgBuf) - 96;
*(USHORTPTR)bptr = '\r\n';
bptr += 2;
blen += 2;
brem -= 2;
if (cnt1 || cnt2)
{
FaoToBuffer (bptr, brem, &slen,
"\r\n\
!#AZ !#AZ !#AZ !8AZ !10AZ\r\n\
!#*- !#*- !#*- !8*- !8*-\r\n",
width1, "Connect", width2, "Service / Request", width3, "Client",
"Time", "Duration",
width1, width2, width3);
bptr += slen;
blen += slen;
brem -= slen;
}
cnt1 = cnt2 = cntvia2 = 0;
for (leptr = RequestList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
if (brem <= 0) break;
rqeptr = (REQUEST_STRUCT*)leptr;
if (rqeptr->Http2Stream.Http2Ptr)
{
cntvia2++;
FaoToBuffer (ConBuf, sizeof(ConBuf), 0, "!UL->!UL",
rqeptr->ConnectNumber,
rqeptr->Http2Stream.Http2Ptr->ConnectNumber);
}
else
{
cnt1++;
FaoToBuffer (ConBuf, sizeof(ConBuf), 0, "!UL", rqeptr->ConnectNumber);
}
FaoToBuffer (SerBuf, sizeof(SerBuf), 0, "!AZ!AZ",
rqeptr->ServicePtr->RequestSchemeNamePtr,
rqeptr->ServicePtr->ServerHostPort);
dura64 = rqeptr->rqTime.BeginTime64 - time64;
dptr = DurationString (NULL, &dura64);
FaoToBuffer (bptr, brem, &slen,
"!#AZ !#AZ !#AZ !8%T !10AZ\r\n",
width1, ConBuf,
width2, SerBuf,
width3, rqeptr->ClientPtr->Lookup.HostName,
&rqeptr->rqTime.BeginTime64,
dptr);
bptr += slen;
blen += slen;
brem -= slen;
if (!(uptr = rqeptr->rqHeader.RequestUriPtr))
{
if (rqeptr->rqNet.PersistentCount)
FaoToBuffer (uptr = PerBuf, sizeof(PerBuf), NULL,
"[persistent:!UL]", rqeptr->rqNet.PersistentCount);
else
uptr = "[connected]";
mptr = eptr = "";
mlen = 0;
}
else
{
mlen = strlen(mptr = rqeptr->rqHeader.MethodName);
if (mlen) mlen++;
eptr = "";
if (strlen(uptr) > width4)
{
mlen += 3;
eptr = "...";
}
}
FaoToBuffer (bptr, brem, &slen,
"!#* !AZ!AZ!#AZ!AZ\r\n",
width1+2, mptr, *mptr ? " " : "",
width4 - mlen, uptr, eptr);
bptr += slen;
blen += slen;
brem -= slen;
}
for (leptr = Http2List.HeadPtr; leptr; leptr = leptr->NextPtr)
{
if (brem <= 0) break;
h2ptr = (HTTP2_STRUCT*)leptr;
cnt2++;
FaoToBuffer (ConBuf, sizeof(ConBuf), 0, "->!UL", h2ptr->ConnectNumber);
FaoToBuffer (SerBuf, sizeof(SerBuf), 0, "!AZ!AZ",
h2ptr->ServicePtr->RequestSchemeNamePtr,
h2ptr->ServicePtr->ServerHostPort);
dura64 = h2ptr->ConnectTime64 - time64;
dptr = DurationString (NULL, &dura64);
FaoToBuffer (bptr, brem, &slen,
"!#AZ !#AZ !#AZ !8%T !10AZ\r\n",
width1, ConBuf,
width2, SerBuf,
width3, h2ptr->ClientPtr->Lookup.HostName,
&h2ptr->ConnectTime64,
dptr);
bptr += slen;
blen += slen;
brem -= slen;
FaoToBuffer (bptr, brem, &slen,
"!#* current:!UL peak:!UL count:!UL\r\n",
width1+2,
h2ptr->RequestCurrent,
h2ptr->RequestPeak,
h2ptr->RequestCount);
bptr += slen;
blen += slen;
brem -= slen;
}
#if WATCH_MOD
sprintf (BytBuf, " (%d bytes)", blen);
#else
BytBuf[0] = '\0';
#endif
/* always space for these (the -96) */
FaoToBuffer (bptr, brem, &slen,
"!AZ\r\n!UL HTTP/1.n, !UL via HTTP/2, !UL HTTP/2, !20%D!AZ\r\n",
brem <= 0 ? "*** TRUNCATED! ***\r\n" : "",
cnt1, cntvia2, cnt2, 0, BytBuf);
blen += slen;
TermDsc.dsc$a_pointer = terminal;
TermDsc.dsc$w_length = strlen(terminal);
MsgBufDsc.dsc$w_length = blen;
sys$setprv (1, &OperMask, 0, 0);
status = sys$brkthru (EfnNoWait, &MsgBufDsc, &TermDsc, BRK$C_DEVICE,
0, 0, 0, BRK$C_GENERAL, 5, 0, 0);
sys$setprv (0, &OperMask, 0, 0);
if (VMSnok (status)) ErrorNoticed (NULL, status, "sys$brkthru()", FI_LI);
}
/*****************************************************************************/
/*
Called every second by HttpdTick(). If there has been a failure in channel
assignment then attempt to queue fresh NetAccept()s for each service.
*/
NetAcceptSupervisor ()
{
static BOOL PrevNetAcceptFailure;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchThis (NULL, FI_LI, WATCH_MOD_NET, "NetAcceptSupervisor() !&B !&B",
PrevNetAcceptFailure, NetAcceptFailure);
if (PrevNetAcceptFailure && !NetAcceptFailure)
LIST_ITERATE (svptr, &ServiceList) NetAccept (svptr);
PrevNetAcceptFailure = NetAcceptFailure;
return (PrevNetAcceptFailure);
}
/*****************************************************************************/
/*
Queue an accept() to the listening server socket.
*/
NetAccept (SERVICE_STRUCT *svptr)
{
int qiofun, status,
BytLmBefore;
CLIENT_STRUCT *clptr;
NETIO_STRUCT *ioptr;
VMS_ITEM_LIST3 *il3ptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetAccept() !UL", svptr->AcceptQueued);
/* do the obvious */
if (NetConnectSuspend) return;
/* if instances are passive and not the instance supervisor */
if (NetInstancePassive && !InstanceNodeSupervisor) return;
/* server channel has been shutdown, most probably restart/exit underway */
if (!svptr->ServerChannel) return;
/* do not queue a second time on a shared socket */
if (svptr->SharedSocket) return;
/* only need the one queued at a time */
if (svptr->AcceptQueued) return;
if (!NetAcceptBytLmRequired) BytLmBefore = GetJpiBytLm ();
if ((ioptr = NetIoBegin ()) == NULL)
{
NetAcceptFailure = true;
NetAcceptBytLmRequired = BytLmBefore - GetJpiBytLm();
return;
}
ioptr->ServicePtr = svptr;
ioptr->ClientPtr = clptr = &ioptr->ClientIp;
if (IPADDRESS_IS_V4 (&svptr->ServerIpAddress))
{
SOCKADDRESS_ZERO4 (&clptr->SocketName)
il3ptr = &clptr->SocketNameItem;
il3ptr->buf_len = sizeof(SOCKADDRIN);
il3ptr->item = 0;
il3ptr->buf_addr = &clptr->SocketName.sa.v4;
il3ptr->ret_len = &clptr->SocketNameLength;
qiofun = IO$_ACCESS | IO$M_ACCEPT;
}
else
if (IPADDRESS_IS_V6 (&svptr->ServerIpAddress))
{
SOCKADDRESS_ZERO6 (&clptr->SocketName)
il3ptr = &clptr->SocketNameItem;
il3ptr->buf_len = sizeof(SOCKADDRIN6);
il3ptr->item = 0;
il3ptr->buf_addr = &clptr->SocketName.sa.v6;
il3ptr->ret_len = &clptr->SocketNameLength;
qiofun = IO$_ACCESS | IO$M_ACCEPT | IO$M_EXTEND;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
status = sys$qio (EfnNoWait, svptr->ServerChannel,
qiofun, &ioptr->AcceptIOsb, &NetAcceptAst, ioptr,
0, 0, &clptr->SocketNameItem,
&ioptr->Channel, &TcpIpFullDuplexCloseOption, 0);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
svptr->AcceptQueued++;
if (WATCH_CATEGORY(WATCH_NETWORK) && Watch.Category != WATCH_ONE_SHOT_CAT)
WatchThis (WATCHALL, WATCH_NETWORK,
"ACCEPT !AZ !&I!&?(INADDR_ANY)\r\r,!AZ",
NetGetBgDevice(svptr->ServerChannel, NULL, 0),
&svptr->ServerIpAddress,
IPADDRESS_IS_ANY(&svptr->ServerIpAddress),
svptr->ServerPortString);
}
/*****************************************************************************/
/*
A connection has been accept()ed on the specified server socket.
*/
NetAcceptAst (NETIO_STRUCT *ioptr)
{
int status;
CLIENT_STRUCT *clptr;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (Watch.Category || Watch.Module)
if (Watch.Category != WATCH_ONE_SHOT_CAT)
if (!Watch.FilterSet)
ioptr->WatchItem = WatchSetWatch (NULL, WATCH_NEW_ITEM);
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetAcceptAst() !&F !UL !&S !&X",
&NetAcceptAst, ioptr->ServicePtr->AcceptQueued,
ioptr->AcceptIOsb.Status, ioptr->AcceptIOsb.Unused);
clptr = ioptr->ClientPtr;
svptr = ioptr->ServicePtr;
if (svptr->AcceptQueued) svptr->AcceptQueued--;
if (VMSnok (status = ioptr->AcceptIOsb.Status))
{
if (ControlExitRequested)
{
/* server exiting or restarting, no new accepts, just return */
return;
}
/* if connect dropped, forget it, ready for next connection */
if (status == SS$_CANCEL ||
status == SS$_ABORT ||
status == SS$_CONNECFAIL ||
status == SS$_LINKABORT ||
status == SS$_REJECT ||
status == SS$_TIMEOUT ||
status == SS$_INSFMEM)
{
/* if server channel zero most probably restart/exit underway */
if (!svptr->ServerChannel) return;
if (status != SS$_CANCEL &&
status != SS$_CONNECFAIL)
ErrorNoticed (NULL, status, NULL, FI_LI);
NetIoEnd (ioptr);
/* queue up the next request acceptance */
NetAccept (svptr);
return;
}
/* most often network/system shutting down ... SS$_SHUT */
ErrorExitVmsStatus (status, "accept()", FI_LI);
}
#if NET_TEST
NetTestRequest (ioptr->Channel);
NetAccept (svptr);
return;
#endif /* NET_TEST */
if (Config.cfScript.GatewayBg)
{
if (svptr->RequestScheme == SCHEME_HTTP)
{
/* make the socket shareable */
status = sys$qiow (EfnWait, ioptr->Channel, IO$_SETMODE,
&ioptr->AcceptIOsb, 0, 0,
0, 0, 0, 0, &TcpIpSocketShareOption, 0);
if (VMSok (status)) status = ioptr->AcceptIOsb.Status;
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
}
}
if (svptr->RequestScheme == SCHEME_HTTPS)
InstanceGblSecIncrLong (&AccountingPtr->ConnectSSLCount);
if (IPADDRESS_IS_V4 (&svptr->ServerIpAddress))
{
InstanceGblSecIncrLong (&AccountingPtr->ConnectIpv4Count);
clptr->IpPort = ntohs(clptr->SocketName.sa.v4.SIN$W_PORT);
IPADDRESS_GET4 (&clptr->IpAddress,
&clptr->SocketName.sa.v4.SIN$L_ADDR);
strcpy (clptr->IpAddressString,
TcpIpAddressToString (&clptr->IpAddress, 0));
}
else
if (IPADDRESS_IS_V6 (&svptr->ServerIpAddress))
{
InstanceGblSecIncrLong (&AccountingPtr->ConnectIpv6Count);
clptr->IpPort = ntohs(clptr->SocketName.sa.v6.SIN6$W_PORT);
IPADDRESS_GET6 (&clptr->IpAddress,
clptr->SocketName.sa.v6.SIN6$R_ADDR_OVERLAY.SIN6$T_ADDR)
strcpy (clptr->IpAddressString,
TcpIpAddressToString (&clptr->IpAddress, 0));
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
/* meanwhile queue another accept */
NetAccept (svptr);
if (Config.cfMisc.DnsLookupClient)
{
if (WATCH_CATEGORY(WATCH_NETWORK))
WatchThis (WATCHALL, WATCH_NETWORK,
"RESOLVE !&I", &clptr->IpAddress);
/* asynchronous DNS lookup */
TcpIpAddressToName (&clptr->Lookup, &clptr->IpAddress,
ConfigDnsLookupRetryCount,
&NetAcceptProcess, ioptr);
}
else
{
/* not using client DNS lookup, carry on synchronously */
NetAcceptProcess (ioptr);
}
}
/*****************************************************************************/
/*
This function can be called either as an AST by TcpIpAdddressToName() if DNS
host name lookup is enabled, or directly from NetAccept() if it's disabled.
Either way just continue to process the connection accept.
*/
NetAcceptProcess (NETIO_STRUCT *ioptr)
{
int idx, qiofun, status,
SocketNameLength,
ServerSocketNameLength;
char ServerIpAddressString [32];
CLIENT_STRUCT *clptr;
REQUEST_STRUCT *rqptr;
SERVICE_STRUCT *asvptr,
*svptr,
*tsvptr;
IO_SB IOsb;
SOCKADDRESS SocketName;
VMS_ITEM_LIST3 SocketNameItem;
VMS_ITEM_LIST3 *il3ptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetAcceptProcess() !&F !&S !UL",
&NetAcceptProcess, ioptr->AcceptIOsb.Status,
ioptr->ClientPtr->Lookup.HostNameLength);
clptr = ioptr->ClientPtr;
svptr = ioptr->ServicePtr;
if (NetAcceptAgent)
{
/*************/
/* net agent */
/*************/
if (clptr->AgentRequestPtr)
{
/* post-process the agent response */
if (MATCH3 (clptr->AgentResponsePtr, "418"))
status = SS$_ABORT;
else
status = SS$_NORMAL;
if (clptr->AgentRequestPtr) VmFree (clptr->AgentRequestPtr, FI_LI);
if (clptr->AgentResponsePtr) VmFree (clptr->AgentResponsePtr, FI_LI);
clptr->AgentRequestPtr = clptr->AgentResponsePtr = NULL;
if (VMSnok (status))
{
/* 418 so drop the connection */
if (WATCH_CATEGORY(WATCH_NETWORK))
WatchThis (WATCHALL, WATCH_NETWORK, "DROP");
sys$dassgn (ioptr->Channel);
VmFree (ioptr, FI_LI);
return;
}
}
else
{
NetAgentBegin (ioptr);
return;
}
}
if (clptr->Lookup.DropConnect)
{
/* drop the connection (from a lookup agent) */
if (WATCH_CATEGORY(WATCH_NETWORK))
WatchThis (WATCHALL, WATCH_NETWORK, "DROP");
sys$dassgn (ioptr->Channel);
VmFree (ioptr, FI_LI);
return;
}
if (VMSnok (clptr->Lookup.LookupIOsb.Status))
{
/* lookup not done or failed, substitute the IP address for the name */
strcpy (clptr->Lookup.HostName, clptr->IpAddressString);
clptr->Lookup.HostNameLength = strlen(clptr->Lookup.HostName);
}
if (WATCH_MODULE(WATCH_MOD_NET))
WatchDataFormatted ("!&Z !&Z\n", clptr->IpAddressString,
clptr->Lookup.HostName);
if (NetMultiHome)
{
/***********************/
/* multihomed services */
/***********************/
/* get actual IP address and port specified by the client */
il3ptr = &SocketNameItem;
il3ptr->item = 0;
if (IPADDRESS_IS_V4 (&svptr->ServerIpAddress))
{
il3ptr->buf_len = sizeof(SOCKADDRIN);
il3ptr->buf_addr = &SocketName.sa.v4;
qiofun = IO$_SENSEMODE;
}
else
if (IPADDRESS_IS_V6 (&svptr->ServerIpAddress))
{
il3ptr->buf_len = sizeof(SOCKADDRIN6);
il3ptr->buf_addr = &SocketName.sa.v6;
qiofun = IO$_SENSEMODE | IO$M_EXTEND;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
il3ptr->ret_len = &SocketNameLength;
status = sys$qiow (EfnWait, ioptr->Channel, qiofun, &IOsb, 0, 0,
0, 0, &SocketNameItem, 0, 0, 0);
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"$QIOW() !&S !&S", status, IOsb.Status);
if (VMSok (status)) status = IOsb.Status;
if (VMSnok (status))
{
/* hmmm, forget it, ready for next connection */
sys$dassgn (ioptr->Channel);
VmFree (ioptr, FI_LI);
return;
}
if (IPADDRESS_IS_V4 (&svptr->ServerIpAddress))
IPADDRESS_GET4 (&clptr->MultiHomeIpAddress,
&SocketName.sa.v4.SIN$L_ADDR)
else
if (IPADDRESS_IS_V6 (&svptr->ServerIpAddress))
IPADDRESS_GET6 (&clptr->MultiHomeIpAddress,
&SocketName.sa.v6.SIN6$R_ADDR_OVERLAY.SIN6$T_ADDR)
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!&I,!UL !&I,!UL",
&clptr->MultiHomeIpAddress, svptr->ServerPort,
&svptr->MultiHomeIpAddress, svptr->ServerPort);
/* first check against the service it arrived at (port is implicit) */
asvptr = svptr;
if (IPADDRESS_IS_SAME(&clptr->MultiHomeIpAddress,
&asvptr->MultiHomeIpAddress))
tsvptr = asvptr;
else
/* then if necessary scan through the list of services */
LIST_ITERATE (tsvptr, &ServiceList)
{
if (WATCH_CATEGORY(WATCH_NETWORK))
WatchThis (WATCHALL, WATCH_NETWORK,
"MULTIHOME !&I,!UL !&I,!UL",
&clptr->MultiHomeIpAddress, asvptr->ServerPort,
&tsvptr->MultiHomeIpAddress, tsvptr->ServerPort);
if (IPADDRESS_IS_SAME(&clptr->MultiHomeIpAddress,
&tsvptr->MultiHomeIpAddress) &&
(asvptr->ServerPort == tsvptr->ServerPort ||
asvptr->ServerPort == tsvptr->AdminPort)) break;
}
if (tsvptr)
{
/* matched, change to the resolved (multihomed) service */
ioptr->ServicePtr = svptr = tsvptr;
}
else
{
/* the presence of this value indicates a multi-home mismatch */
strcpy (clptr->MultiHomeIpAddressString,
TcpIpAddressToString(&clptr->MultiHomeIpAddress,0));
}
}
else
tsvptr = NULL;
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!AZ !AZ:!UL",
svptr->ServerIpAddressString,
svptr->ServerHostName, svptr->ServerPort);
if (NetCurrentConnected[HTTP12] > NetConcurrentMax)
{
/************/
/* too busy */
/************/
if (WATCHING (ioptr, WATCH_CONNECT))
WatchThis (WATCHALL, WATCH_CONNECT,
"ACCEPTED !UL too-busy !AZ,!UL on !AZ//!AZ,!AZ !AZ",
NetConcurrentMax,
clptr->Lookup.HostName, clptr->IpPort,
svptr->RequestSchemeNamePtr,
svptr->ServerIpAddressString,
svptr->ServerPortString,
NetGetBgDevice(ioptr->Channel, NULL, 0));
svptr->ConnectCount++;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
AccountingPtr->ConnectTooBusyCount++;
AccountingPtr->ResponseStatusCodeGroup[5]++;
AccountingPtr->ResponseStatusCodeCount[RequestHttpStatusIndex(503)]++;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
/* just drop (as yet unnegotiated) TLS/SSL connection if too busy */
if (svptr->RequestScheme == SCHEME_HTTPS)
NetIoEnd (ioptr);
else
NetDirectResponse (ioptr, MSG_GENERAL_TOO_BUSY);
return;
}
if (!ConfigAcceptClientHostName (clptr->IpAddressString,
clptr->Lookup.HostName))
{
/************/
/* rejected */
/************/
if (WATCHING (ioptr, WATCH_CONNECT))
WatchThis (WATCHALL, WATCH_CONNECT,
"ACCEPTED reject !AZ,!UL on !AZ//!AZ,!AZ !AZ",
clptr->Lookup.HostName, clptr->IpPort,
svptr->RequestSchemeNamePtr,
svptr->ServerIpAddressString,
svptr->ServerPortString,
NetGetBgDevice(ioptr->Channel, NULL, 0));
svptr->ConnectCount++;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
AccountingPtr->ConnectRejectedCount++;
AccountingPtr->ResponseStatusCodeGroup[4]++;
AccountingPtr->ResponseStatusCodeCount[RequestHttpStatusIndex(403)]++;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
/* just drop (as yet unnegotiated) TLS/SSL connection if rejected */
if (svptr->RequestScheme == SCHEME_HTTPS)
NetIoEnd (ioptr);
else
NetDirectResponse (ioptr, MSG_GENERAL_ACCESS_DENIED);
return;
}
/************/
/* accepted */
/************/
if (ioptr->WatchItem &&
WATCH_CATEGORY(WATCH_CONNECT))
{
if (NetMultiHome)
WatchThis (WATCHITM(ioptr), WATCH_CONNECT,
"MULTIHOME !&?match\rno match\r for !&I,!UL arrived at !&I,!UL",
tsvptr,
&clptr->MultiHomeIpAddress, svptr->ServerPort,
&asvptr->ServerIpAddress, asvptr->ServerPort);
WatchThis (WATCHITM(ioptr), WATCH_CONNECT,
"ACCEPTED !AZ,!UL on !AZ//!AZ,!UL (!&I) !AZ",
clptr->Lookup.HostName, clptr->IpPort,
svptr->RequestSchemeNamePtr,
svptr->ServerHostName,
svptr->ServerPort,
&svptr->ServerIpAddress,
NetGetBgDevice(ioptr->Channel, NULL, 0));
}
RequestAccept (ioptr);
}
/*****************************************************************************/
/*
Change the socket BG devices implied carriage-control bit; 0 forces the CCL bit
off, 1 forces it on(, and -1 one toggles it [perhaps one day]).
*/
int NetClientSocketCcl
(
NETIO_STRUCT *ioptr,
int CclOption
)
{
int status;
IO_SB IOsb;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET,
"NetClientSocketCcl() !SL !&A !UL",
CclOption, ioptr->Http2StreamPtr, ioptr->Channel);
if (ioptr->Http2StreamPtr)
status = SS$_BADPARAM;
else
if (ioptr->ServicePtr->RequestScheme == SCHEME_HTTP)
{
if (ioptr->Channel)
{
if (CclOption == 1)
status = sys$qiow (EfnWait, ioptr->Channel, IO$_SETMODE,
&IOsb, 0, 0,
0, 0, 0, 0, &TcpIpSocketCclOptionOn, 0);
else
if (CclOption == 0)
status = sys$qiow (EfnWait, ioptr->Channel, IO$_SETMODE,
&IOsb, 0, 0,
0, 0, 0, 0, &TcpIpSocketCclOptionOff, 0);
else
status = SS$_BADPARAM;
if (VMSok (status)) status = IOsb.Status;
if (WATCHING (ioptr, WATCH_NETWORK))
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"SOCKET CCL !SL !&S", CclOption, status);
}
else
status = SS$_BADPARAM;
}
else
status = SS$_BADPARAM;
return (status);
}
/*****************************************************************************/
/*
'HostNamePort' can contain a "host.name:port" or just a "host.name" if the port
is supplied via 'PortNumber'. Using the supplied or parsed host name get the
lookup host name into 'HostNamePtr', the decimal-dot-notation IP address string
into 'IpAddressStringPtr' and the IP address into 'IpAddressPtr', the IP port
number (particularly if parsed from 'HostNamePort' in to 'IpPortPtr'. Any of
the '...Ptr' parameters can be NULL and won't have the respective information
returned.
*/
int NetHostNameLookup
(
char *HostNamePort,
int PortNumber,
char *HostNamePtr,
char *HostPortPtr,
char *IpAddressStringPtr,
IPADDRESS *IpAddressPtr,
int *IpPortPtr
)
{
static $DESCRIPTOR (HostPortFaoDsc, "!AZ:!UL\0");
static $DESCRIPTOR (StringDsc, "");
static int RetryAttempts = -1;
BOOL AddressOnly,
FullyQualified;
int idx,
status;
char *cptr, *sptr, *zptr;
char HostNameScratch [128];
IPADDRESS IpAddress;
TCPIP_HOST_LOOKUP HostLookup;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetHostNameLookup() !AZ", HostNamePort);
AddressOnly = true;
FullyQualified = false;
zptr = (sptr = HostNameScratch) + sizeof(HostNameScratch)-1;
if (HostNamePort[0] == '[')
{
/* IPv6 address */
for (cptr = HostNamePort;
*cptr && *cptr != ']' && sptr < zptr;
*sptr++ = *cptr++);
if (*cptr == ']' && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
}
else
{
for (cptr = HostNamePort;
*cptr && *cptr != ':' && sptr < zptr;
*sptr++ = TOLO(*cptr++))
if (isalpha(*cptr)) AddressOnly = false;
*sptr = '\0';
}
if (*cptr == ':' && !PortNumber) PortNumber = atoi(cptr+1);
/*************************/
/* UCX resolve host name */
/*************************/
IPADDRESS_ZERO (&IpAddress);
if (AddressOnly)
status = SS$_NORMAL;
else
{
if (RetryAttempts < 0)
{
if (cptr = SysTrnLnm (WASD_NET_LOOKUP_RETRY))
RetryAttempts = atoi(cptr);
else
RetryAttempts = NET_LOOKUP_RETRY;
}
memset (&HostLookup, 0, sizeof(HostLookup));
status = TcpIpNameToAddress (&HostLookup, HostNameScratch,
RetryAttempts, NULL, 0);
if (VMSok (status))
{
/* use the resolved name */
zptr = (sptr = HostNameScratch) + 127;
for (cptr = HostLookup.HostName;
*cptr && sptr < zptr;
*sptr++ = TOLO(*cptr++));
*sptr = '\0';
IPADDRESS_COPY (&IpAddress, &HostLookup.IpAddress)
}
}
/*****************************/
/* return values as required */
/*****************************/
if (HostNamePtr)
{
strcpy (HostNamePtr, HostNameScratch);
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!AZ", HostNamePtr);
}
if (HostPortPtr)
{
StringDsc.dsc$a_pointer = HostPortPtr;
StringDsc.dsc$w_length = 128+16;
sys$fao (&HostPortFaoDsc, 0, &StringDsc, HostNameScratch, PortNumber);
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!AZ", HostPortPtr);
}
if (IpAddressStringPtr)
{
/* convert the binary address into a string */
strcpy (IpAddressStringPtr, TcpIpAddressToString (&IpAddress, 0));
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!AZ", IpAddressStringPtr);
}
if (IpAddressPtr) IPADDRESS_COPY (IpAddressPtr, &IpAddress)
if (IpPortPtr) *IpPortPtr = PortNumber;
return (status);
}
/****************************************************************************/
/*
Just close the socket, bang!
*/
void NetCloseSocket (REQUEST_STRUCT *rqptr)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET, "NetCloseSocket()");
NetIoCloseSocket (rqptr->NetIoPtr);
}
/****************************************************************************/
/*
Deassign the request's underlying network connection regardless of whether it
is a directly connected socket or HTTP/2 connected socket.
*/
void NetAbortSocket (REQUEST_STRUCT *rqptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET, "NetAbortSocket()");
if (rqptr->Http2Stream.Http2Ptr)
NetIoCloseSocket (rqptr->Http2Stream.Http2Ptr->NetIoPtr);
else
NetIoCloseSocket (rqptr->NetIoPtr);
}
/****************************************************************************/
/*
Stop the server from receiving incoming requests.
*/
NetShutdownServerSocket ()
{
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetShutdownServerSocket()");
LIST_ITERATE (svptr, &ServiceList)
{
sys$dassgn (svptr->ServerChannel);
svptr->ServerChannel = 0;
}
}
/*****************************************************************************/
/*
Called from NetWrite() is a response header needs to be sent before any data.
Response header has now been sent, send the data using the buffered
information about it.
*/
NetResponseHeaderAst (REQUEST_STRUCT *rqptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"NetResponseHeaderAst() !&F !&A !&X !UL",
&NetResponseHeaderAst,
rqptr->rqResponse.HeaderAstFunction,
rqptr->rqResponse.HeaderDataPtr,
rqptr->rqResponse.HeaderDataLength);
if (rqptr->rqResponse.HeaderDataPtr &&
rqptr->rqResponse.HeaderDataLength)
NetWrite (rqptr,
rqptr->rqResponse.HeaderAstFunction,
rqptr->rqResponse.HeaderDataPtr,
rqptr->rqResponse.HeaderDataLength);
else
/* without a real network write just fudge the status */
NetIoWriteStatus (rqptr->NetIoPtr, rqptr->rqResponse.HeaderAstFunction,
rqptr, SS$_NORMAL, 0);
}
/*****************************************************************************/
/*
Write 'DataLength' bytes located at 'DataPtr' to the client either using either
the "raw" network or via the Secure Sockets Layer.
If 'AstFunction' zero then use sys$qiow(), waiting for completion. If
an AST completion address is supplied then use sys$qio(). If empty data
buffer is supplied (zero length) then declare an AST to service any AST
routine supplied. If none then just return.
For responses generated by the server the HTTP header is a separate structure
which can be sent separately. If the HTTP method is "HEAD" only allow bytes in
the header to be sent, absorb any other, explicitly calling the AST completion
routine as necessary (this, in particular, is for scripts that don't recognise
this method).
Explicitly declares any AST routine if an error occurs. The calling function
must not do any error recovery if an AST routine has been supplied but the
associated AST routine must! If an AST was not supplied then the return
status can be checked.
*/
int NetWrite
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction,
char *DataPtr,
int DataLength
)
{
int cnt, length, nlcnt, status;
BOOL WritingProxyResponseHeader;
char *cptr, *sptr;
DICT_ENTRY_STRUCT *denptr;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"NetWrite() ast:!&A data:!&X len:!UL state:!UL gen:!&B sent:!&B cnt:!UL",
AstFunction, DataPtr, DataLength,
rqptr->RequestState,
rqptr->rqResponse.HeaderGenerated,
rqptr->rqResponse.HeaderSent,
rqptr->rqResponse.HeaderNewlineCount);
ioptr = rqptr->NetIoPtr;
ioptr->WatchItem = rqptr->WatchItem;
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
{
NetIoWriteStatus (ioptr, AstFunction, rqptr, SS$_ABORT, 0);
return (SS$_ABORT);
}
/* intermediate update to data transfer stats */
rqptr->NetIoPtr->BlocksRawTx64 = ioptr->BlocksRawTx64;
rqptr->NetIoPtr->BytesRawTx64 = ioptr->BytesRawTx64;
status = SS$_NORMAL;
/* initiate cache load if .. */
if (rqptr->rqPathSet.CacheNet && /* the path indicates it */
!rqptr->rqCache.LoadCheck && /* not been checked already */
!rqptr->rqCache.EntryPtr) /* output is not from the cache! */
{
/* request output to be cached */
rqptr->rqCache.LoadFromNet =
CacheLoadBegin (rqptr, (int)rqptr->rqResponse.ContentLength64,
rqptr->rqResponse.ContentTypePtr);
}
if (rqptr->rqResponse.HeaderGenerated &&
!rqptr->rqResponse.HeaderSent)
{
/*******************************************/
/* nothing of response sent to client yet! */
/*******************************************/
rqptr->rqResponse.HeaderSent = true;
if (rqptr->rqPathSet.ResponseHeaderNone &&
rqptr->rqResponse.HttpStatus / 100 == 2)
{
/*********************/
/* header suppressed */
/*********************/
if (WATCHING (rqptr, WATCH_RESPONSE_HEADER))
{
if (denptr = ResponseDictHeader (rqptr))
length = DICT_GET_VALUE_LEN(denptr);
else
length = 0;
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER,
"HEADER !UL bytes (NONE)", length);
}
}
else
if (rqptr->rqResponse.HttpVersion != HTTP_VERSION_0_9)
{
/************************/
/* send response header */
/************************/
if (rqptr != Watch.RequestPtr &&
WATCHPNT(rqptr) && WATCH_CATEGORY(WATCH_RESPONSE_HEADER))
{
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER, "DATA");
DictWatchEntry (NULL);
DictWatch (rqptr->rqDictPtr, DICT_TYPE_INTERNAL, "response_status");
DictWatch (rqptr->rqDictPtr, DICT_TYPE_RESPONSE, "*");
}
if (AstFunction)
{
rqptr->rqResponse.HeaderAstFunction = AstFunction;
rqptr->rqResponse.HeaderDataPtr = DataPtr;
rqptr->rqResponse.HeaderDataLength = DataLength;
AstFunction = &NetResponseHeaderAst;
}
/* only need header via the network if it's not already generated */
if (rqptr->rqCache.LoadFromNet &&
!rqptr->rqResponse.ContentTypePtr)
{
if (denptr = ResponseDictHeader (rqptr))
{
cptr = DICT_GET_VALUE(denptr);
length = DICT_GET_VALUE_LEN(denptr);
CacheLoadData (rqptr, cptr, length);
}
}
else
denptr = NULL;
if (HTTP2_REQUEST(rqptr))
{
/* function will return SS$_ABORT if header not generated */
if (VMSnok (status = Http2ResponseDictHeader (rqptr, AstFunction)))
NetIoWriteStatus (ioptr, AstFunction, rqptr, status, 0);
}
else
{
if (denptr == NULL) denptr = ResponseDictHeader (rqptr);
/* it is possible that a header has not been generated */
if (denptr)
{
cptr = DICT_GET_VALUE(denptr);
length = DICT_GET_VALUE_LEN(denptr);
if (rqptr->rqPathSet.ResponseHeaderBegin &&
rqptr->rqResponse.HttpStatus / 100 == 2) length -= 2;
if (rqptr != Watch.RequestPtr &&
WATCHPNT(rqptr) && WATCH_CATEGORY(WATCH_RESPONSE_HEADER))
{
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER,
"HEADER !UL bytes", length);
WatchData (cptr, length);
}
status = NetIoWrite (ioptr, AstFunction, rqptr, cptr, length);
if (VMSok (status)) rqptr->BytesTx64 += length;
}
else
NetIoWriteStatus (ioptr, AstFunction, rqptr,
status = SS$_ABORT, 0);
}
if (AstFunction) return (status);
/* a blocking write will continue on to write the data */
}
}
if (DataLength)
{
/********/
/* data */
/********/
rqptr->BytesTx64 += DataLength;
if ((rqptr->rqHeader.Method == HTTP_METHOD_HEAD ||
rqptr->rqResponse.HttpStatus == 304) &&
!rqptr->ProxyTaskPtr)
{
/*****************************/
/* send only response header */
/*****************************/
if (!rqptr->rqResponse.HeaderSent &&
rqptr->rqResponse.HeaderNewlineCount <= 1)
{
/**********************/
/* header from script */
/**********************/
nlcnt = rqptr->rqResponse.HeaderNewlineCount;
cptr = DataPtr;
cnt = DataLength;
while (cnt--)
{
if (*cptr == '\n' && ++nlcnt == 2)
{
/* two successive end-of-lines, therefore end of header */
cptr++;
break;
}
else
if (*cptr != '\r' && *cptr != '\n')
nlcnt = 0;
cptr++;
}
if ((rqptr->rqResponse.HeaderNewlineCount = nlcnt) == 2)
{
/* finally found those two consecutive newlines! */
rqptr->rqResponse.HeaderSent = true;
if (DataLength = cptr - DataPtr)
{
/* adjust data length to include only the HTTP header */
DataLength = cptr - DataPtr;
}
else
{
/* no data in HTTP header left at all */
NetIoWriteStatus (ioptr, AstFunction, rqptr, SS$_NORMAL, 0);
return (SS$_NORMAL);
}
}
}
else
{
/* HTTP header has been completely sent, absorb anything else */
NetIoWriteStatus (ioptr, AstFunction, rqptr, SS$_NORMAL, 0);
return (SS$_NORMAL);
}
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"HEAD !&X !UL", DataPtr, DataLength);
}
if (rqptr->rqResponse.HttpVersion == HTTP_VERSION_0_9 &&
!rqptr->rqResponse.HeaderSent &&
rqptr->rqResponse.HeaderNewlineCount <= 1 &&
!rqptr->ProxyTaskPtr)
{
/*********************************/
/* absorb any header from script */
/*********************************/
int cnt, nlcnt;
char *cptr;
nlcnt = rqptr->rqResponse.HeaderNewlineCount;
cptr = DataPtr;
cnt = DataLength;
while (cnt--)
{
if (*cptr == '\n' && ++nlcnt == 2)
{
/* two successive end-of-lines, therefore end of header */
cptr++;
break;
}
else
if (*cptr != '\r' && *cptr != '\n')
nlcnt = 0;
cptr++;
}
if ((rqptr->rqResponse.HeaderNewlineCount = nlcnt) == 2)
{
/* adjust data pointer and length to exclude header */
rqptr->rqResponse.HeaderSent = true;
DataLength = cptr - DataPtr;
DataPtr = cptr;
}
else
{
/* no data in HTTP header left at all */
NetIoWriteStatus (ioptr, AstFunction, rqptr, SS$_NORMAL, 0);
return (SS$_NORMAL);
}
/* HTTP header has been completely absorbed, send everything else */
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"HTTP/0.9 !&X !UL", DataPtr, DataLength);
}
/*************/
/* send data */
/*************/
if (WATCHING (rqptr, WATCH_RESPONSE_BODY))
{
if (rqptr->rqResponse.HeaderSent)
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_BODY,
"BODY !UL bytes", DataLength);
else
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_BODY,
"STREAM !UL bytes", DataLength);
WatchDataDump (DataPtr, DataLength);
#if WATCH_MOD
if (rqptr->rqResponse.ContentTypePtr &&
!strncmp (rqptr->rqResponse.ContentTypePtr, "text/", 5))
{
if (DataLength && DataPtr[DataLength-1] == '\n')
WatchDataFormatted ("!#AZ", DataLength, DataPtr);
else
WatchDataFormatted ("!#AZ\n", DataLength, DataPtr);
}
#endif /* WATCH_MOD */
}
if (rqptr->rqCache.LoadFromNet)
CacheLoadData (rqptr, DataPtr, DataLength);
if (rqptr->rqResponse.CharsetNcsCf)
{
status = ResponseCharsetConvert (rqptr, &DataPtr, &DataLength);
if (VMSnok (status))
{
/* fudge the status */
NetIoWriteStatus (ioptr, AstFunction, rqptr, status, 0);
return (status);
}
}
}
else
if (DataPtr)
{
/****************/
/* "empty" data */
/****************/
/* without a real network write just fudge the status */
NetIoWriteStatus (ioptr, AstFunction, rqptr, SS$_NORMAL, 0);
return (SS$_NORMAL);
}
else
{
/*****************/
/* end-of-stream */
/*****************/
if (rqptr->GzipCompress.DeflateStartStream &&
!rqptr->GzipCompress.DeflateEndOfStream)
{
/* indicates to GZIP to flush then close the deflate stream */
status = NetWriteGzip (rqptr, AstFunction, NULL, 0);
}
else
if (rqptr->rqResponse.TransferEncodingChunked)
{
/* writes the end-of-content empty chunk */
status = NetWriteChunked (rqptr, AstFunction, NULL, 0);
}
else
{
/* without a real network write just fudge the status */
NetIoWriteStatus (ioptr, AstFunction, rqptr, status = SS$_NORMAL, 0);
}
return (status);
}
/******************/
/* write the data */
/******************/
WritingProxyResponseHeader = rqptr->ProxyTaskPtr &&
rqptr->ProxyTaskPtr->ResponseHeaderPtr &&
!rqptr->rqResponse.HeaderSent;
if (rqptr->rqResponse.ContentEncodeAsGzip && !WritingProxyResponseHeader)
status = NetWriteGzip (rqptr, AstFunction, DataPtr, DataLength);
else
if (rqptr->rqResponse.TransferEncodingChunked && !WritingProxyResponseHeader)
status = NetWriteChunked (rqptr, AstFunction, DataPtr, DataLength);
else
if (!DataLength)
NetIoWriteStatus (ioptr, AstFunction, rqptr, status = SS$_NORMAL, 0);
else
status = NetIoWrite (ioptr, AstFunction, rqptr, DataPtr, DataLength);
return (status);
}
/*****************************************************************************/
/*
The response content is being "Content-Encoding: gzip"ed. Due to the way the
ZLIB compressed multiple consecutive input buffers before providing multiple
consecutive output buffers this routine must be able to handle both independent
of any other processing in the response. It may AST to NetWriteGzipAst()
multiple times when outputing compressed data. It ASTs to 'AstFunction'
(usually for more raw data) when any output ceases.
*/
NetWriteGzip
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction,
char *DataPtr,
int DataLength
)
{
int status,
BufferSize,
OutDataLength,
SanityCount;
char *OutDataPtr;
GZIP_COMPRESS *gzptr;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"NetWriteGzip() !&X !UL !&A",
DataPtr, DataLength, AstFunction);
gzptr = &rqptr->GzipCompress;
ioptr = rqptr->NetIoPtr;
ioptr->WatchItem = rqptr->WatchItem;
/* intermediate update to data transfer stats */
rqptr->NetIoPtr->BlocksRawTx64 = ioptr->BlocksRawTx64;
rqptr->NetIoPtr->BytesRawTx64 = ioptr->BytesRawTx64;
if (!gzptr->DeflateStartStream)
{
if (DataLength <= OutputBufferSize)
BufferSize = OutputBufferSize;
else
BufferSize = DataLength + (DataLength / 100) + 32;
BufferSize &= 0x0000ffff;
GzipDeflateBegin (rqptr, gzptr, BufferSize);
}
/* blocking I/O may require multiple writes */
SanityCount = 0;
for (;;)
{
/* if we didn't have or somehow have lost the zlib stream */
if (!gzptr->DeflateZstreamPtr) break;
if (!GzipDeflate (rqptr, gzptr,
&DataPtr, &DataLength,
&OutDataPtr, &OutDataLength)) break;
if (OutDataLength)
{
/* if non-blocking I/O then AST back here (eventually) for any more */
if (AstFunction)
{
rqptr->rqNet.GzipDataPtr = DataPtr;
rqptr->rqNet.GzipDataLength = DataLength;
rqptr->rqNet.GzipAstFunction = AstFunction;
AstFunction = NetWriteGzipAst;
}
if (rqptr->rqResponse.TransferEncodingChunked)
status = NetWriteChunked (rqptr, AstFunction,
OutDataPtr, OutDataLength);
else
status = NetIoWrite (ioptr, AstFunction, rqptr,
OutDataPtr, OutDataLength);
if (AstFunction) return (status);
}
else
if (!DataLength)
{
/* nothing still to input, nothing to write, fudge it */
NetIoWriteStatus (ioptr, AstFunction, rqptr, SS$_WASECC, 0);
return (SS$_NORMAL);
}
if (SanityCount++ > 100)
{
/* don't quite trust my logic! */
ErrorNoticed (rqptr, SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
break;
}
}
/* only ever breaks from the loop on an error */
NetIoWriteStatus (ioptr, AstFunction, rqptr, SS$_ABORT, 0);
return (SS$_ABORT);
}
/*****************************************************************************/
/*
AST delivered by asynchronous I/O initiated by NetWriteGzip(). Checks the
status of the network write and if OK reassembles the parameters required when
calling NetWriteGzip().
*/
NetWriteGzipAst (REQUEST_STRUCT *rqptr)
{
int DataLength;
char *DataPtr;
NETIO_STRUCT *ioptr;
REQUEST_AST AstFunction;
/*********/
/* begin */
/*********/
ioptr = rqptr->NetIoPtr;
ioptr->WatchItem = rqptr->WatchItem;
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"NetWriteGzipAst() !&F !&S !&X !UL !&A", NetWriteGzipAst,
ioptr->WriteStatus,
rqptr->rqNet.GzipDataPtr,
rqptr->rqNet.GzipDataLength,
rqptr->rqNet.GzipAstFunction);
DataPtr = rqptr->rqNet.GzipDataPtr;
DataLength = rqptr->rqNet.GzipDataLength;
AstFunction = rqptr->rqNet.GzipAstFunction;
rqptr->rqNet.GzipDataPtr =
rqptr->rqNet.GzipDataLength =
rqptr->rqNet.GzipAstFunction = 0;
if (VMSok (ioptr->WriteStatus))
NetWriteGzip (rqptr, AstFunction, DataPtr, DataLength);
else
NetIoWriteStatus (ioptr, AstFunction, rqptr, ioptr->WriteStatus, 0);
}
/*****************************************************************************/
/*
The response is being "Transfer-Encoding: chunked".
This is a little more complicated than it might have been in order improve the
efficiency of non-encrypted (non-SSL) network I/O.
In the case of encrypted data a separate chunk buffer is allocated. In this
buffer the chunk size string is placed, followed by a copy of the data, and
then the required trailing arriage control. This involves the expensive
copying of often large quantities of data, the reason why for non-encrypted
data the buffer list is used, avoiding this processing overhead.
*/
NetWriteChunked
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction,
char *DataPtr,
int DataLength
)
{
static char ChunkBuf [32];
static $DESCRIPTOR (ChunkBufDsc, ChunkBuf);
static $DESCRIPTOR (ChunkFaoDsc, "!XL\r\n\0");
int size, status;
char *cptr, *sptr;
NETIO_STRUCT *ioptr;
VMS_ITEM_LIST2 *p5ptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET, "NetWriteChunked()");
ioptr = rqptr->NetIoPtr;
ioptr->WatchItem = rqptr->WatchItem;
/* intermediate update to data transfer stats */
rqptr->NetIoPtr->BlocksRawTx64 = ioptr->BlocksRawTx64;
rqptr->NetIoPtr->BytesRawTx64 = ioptr->BytesRawTx64;
if (WATCHING (rqptr, WATCH_NETWORK_OCTETS))
WatchThis (WATCHITM(rqptr), WATCH_NETWORK,
"CHUNK !UL bytes", DataLength);
/* if it's the zero-length chunk (end-of-stream) then it is no longer */
if (!DataLength) rqptr->rqResponse.TransferEncodingChunked = false;
size = rqptr->rqResponse.ChunkedBufferSize;
sptr = rqptr->rqResponse.ChunkedBufferPtr;
if (DataLength > size || !sptr)
{
while (DataLength > size) size += OutputBufferSize;
if (sptr) VmFreeFromHeap (rqptr, sptr, FI_LI);
sptr = VmGetHeap (rqptr, size + sizeof(ChunkBuf));
rqptr->rqResponse.ChunkedBufferPtr = sptr;
rqptr->rqResponse.ChunkedBufferSize = size;
}
sys$fao (&ChunkFaoDsc, 0, &ChunkBufDsc, DataLength);
for (cptr = ChunkBuf; *cptr; *sptr++ = *cptr++);
for (cptr = DataPtr; DataLength--; *sptr++ = *cptr++);
*sptr++ = '\r';
*sptr++ = '\n';
DataPtr = rqptr->rqResponse.ChunkedBufferPtr;
DataLength = sptr - rqptr->rqResponse.ChunkedBufferPtr;
status = NetIoWrite (rqptr->NetIoPtr, AstFunction, rqptr,
DataPtr, DataLength);
return (status);
}
/*****************************************************************************/
/*
Write data directly to the network. No fancy stuff.
*/
int NetWriteRaw
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction,
char *DataPtr,
int DataLength
)
{
int status;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"NetWriteRaw() !&A !&X !UL", AstFunction, DataPtr, DataLength);
ioptr = rqptr->NetIoPtr;
ioptr->WatchItem = rqptr->WatchItem;
status = NetIoWrite (ioptr, AstFunction, rqptr, DataPtr, DataLength);
return (status);
}
/*****************************************************************************/
/*
*/
int NetRead
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction,
char *DataPtr,
int DataSize
)
{
int status;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET, "NetRead() !&A !&X !UL",
AstFunction, DataPtr, DataSize);
ioptr = rqptr->NetIoPtr;
ioptr->WatchItem = rqptr->WatchItem;
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
{
NetIoReadStatus (ioptr, AstFunction, rqptr, SS$_ABORT, 0);
return (SS$_ABORT);
}
/* intermediate update to data transfer stats */
rqptr->NetIoPtr->BlocksRawRx64 = ioptr->BlocksRawRx64;
rqptr->NetIoPtr->BytesRawRx64 = ioptr->BytesRawRx64;
if (rqptr->rqNet.RedactBufferPtr)
{
int ReadCount = rqptr->rqNet.RedactBufferSize -
rqptr->rqNet.RedactBufferCount;
char *RedactBufferPtr = rqptr->rqNet.RedactBufferPtr +
rqptr->rqNet.RedactBufferCount;
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET, "REDACT !UL-!UL=!UL",
rqptr->rqNet.RedactBufferSize,
rqptr->rqNet.RedactBufferCount,
ReadCount);
if (ReadCount >= DataSize)
{
/* redact buffer (still) contains more than a network buffer */
status = SS$_NORMAL;
ReadCount = DataSize;
memcpy (DataPtr, RedactBufferPtr, ReadCount);
rqptr->rqNet.RedactBufferCount += ReadCount;
}
else
if (ReadCount)
{
/* whatever is remaining */
status = SS$_NORMAL;
memcpy (DataPtr, RedactBufferPtr, ReadCount);
rqptr->rqNet.RedactBufferCount += ReadCount;
}
else
{
/* redact buffer has been completely read */
status = SS$_ENDOFFILE;
ReadCount = 0;
}
NetIoReadStatus (ioptr, AstFunction, rqptr, status, ReadCount);
return (status);
}
if (rqptr->ServicePtr->ProxyTunnel == PROXY_TUNNEL_RAW &&
/* prevent %CC-E-NOEQUALITY under VAX VMS V7.3 and DECC V6.4 */
(void*)AstFunction == (void*)RequestGet)
{
/*
For raw proxy tunneling, we need to send a connect request to
the origin server immediately since the client will wait until it
receives the server welcome message. This should be done only once
upon SSL handshake completion.
*/
/* fudge these as if it came from the network */
NetIoReadStatus (ioptr, RequestGet, rqptr, SS$_NORMAL, 0);
return (SS$_NORMAL);
}
status = NetIoRead (ioptr, AstFunction, rqptr, DataPtr, DataSize);
return (status);
}
/*****************************************************************************/
/*
This function buffers output without actually sending it to the client until
ready, either when the first buffer fills or when all output is completely
buffered. It will store any amount of output in a linked list of separately
allocated descriptors. This is useful when a function that must not be
interrupted can rapidly store all required output without being slowed by
actually transfering it on the network, then flush it all asynchronously (e.g.
the server administration reports, for instance CacheReport(), which are
blocking).
If the data pointer is not NULL and the data length is -1 then the data is
assumed to be a null-terminated string.
Providing an AST parameter and a data parameter implies that after the first
buffer fills (and usually overflows into a second) the current buffered output
should be written to the client.
Providing an AST parameter and setting the data parameter to NULL and
the data length to 0 indicates all the currently buffered contents should be
written to the client.
Providing an AST parameter and setting the data parameter to NULL and the data
length parameter to -1 indicates all the currently buffered contents should be
written to the client if more than buffer-full has been written, otherwise just
declare the AST.
Providing all parameters as NULL and zero, (except 'rqptr') as appropriate,
results in the data buffer initialized (if it didn't exist) or reset (if it
did).
*/
void NetWriteBuffered
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction,
char *DataPtr,
int DataLength
)
{
int status;
char *BufferPtr;
STR_DSC *sdptr;
STR_DSC_AUTO (DataDsc);
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
{
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"NetWriteBuffered() !UL !&A !&X !SL",
rqptr->RequestState, AstFunction, DataPtr, DataLength);
WatchDataDump (DataPtr, DataLength);
}
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
{
NetIoWriteStatus (rqptr->NetIoPtr, AstFunction, rqptr, SS$_ABORT, 0);
return;
}
/* if all parameters empty */
if (!AstFunction && !DataPtr && !DataLength)
{
/* reset the descriptor */
if (STR_DSC_SANITY(&rqptr->NetWriteBufferDsc))
{
/* if there is data in the descriptor write it blocking */
if (STR_DSC_LEN (&rqptr->NetWriteBufferDsc))
NetWriteStrDsc (rqptr, NULL);
StrDscNoContent (&rqptr->NetWriteBufferDsc);
}
else
StrDscBegin (rqptr, &rqptr->NetWriteBufferDsc, OutputBufferSize);
return;
}
if (DataPtr && DataLength)
{
/**********************/
/* buffer this output */
/**********************/
if (!STR_DSC_SANITY(&rqptr->NetWriteBufferDsc))
StrDscBegin (rqptr, &rqptr->NetWriteBufferDsc, OutputBufferSize);
if (rqptr->NetWriteEscapeHtml)
{
if (DataLength == -1)
StrDscBuildHtmlEscape (&rqptr->NetWriteBufferDsc, NULL, DataPtr);
else
{
StrDscThis (NULL, &DataDsc, DataPtr, DataLength);
StrDscBuildHtmlEscape (&rqptr->NetWriteBufferDsc, &DataDsc, NULL);
}
}
else
{
if (DataLength == -1)
StrDscBuild (&rqptr->NetWriteBufferDsc, NULL, DataPtr);
else
{
StrDscThis (NULL, &DataDsc, DataPtr, DataLength);
StrDscBuild (&rqptr->NetWriteBufferDsc, &DataDsc, NULL);
}
}
}
/* if an AST routine supplied then we can think about buffer flushing */
if (!AstFunction) return;
if (!DataPtr && DataLength != -1)
{
/*************************/
/* flush is being forced */
/*************************/
NetWriteStrDsc (rqptr, AstFunction);
return;
}
if (STR_DSC_LEN(&rqptr->NetWriteBufferDsc) >=
STR_DSC_SIZE(&rqptr->NetWriteBufferDsc))
{
/************************/
/* first buffer is full */
/************************/
rqptr->NetWriteFlushOnly = true;
NetWriteStrDsc (rqptr, AstFunction);
return;
}
/************************/
/* just declare the AST */
/************************/
/* fudge this status for the AST routine check */
NetIoWriteStatus (rqptr->NetIoPtr, AstFunction, rqptr, SS$_NORMAL, 0);
}
/*****************************************************************************/
/*
Synchronous (no AST function supplied) or asynchronous write of a WASD string
descriptor or linked list of string descriptors. Where multiple writes are
required this function will be delivered to as an AST (and then the
'AstFunction' parameter is ignored).
*/
void NetWriteStrDsc
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction
)
{
BOOL BlockingWrite;
int DataLength;
char *DataPtr,
*EndPtr;
NETIO_STRUCT *ioptr;
STR_DSC *sdptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET,
"NetWriteStrDsc() !&F !&A", &NetWriteStrDsc,
rqptr->NetWriteAstFunction);
ioptr = rqptr->NetIoPtr;
ioptr->WatchItem = rqptr->WatchItem;
/* loop for (possible) blocking write */
BlockingWrite = false;
for (;;)
{
if (BlockingWrite || rqptr->NetWriteAstFunction)
{
/* blocking write loop or AST delivery */
if (VMSnok (ioptr->WriteStatus))
{
/* network write has failed, bail out now */
NetIoWriteStatus (ioptr, rqptr->NetWriteAstFunction, rqptr,
ioptr->WriteStatus, 0);
rqptr->NetWriteAstFunction = NULL;
StrDscNoContent (&rqptr->NetWriteBufferDsc);
return;
}
/* find the descriptor having content */
STR_DSC_ITERATE (sdptr, &rqptr->NetWriteBufferDsc)
if (STR_DSC_LEN(sdptr)) break;
if (!sdptr) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
else
{
/* initial call */
if (!rqptr) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
BlockingWrite = !(rqptr->NetWriteAstFunction = AstFunction);
rqptr->NetWriteBufferCount = 0;
sdptr = &rqptr->NetWriteBufferDsc;
}
EndPtr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
DataPtr = STR_DSC_PTR(sdptr) + rqptr->NetWriteBufferCount;
DataLength = EndPtr - DataPtr;
rqptr->NetWriteBufferCount += DataLength;
if (!BlockingWrite) AstFunction = &NetWriteStrDsc;
if (rqptr->NetWriteBufferCount >= STR_DSC_LEN(sdptr))
{
/* this is the final write for this descriptor */
rqptr->NetWriteBufferCount = STR_DSC_LEN(sdptr) = 0;
if (rqptr->NetWriteFlushOnly)
{
/* output all (if multiple) leading full descriptors */
if (!STR_DSC_NEXT(sdptr) ||
STR_DSC_LEN(STR_DSC_NEXT(sdptr)) <
STR_DSC_SIZE(STR_DSC_NEXT(sdptr)))
{
/* less than full (or none at all) */
rqptr->NetWriteFlushOnly = false;
if (STR_DSC_NEXT(sdptr))
{
/* swap the now-emptied and partially filled storage */
StrDscStorageSwap (&rqptr->NetWriteBufferDsc,
STR_DSC_NEXT(sdptr));
}
sdptr = NULL;
}
}
else
{
/* find the next (if any) descriptor having content */
for (sdptr = STR_DSC_NEXT(sdptr); sdptr; sdptr = STR_DSC_NEXT(sdptr))
if (STR_DSC_LEN(sdptr)) break;
}
if (!sdptr)
{
/* final write entirely */
AstFunction = rqptr->NetWriteAstFunction;
rqptr->NetWriteAstFunction = NULL;
BlockingWrite = false;
}
}
NetWrite (rqptr, AstFunction, DataPtr, DataLength);
if (!BlockingWrite || AstFunction) return;
}
}
/*****************************************************************************/
/*
This function MUST be called with the global section ALREADY locked.
Increment or decrement the counters of current network connections. Account
for HTTP/2 and HTTP/1.n connections separately. Global storage represents data
of the running image and process (i.e. this instance) and accounting data
the server overall (where multiple instances are deployed).
*/
void NetUpdateConnected
(
void *DataPtr,
int MoreOrLess
)
{
int idx, tot1, tot2;
ACCOUNTING_STRUCT *accptr;
HTTP2_STRUCT *h2ptr = NULL;
REQUEST_STRUCT *rqptr = NULL;
/*********/
/* begin */
/*********/
accptr = AccountingPtr;
if (!DataPtr)
h2ptr = rqptr = NULL;
else
if (((LIST_ENTRY*)DataPtr)->DataType == LIST_ENTRY_TYPE_HTTP2)
h2ptr = (HTTP2_STRUCT*)DataPtr;
else
if (((LIST_ENTRY*)DataPtr)->DataType == LIST_ENTRY_TYPE_REQUEST)
rqptr = (REQUEST_STRUCT*)DataPtr;
/* else an accepted connection is not a "request" until RequestBegin() */
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetUpdateConnected() !SL !AZ !UL+!UL=!UL",
MoreOrLess, h2ptr ? "HTTP/2" : "HTTP/1.n",
NetCurrentConnected[HTTP1], NetCurrentConnected[HTTP2],
NetCurrentConnected[HTTP12]);
if (MoreOrLess > 0)
{
/************/
/* one more */
/************/
if (rqptr)
{
NetCurrentConnected[HTTP1]++;
accptr->ConnectCount[HTTP1]++;
accptr->CurrentInstanceConnected[HTTP1][InstanceNumber]++;
/* total connections only increase with HTTP/1.n */
accptr->ConnectCount[HTTP12]++;
}
else
if (h2ptr)
{
NetCurrentConnected[HTTP2]++;
accptr->ConnectCount[HTTP2]++;
accptr->CurrentInstanceConnected[HTTP2][InstanceNumber]++;
}
else
ErrorNoticed (NULL, SS$_BUGCHECK, NULL, FI_LI);
}
else
if (MoreOrLess < 0)
{
/************/
/* one less */
/************/
if (rqptr)
{
if (NetCurrentConnected[HTTP1]) NetCurrentConnected[HTTP1]--;
if (accptr->CurrentInstanceConnected[HTTP1][InstanceNumber])
accptr->CurrentInstanceConnected[HTTP1][InstanceNumber]--;
}
else
if (h2ptr)
{
if (NetCurrentConnected[HTTP2]) NetCurrentConnected[HTTP2]--;
if (accptr->CurrentInstanceConnected[HTTP2][InstanceNumber])
accptr->CurrentInstanceConnected[HTTP2][InstanceNumber]--;
}
else
ErrorNoticed (NULL, SS$_BUGCHECK, NULL, FI_LI);
}
/* else if zero then just drop through to re-accumulate accounting */
/**************/
/* accumulate */
/**************/
NetCurrentConnected[HTTP12] = NetCurrentConnected[HTTP1] +
NetCurrentConnected[HTTP2];
for (tot1 = tot2 = idx = 0; idx <= InstanceNodeCurrent; idx++)
{
tot1 += accptr->CurrentInstanceConnected[HTTP1][idx];
tot2 += accptr->CurrentInstanceConnected[HTTP2][idx];
}
if (NetCurrentConnected[HTTP1] > accptr->ConnectPeak[HTTP1])
accptr->ConnectPeak[HTTP1] = NetCurrentConnected[HTTP1];
accptr->CurrentConnected[HTTP1] = tot1;
if (tot1 > accptr->ConnectPeak[HTTP1]) accptr->ConnectPeak[HTTP1] = tot1;
if (NetCurrentConnected[HTTP2] > accptr->ConnectPeak[HTTP2])
accptr->ConnectPeak[HTTP2] = NetCurrentConnected[HTTP2];
accptr->CurrentConnected[HTTP2] = tot2;
if (tot2 > accptr->ConnectPeak[HTTP2]) accptr->ConnectPeak[HTTP2] = tot2;
accptr->CurrentConnected[HTTP12] = tot1 + tot2;
if (accptr->CurrentConnected[HTTP12] > accptr->ConnectPeak[HTTP12])
accptr->ConnectPeak[HTTP12] = accptr->CurrentConnected[HTTP12];
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!AZ!AZ!UL+!UL=!UL !UL+!UL=!UL",
h2ptr ? "HTTP/2 " : "",
rqptr ? "HTTP/1.n " : "",
NetCurrentConnected[HTTP1], NetCurrentConnected[HTTP2],
NetCurrentConnected[HTTP12], tot1, tot2,
accptr->CurrentConnected[HTTP12]);
}
/*****************************************************************************/
/*
This function MUST be called with the global section ALREADY locked.
Increment or decrement the current count of persistent connections.
*/
void NetUpdatePersistent (int MoreOrLess)
{
int idx, tot1;
ACCOUNTING_STRUCT *accptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetUpdatePersistent() !SL !UL",
MoreOrLess, NetCurrentHttp1Persistent);
accptr = AccountingPtr;
if (MoreOrLess > 0)
{
NetCurrentHttp1Persistent++;
accptr->CurrentPersistentHttp1[InstanceNumber]++;
}
else
if (MoreOrLess < 0)
{
if (NetCurrentHttp1Persistent) NetCurrentHttp1Persistent--;
if (accptr->CurrentPersistentHttp1[InstanceNumber])
accptr->CurrentPersistentHttp1[InstanceNumber]--;
}
/* else if zero then just drop through to re-accumulate accounting */
for (tot1 = idx = 0; idx <= InstanceNodeCurrent; idx++)
tot1 += accptr->CurrentPersistentHttp1[idx];
accptr->CurrentHttp1Persistent = tot1;
if (accptr->CurrentHttp1Persistent > accptr->ConnectPeakPersistent)
accptr->ConnectPeakPersistent = accptr->CurrentHttp1Persistent;
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!UL !UL",
NetCurrentHttp1Persistent, tot1);
}
/*****************************************************************************/
/*
This function MUST be called with the global section ALREADY locked.
Increment or decrement the counters of currently processing requests. Account
for HTTP/2 and HTTP/1.n requests separately. Global storage represents data of
the running image and process (i.e. this instance) and accounting data the
server overall (where multiple instances are deployed).
*/
void NetUpdateProcessing
(
void *DataPtr,
int MoreOrLess
)
{
int idx, tot1, tot2;
ACCOUNTING_STRUCT *accptr;
HTTP2_STRUCT *h2ptr = NULL;
REQUEST_STRUCT *rqptr = NULL;
/*********/
/* begin */
/*********/
accptr = AccountingPtr;
if (!DataPtr)
h2ptr = rqptr = NULL;
else
if (((LIST_ENTRY*)DataPtr)->DataType == LIST_ENTRY_TYPE_REQUEST)
{
rqptr = (REQUEST_STRUCT*)DataPtr;
if (h2ptr = rqptr->Http2Stream.Http2Ptr) rqptr = NULL;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetUpdateProcessing() !SL !AZ !UL+!UL=!UL",
MoreOrLess, h2ptr ? "HTTP/2" : "HTTP/1.n",
NetCurrentProcessing[HTTP1], NetCurrentProcessing[HTTP2],
NetCurrentProcessing[HTTP12]);
if (MoreOrLess > 0)
{
/************/
/* one more */
/************/
InstanceStatusRequestCount++;
accptr->ProcessingTotalCount[HTTP12]++;
if (rqptr)
{
NetCurrentProcessing[HTTP1]++;
accptr->ProcessingTotalCount[HTTP1]++;
accptr->CurrentInstanceProcessing[HTTP1][InstanceNumber]++;
if (rqptr->WebSocketRequest)
{
WebSockCurrent++;
accptr->CurrentWebSockets[InstanceNumber]++;
}
if (rqptr->ServicePtr->RequestScheme == SCHEME_HTTPS)
AccountingPtr->RequestSSLCount++;
}
else
if (h2ptr)
{
NetCurrentProcessing[HTTP2]++;
accptr->ProcessingTotalCount[HTTP2]++;
accptr->CurrentInstanceProcessing[HTTP2][InstanceNumber]++;
if (h2ptr->ServicePtr->RequestScheme == SCHEME_HTTPS)
AccountingPtr->RequestSSLCount++;
}
else
ErrorNoticed (NULL, SS$_BUGCHECK, NULL, FI_LI);
}
else
if (MoreOrLess < 0)
{
/************/
/* one less */
/************/
if (rqptr)
{
if (NetCurrentProcessing[HTTP1]) NetCurrentProcessing[HTTP1]--;
if (accptr->CurrentInstanceProcessing[HTTP1][InstanceNumber])
accptr->CurrentInstanceProcessing[HTTP1][InstanceNumber]--;
if (rqptr->WebSocketRequest)
{
if (WebSockCurrent) WebSockCurrent--;
if (accptr->CurrentWebSockets[InstanceNumber])
accptr->CurrentWebSockets[InstanceNumber]--;
}
}
else
if (h2ptr)
{
if (NetCurrentProcessing[HTTP2]) NetCurrentProcessing[HTTP2]--;
if (accptr->CurrentInstanceProcessing[HTTP2][InstanceNumber])
accptr->CurrentInstanceProcessing[HTTP2][InstanceNumber]--;
}
else
ErrorNoticed (NULL, SS$_BUGCHECK, NULL, FI_LI);
}
/* else if zero then just drop through to re-accumulate accounting */
/**************/
/* accumulate */
/**************/
NetCurrentProcessing[HTTP12] = NetCurrentProcessing[HTTP1] +
NetCurrentProcessing[HTTP2];
for (tot1 = tot2 = idx = 0; idx <= InstanceNodeCurrent; idx++)
{
tot1 += accptr->CurrentInstanceProcessing[HTTP1][idx];
tot2 += accptr->CurrentInstanceProcessing[HTTP2][idx];
}
accptr->CurrentProcessing[HTTP1] = tot1;
if (tot1 > accptr->ProcessingPeak[HTTP1])
accptr->ProcessingPeak[HTTP1] = tot1;
accptr->CurrentProcessing[HTTP2] = tot2;
if (tot2 > accptr->ProcessingPeak[HTTP2])
accptr->ProcessingPeak[HTTP2] = tot2;
accptr->CurrentProcessing[HTTP12] = tot1 + tot2;
if (accptr->CurrentProcessing[HTTP12] > accptr->ProcessingPeak[HTTP12])
accptr->ProcessingPeak[HTTP12] = accptr->CurrentProcessing[HTTP12];
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "!UL+!UL=!UL !UL+!UL=!UL",
NetCurrentProcessing[HTTP1], NetCurrentProcessing[HTTP2],
NetCurrentProcessing[HTTP12], tot1, tot2,
accptr->CurrentProcessing[HTTP12]);
}
/*****************************************************************************/
/*
Respond direct to the client without beginning request processing. Read
something from the client, they seem to enjoy (need) that! These responses
are completely independent of the main request processing life-cycle. These
functions should only be used from NetAcceptProcess()!!
*/
NetDirectResponse
(
NETIO_STRUCT *ioptr,
int Message
)
{
static $DESCRIPTOR (BufferDsc, "");
static $DESCRIPTOR (TooBusyFaoDsc,
"HTTP/1.1 503 Too busy!!\r\n\
Content-Type: text/html!AZ!AZ\r\n\
Connection: close\r\n\
\r\n\
!AZ\
<html>\n\
<head>\n\
<title>!AZ 503</title>\n\
</head>\n\
!AZ\n\
!AZ\n\
</body>\n\
</html>\n");
static $DESCRIPTOR (ForbiddenFaoDsc,
"HTTP/1.1 403 Forbidden\r\n\
Content-Type: text/html!AZ!AZ\r\n\
Connection: close\r\n\
\r\n\
!AZ\
<html>\n\
<head>\n\
<title>!AZ 403</title>\n\
</head>\n\
!AZ\n\
!AZ\n\
</body>\n\
</html>\n");
int status;
short Length;
IO_SB IOsb;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetDirectResponse() !UL", Message);
status = sys$setimr (0, &Delta05Sec,
&NetDirectResponseTimeoutAst, ioptr, 0);
if (VMSnok (status))
{
ErrorNoticed (NULL, status, NULL, FI_LI);
sys$dassgn (ioptr->Channel);
VmFree (ioptr, FI_LI);
return;
}
ioptr->ReadPtr = VmGet (NetReadBufferSize);
BufferDsc.dsc$a_pointer = ioptr->ReadPtr;
BufferDsc.dsc$w_length = NetReadBufferSize;
if (Message == MSG_GENERAL_ACCESS_DENIED)
sys$fao (&ForbiddenFaoDsc, &Length, &BufferDsc,
Config.cfContent.CharsetDefault[0] ? "; charset=" : "",
Config.cfContent.CharsetDefault,
WASD_DOCTYPE,
MsgFor (NULL, MSG_STATUS_ERROR),
REPORT_BODY_TAG,
MsgFor (NULL, MSG_GENERAL_ACCESS_DENIED));
else
if (Message == MSG_GENERAL_TOO_BUSY)
sys$fao (&TooBusyFaoDsc, &Length, &BufferDsc,
Config.cfContent.CharsetDefault[0] ? "; charset=" : "",
Config.cfContent.CharsetDefault,
WASD_DOCTYPE,
MsgFor (NULL, MSG_STATUS_ERROR),
REPORT_BODY_TAG,
MsgFor (NULL, MSG_GENERAL_TOO_BUSY));
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
status = sys$qiow (EfnWait, ioptr->Channel,
IO$_WRITEVBLK | IO$M_NOWAIT,
&IOsb, 0, 0, ioptr->ReadPtr, Length,
0, 0, 0, 0);
if (VMSok (status)) status = IOsb.Status;
if (VMSok (status))
{
status = sys$qio (EfnNoWait, ioptr->Channel,
IO$_READVBLK, &ioptr->WriteIOsb,
&NetDirectResponseAst, ioptr,
ioptr->ReadPtr, NetReadBufferSize,
0, 0, 0, 0);
if (VMSnok (status)) ErrorNoticed (NULL, status, NULL, FI_LI);
}
else
ErrorNoticed (NULL, status, NULL, FI_LI);
if (VMSnok (status))
{
VmFree (ioptr->ReadPtr, FI_LI);
NetIoEnd (ioptr);
}
}
/*****************************************************************************/
/*
See commentary in NetDirectResponse().
*/
NetDirectResponseAst (NETIO_STRUCT *ioptr)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetDirectResponseAst()");
sys$cantim (ioptr, 0);
VmFree (ioptr->ReadPtr, FI_LI);
NetIoEnd (ioptr);
}
/*****************************************************************************/
/*
See commentary in NetDirectResponse().
*/
NetDirectResponseTimeoutAst (NETIO_STRUCT *ioptr)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetDirectResponseTimeoutAst()");
sys$cancel (ioptr->Channel);
}
/*****************************************************************************/
/*
Activate a network agent (DCL script) to perform a function. ASYNCHRONOUS!
A network agent is primarily to allow an assessment of a connection and whether
that should be dropped. A network agent, like a lookup agent, is way to early
to have an associated request.
*/
void NetAgentBegin (NETIO_STRUCT *ioptr)
{
int status;
char *sptr;
CLIENT_STRUCT *clptr;
REQUEST_STRUCT *rqptr;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetAgentBegin()");
clptr = ioptr->ClientPtr;
if (NetAgentActiveCount >= NetAgentActiveMax)
{
/* busy, busy, busy ... requeue for a delayed subsequent attempt */
if (clptr->AgentBusyCount++ <= NetAgentBusyMax)
{
if (clptr->AgentBusyCount <= NetAgentBusyMax / 4)
SysDclAst (NetAgentBegin, ioptr);
else
sys$setimr (0, &Delta100mSec, &NetAgentBegin, ioptr, 0);
return;
}
else
{
ErrorNoticed (NULL, SS$_TOOMANYREDS, "!UL exceeded (!UL)",
FI_LI, NetAgentBusyMax, NetAgentBusyLimit);
NetAgentBusyCount++;
clptr->AgentResponsePtr = sptr = VmGet (64);
strcpy (sptr, "500 ");
strcat (sptr, ProblemAcceptAgent);
SysDclAst (NetAcceptProcess, ioptr);
return;
}
}
if (clptr->AgentBusyCount)
{
if (clptr->AgentBusyCount > NetAgentBusyLimit)
NetAgentBusyLimit = clptr->AgentBusyCount;
clptr->AgentBusyCount = 0;
}
/************/
/* continue */
/************/
svptr = ioptr->ServicePtr;
rqptr = DclFauxRequest (NULL, NULL, NULL);
/* use these rather than the stubs created by DclFauxRequest() */
rqptr->ClientPtr = clptr;
rqptr->ServicePtr = svptr;
rqptr->AgentAstParam = ioptr;
clptr->AgentRequestPtr = VmGet(64);
strcpy (clptr->AgentRequestPtr, "*");
rqptr->AgentRequestPtr = VmGetHeap (rqptr, strlen(clptr->AgentRequestPtr));
strcpy (rqptr->AgentRequestPtr, clptr->AgentRequestPtr);
rqptr = DclFauxRequest (rqptr, NetAcceptAgentScript, &NetAgentEnd);
if (!rqptr)
{
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_NETWORK, "AGENT !AZ", NetAcceptAgentScript);
ErrorNoticed (NULL, SS$_ABORT, ProblemAcceptAgent, FI_LI);
clptr->AgentResponsePtr = sptr = VmGet (64);
strcpy (sptr, "500 ");
strcat (sptr, ProblemAcceptAgent);
SysDclAst (NetAcceptProcess, ioptr);
return;
}
NetAgentActiveCount++;
rqptr->AgentRequestPtr = clptr->AgentRequestPtr;
}
/*****************************************************************************/
/*
The agent (DCL script) has completed.
*/
void NetAgentEnd (REQUEST_STRUCT *rqptr)
{
int count, status;
char *cptr, *sptr, *zptr;
CLIENT_STRUCT *clptr;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetAgentEnd()");
ioptr = (NETIO_STRUCT*)rqptr->AgentAstParam;
clptr = ioptr->ClientPtr;
if (cptr = rqptr->AgentResponsePtr)
{
for (sptr = cptr; *sptr; sptr++);
clptr->AgentResponsePtr = sptr = VmGet (sptr - cptr);
while (*cptr) *sptr++ = *cptr++;
}
else
{
clptr->AgentResponsePtr = sptr = VmGet (64);
strcpy (sptr, "500 ");
strcat (sptr, ProblemAcceptAgent);
ErrorNoticed (NULL, SS$_ABORT, ProblemAcceptAgent, FI_LI);
}
SysDclAst (NetAcceptProcess, ioptr);
if (NetAgentActiveCount) NetAgentActiveCount--;
/* remove from any supervisory list */
HttpdSupervisorList (rqptr, -1);
VmFreeRequest (rqptr, FI_LI);
}
/*****************************************************************************/
/*
Called by HttpdTick() every minute to continuously break network connections
using NetTestBreak(). The logical name WASD_NET_TEST_BREAK contains one or
more single-digit integers used to call NetTestBreak() every five seconds after
the minute.
*/
#if WATCH_MOD
void NetTestSupervisor ()
{
static char *nptr = "";
int status;
ulong number, seconds;
char *cptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetTestSupervisor()");
if (!(cptr = SysTrnLnm (WASD_NET_TEST_BREAK))) return;
if (!*nptr) nptr = cptr;
while (*nptr && !isdigit(*nptr)) nptr++;
number = atoi(nptr);
while (isdigit(*nptr)) nptr++;
status = sys$setimr (0, &Delta05Sec, NetTestBreak, number, 0);
if (VMSnok (status)) ErrorNoticed (NULL, status, NULL, FI_LI);
}
#endif /* WATCH_MOD */
/*****************************************************************************/
/*
This function is used to break every /nth/ network connection simply by
deassigning the network channel.
It is used on the development/test bench to see how the server behaves when
network connections are abruptly broken. Any HTTP/2 request in progress has
the underlying HTTP/2 connection broken (and so may take-out multiple requests).
A selective sledgehammer!
*/
#if WATCH_MOD
#include "sesola.h"
void NetTestBreak (int every)
{
int count, total;
HTTP2_STRUCT *h2ptr;
LIST_ENTRY *leptr;
NETIO_STRUCT *ioptr;
REQUEST_STRUCT *rqeptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetTestBreak()");
if (every <= 0) every = 1;
count = total = 0;
for (leptr = RequestList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
if (++count % every) continue;
rqeptr = (REQUEST_STRUCT*)leptr;
/* do not kill WATCHing request */
if (rqeptr == Watch.RequestPtr) continue;
ioptr = rqeptr->NetIoPtr;
if (ioptr->Http2StreamPtr) continue;
if (rqeptr->rqHeader.RequestUriPtr)
WatchThis (WATCHITM(rqeptr), WATCH_NETWORK, "BREAK1 !AZ !AZ !AZ",
rqeptr->ServicePtr->ServerHostPort,
rqeptr->rqHeader.MethodName,
rqeptr->rqHeader.RequestUriPtr);
else
WatchThis (WATCHITM(rqeptr), WATCH_NETWORK, "BREAK1 !AZ !UL",
rqeptr->ServicePtr->ServerHostPort,
rqeptr->rqNet.PersistentCount);
sys$dassgn (ioptr->Channel);
ioptr->Channel = 0;
total++;
}
FaoToStdout ("%HTTPD-I-NET, !%T, !UL/!UL/!UL broken\n",
0, every, total, count);
Http2TestBreak (every);
}
#endif /* WATCH_MOD */
/*****************************************************************************/
/*
Needed a rig to test/experiment with multiple-instance network device (socket)
handling.
*/
#if NET_TEST
NetTestRequest (unsigned short Channel)
{
int status;
struct NetTestStruct *ntptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetTestRequest() !UL", Channel);
ntptr = VmGet (sizeof(struct NetTestStruct));
ntptr->Channel = Channel;
status = sys$qio (EfnNoWait, ntptr->Channel, IO$_READVBLK,
&ntptr->IOsb, &NetTestReadAst, ntptr,
ntptr->Buffer, sizeof(ntptr->Buffer), 0, 0, 0, 0);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
/*****************************************************************************/
/*
See comments in NetTestRequest().
*/
NetTestReadAst (struct NetTestStruct *ntptr)
{
static char ResponseHeader [] =
"HTTP/1.0 200 OK\r\n\
Server: WASD/Test\r\n\
Content-Type: text/plain\r\n\
\r\n";
static char ResponseBody [] =
"abcdefghijklnmopqrstuvwxyzABCDEFGHIJKLNMOPQRSTUVWXYZ0123456789\n";
int status;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetTestReadAst() !UL !&S !UL",
ntptr->Channel, ntptr->IOsb.Status, ntptr->IOsb.Count);
if (VMSnok (ntptr->IOsb.Status))
{
ErrorNoticed (rqptr, ntptr->IOsb.Status, NULL, FI_LI);
status = sys$dassgn (ntptr->Channel);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
VmFree (ntptr, FI_LI);
return;
}
memcpy (ntptr->Buffer, ResponseHeader, sizeof(ResponseHeader));
sptr = ntptr->Buffer + sizeof(ResponseHeader);
zptr = ntptr->Buffer + sizeof(ntptr->Buffer);
cptr = ResponseBody;
while (sptr < zptr)
{
if (!*cptr) cptr = ResponseBody;
*sptr++ = *cptr++;
}
status = sys$qio (EfnNoWait, ntptr->Channel, IO$_WRITEVBLK, &ntptr->IOsb,
&NetTestWriteAst, ntptr,
ntptr->Buffer, sizeof(ntptr->Buffer), 0, 0, 0, 0);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
/*****************************************************************************/
/*
See comments in NetTestRequest().
*/
NetTestWriteAst (struct NetTestStruct *ntptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET,
"NetTestWriteAst() !UL !&S",
ntptr->Channel, ntptr->IOsb.Status);
status = sys$dassgn (ntptr->Channel);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
VmFree (ntptr, FI_LI);
}
#endif /* NET_TEST */
/****************************************************************************/