[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]
/*****************************************************************************/
/*
DECnet.c
This module implements a full multi-threaded, AST-driven, script execution via
DECnet. Primarily this is to provide a substantially OSU-compatible scripting
enviroment, but does support WASD-style CGI scripting transparently over
DECnet. This code is functional but does not pretend to be highly optimized.
Two modes are supported.
WASD CGI MODE
-------------
These scripts behave in exactly the same manner as script process-based,
standard WASD CGI scripts. A stream of DCL commands create the CGI variable
environment and execute the script. The output stream can be CGI-compliant or
return a full HTTP response stream.
This is the default mode. If a mapped script contains a DECnet node component
but without a "TASK=" string the CGI mode is used. It is also the mode for
any "TASK=" string containing "CGIWASD".
OSU MODE
--------
This mode emulates the OSU DECnet scripting environment. It is based in large
part on reverse engineering the OSU 'script_execute.c' module, and lots of
trial-and-error!
This is the mode used when the mapped script contains a DECnet component and a
"TASK=" string that does not contain "WASD" as the final four characters. In
general the string will be "TASK=WWWEXEC", the basic OSU script executive.
Any other task name will also be assumed to be OSU compliant.
MAPPING
-------
DECnet scripting is enabled for individual scripts by including a DECnet
component in the result of a "script" or "exec" mapping rule.
Examples ...
exec /FRODO/* /FRODO::/cgi-bin/*
exec /frodo/* /frodo::"task=cgiwasd"/cgi-bin/*
exec /frodo/* /frodo::"0=cgiwasd"/cgi-bin/*
executes any WASD CGI script specified on node FRODO
(both forms result in the same script execution)
exec /bilbo/osu/* /BILBO::"TASK=WWWEXEC"/*
exec /bilbo/osu/* /BILBO::"0=WWWEXEC"/*
executes any OSU script specified on node BILBO
SCRIPTING AS A NON-HTTPD ACCOUNT
--------------------------------
The mapping rules
set /frodo/ script=as=$
set /frodo/ script=as=~
set /frodo/ script=as=ACCOUNT-NAME
are all supported (with the necessary DECnet proxy access).
These functional equivalents are also available
exec /frodo/* /frodo"$"::"0=cgiwasd"/cgi-bin/*
exec /frodo/* /frodo"~"::"0=cgiwasd"/cgi-bin/*
exec /frodo/* /frodo"ACCOUNT-NAME"::"0=cgiwasd"/cgi-bin/*
CONNECTION REUSE
----------------
As of v3.3 OSU provided the capability to reuse existing connections to the
WWWEXEC.COM task to provide multiple, consecutive requests for a single link.
An efficiency advantage gained through avoiding the overhead of connection
establishment with each script activation. WASD provides similar functionality
for both OSU and CGI tasked scripts.
A list of connection structures is maintained. Some of these may have channels
assigned to established network tasks, others may not, just depending on
previous activity. The channel non-zero is used when scanning the list for an
appropriate connected task to reuse. Each established connection has a finite
lifetime after which the channel is deassigned effectively disconnecting the
link. Could have done the process control with an intermediate mailbox but
this will work as well most of the time almost as efficiently.
Related configuration parameters:
[DECnetReuseLifeTime] .... minutes the connection to the task is maintained,
non-zero enables connection reuse by the server
[DECnetConnectListMax] ... number of concurrent reuse connections the server
will maintain before reporting an error
VERSION HISTORY
---------------
07-FEB-2020 MGD RequestAbort() accomodates HttpdSupervisor() refinement
and REQUEST_STATE_ABORT used throughout server
13-JAN-2014 MGD DECnetCountConnection()
12-JUL-2009 MGD DECnetCgiDialog() and DECnetOsuDialog()
WASD_FILE_DEV and WASD_FILE_DEV_n procedure
09-JUN-2007 MGD use STR_DSC
05-JAN-2006 MGD bugfix; DECnetWriteRequestBody() suppress empty record on
end-of-body for OSU (call DECnetWriteRequestBodyAst())
to prevent it interfering with <DNETREUSE> functionality
06-OCT-2005 MGD copy sentinals into request storage
15-JUL-2005 MGD bugfix; DECnetOsuDialog() allow CgiOutput() error responses
12-OCT-2003 MGD bugfix; allow for outstanding network writes during rundown
26-AUG-2003 MGD bugfix; allow for outstanding body reads during task rundown
05-AUG-2003 MGD bugfix; check for NULL pointer 'cnptr->ReuseConnection'
27-JUL-2003 MGD revise reporting format
revise script activation code (include .CLD)
bugfix; DECnetCgiDialog() not strict wait for EOF sentinal
22-APR-2003 MGD bugfix; (and refine) DECnetSupervisor()
15-MAR-2003 MGD script=as=$? to indicate optional use of SYSUAF username
implement authorization "scriptas" keyword directive
30-JAN-2003 MGD build up 'records' from single byte output streams
(see description of purpose and functionality in DCL.C)
bugfix; DECnetFindCgiScript() foreign verb creation
08-OCT-2002 MGD implement 'HttpdScriptAsUserName' for DECnet also
14-SEP-2002 MGD support 'script=as=' functionality, plus DECnet variants
NODE"$":: substitutes SYSUAF authenticated username into
access string (for proxy access to account) and
NODE"~":: substitutes '/~username/' username in same way
02-FEB-2002 MGD rework due to request body processing changes
28-OCT-2001 MGD "TASK=CGI..", "0=CGI.." now recognised as CGI dialog
29-SEP-2001 MGD instance support
04-AUG-2001 MGD support module WATCHing
26-APR-2001 MGD use HttpdTick() to drive DECnetSupervisor()
26-JAN-2001 MGD bugfix; force CgiOutput() record/stream mode
22-JUN-2000 MGD bugfix; HEAD requests specifying content-length
09-MAY-2000 MGD bugfix; sys$assign() error had no DECnetEnd()
08-APR-2000 MGD if(!Config.cfScript.Enabled)
04-MAR-2000 MGD use FaolToNet(), et.al.
13-JAN-2000 MGD add OPCOM messages
28-NOV-1999 MGD relocate CgiGenerateVariables()
19-JUN-1999 MGD bugfix; remove SysDclAst() from DECnetBegin(),
general refinement
29-JAN-1999 MGD add <DNETRECMODE2> from OSU 3.3b
06-DEC-1999 MGD bugfix; initial OSU dialog send mapped path not original path
07-NOV-1998 MGD WATCH facility,
client port number now available for OSU
15-AUG-1998 MGD reuse network task-connections,
report status 500/501 if script returns no output,
report unknown OSU dialog tags as an error,
return translated path in Unix-style syntax
16-DEC-1997 MGD initial development for v5.0
*/
/*****************************************************************************/
#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 <stdio.h>
#include <string.h>
/* VMS related header files */
#include <descrip.h>
#include <iodef.h>
#include <libdef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application header files */
#include "wasd.h"
#define WASD_MODULE "DECNET"
/**********/
/* macros */
/**********/
#define DECNET_CONTENT_MAX 1024
#define DECNET_SUPERVISOR_TICK_MIN 10
#define DECNET_SUPERVISOR_TICK_MAX 30
/* space for adding file types (e.g. ".COM") onto script specifications */
#define FIND_SCRIPT_OVERHEAD 48
#define DECNET_TASK_CGI "CGIWASD"
#define DECNET_TASK_OSU "WWWEXEC"
#define SCRIPT_CGI 1
#define SCRIPT_OSU 2
#define CGI_BEGIN 1
#define CGI_REUSE 2
#define CGI_SEARCH 3
#define CGI_DCL 4
#define CGI_OUTPUT 5
#define OSU_BEGIN 1
#define OSU_REUSE 2
#define OSU_DIALOG 3
#define OSU_DNET_HDR 4
#define OSU_DNET_INPUT 5
#define OSU_DNET_XLATE 6
#define OSU_OUTPUT_RAW 7
#define OSU_OUTPUT_REC 8
#define OSU_DNETTEXT 9
/******************/
/* global storage */
/******************/
char ErrorDECnetReuseListExhausted [] = "DECnet reuse list exhausted.",
ErrorOsuImplementation [] = "Possible OSU implementation problem!",
ErrorOsuNoInvCache [] =
"OSU "invalidate cache" dialog not implemented.",
ErrorOsuNoManage [] = "OSU "manage" dialog not implemented.",
ErrorOsuUnknown [] = "Unknown OSU dialog ... "<tt>!&;AZ</tt>"";
char DECnetWasdFileDev [] =
"IF F$TRNLNM(\"WASD_FILE_DEV\").NES.\"\" THEN @WASD_FILE_DEV";
$DESCRIPTOR (DECnetWasdFileDevFaoDsc,
"IF F$TRNLNM(\"WASD_FILE_DEV_!UL\").NES.\"\" THEN @WASD_FILE_DEV_!UL !UL");
LIST_HEAD DECnetConnectList;
int DECnetConnectListCount,
DECnetPurgeAllConnectCount;
/********************/
/* external storage */
/********************/
#ifdef DBUG
extern BOOL Debug;
#else
#define Debug 0
#endif
extern int EfnNoWait,
HttpdTickSecond,
InstanceEnvNumber,
InstanceNumber,
NetReadBufferSize,
OpcomMessages,
OutputBufferSize;
extern int ToLowerCase[],
ToUpperCase[];
extern char CliScriptAs[],
DclCgiVariablePrefix[],
ErrorSanityCheck[],
HttpdScriptAsUserName[],
SoftwareID[];
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern HTTPD_PROCESS HttpdProcess;
extern MSG_STRUCT Msgs;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Initiate a connection to a DECnet node using the connection details specified
in 'ConnectString'.
*/
DECnetBegin
(
REQUEST_STRUCT *rqptr,
REQUEST_AST NextTaskFunction,
char *MappedScript,
char *ScriptRunTime
)
{
int status;
char *cptr, *sptr, *uptr, *zptr,
*ScriptAsPtr;
REQUEST_AST AstFunction;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetBegin() !&A !&Z !&Z",
NextTaskFunction, MappedScript, ScriptRunTime);
if (!Config.cfScript.Enabled)
{
rqptr->rqResponse.HttpStatus = 403;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_GENERAL_DISABLED), FI_LI);
SysDclAst (NextTaskFunction, rqptr);
return;
}
if (!rqptr->AccountingDone++)
InstanceGblSecIncrLong (&AccountingPtr->DoDECnetCount);
/* set up the task structure */
if (!rqptr->DECnetTaskPtr)
{
rqptr->DECnetTaskPtr = tkptr = (DECNET_TASK*)
VmGetHeap (rqptr, sizeof(DECNET_TASK));
}
else
{
tkptr = rqptr->DECnetTaskPtr;
memset (tkptr, 0, sizeof(DECNET_TASK));
}
tkptr->RequestPtr = rqptr;
tkptr->NextTaskFunction = NextTaskFunction;
tkptr->WatchItem = rqptr->WatchItem;
cptr = MappedScript;
zptr = (sptr = tkptr->MappedScript) + sizeof(tkptr->MappedScript);
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr >= zptr)
{
ErrorGeneralOverflow (rqptr, FI_LI);
DECnetEnd (rqptr);
return;
}
*sptr = '\0';
if (ScriptRunTime && ScriptRunTime[0])
{
cptr = ScriptRunTime;
zptr = (sptr = tkptr->ScriptRunTime) + sizeof(tkptr->ScriptRunTime);
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr >= zptr)
{
ErrorGeneralOverflow (rqptr, FI_LI);
DECnetEnd (rqptr);
return;
}
*sptr = '\0';
}
else
tkptr->ScriptRunTime[0] = '\0';
/* reset CGI output processing (both OSU and CGI use this) */
CgiOutput (rqptr, NULL, 0);
/*******************************/
/* generate the connect string */
/*******************************/
ScriptAsPtr = NULL;
zptr = (sptr = tkptr->ConnectString) + sizeof(tkptr->ConnectString);
for (cptr = tkptr->MappedScript;
*cptr && *cptr != ':' && *cptr != '\"' && sptr < zptr;
*sptr++ = *cptr++);
if (*cptr == '\"')
{
/* account detail string */
if (sptr < zptr) *sptr++ = *cptr++;
if (*cptr == '$')
{
/* use the SYSUAF authenticated username for proxy access */
if (rqptr->RemoteUser[0] &&
rqptr->rqAuth.SysUafAuthenticated)
{
ScriptAsPtr = uptr = rqptr->RemoteUser;
while (*uptr && sptr < zptr) *sptr++ = *uptr++;
}
else
{
rqptr->rqResponse.HttpStatus = 403;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_AUTH_REQUIRED), FI_LI);
DECnetEnd (rqptr);
return;
}
while (*cptr && *cptr != '\"') cptr++;
}
else
if (*cptr == '~')
{
/* use the URI /~username/ for proxy access */
uptr = rqptr->rqHeader.RequestUriPtr;
if (!SAME2(uptr,'/~'))
{
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_MAPPING_DENIED_RULE), FI_LI);
DECnetEnd (rqptr);
return;
}
uptr += 2;
ScriptAsPtr = uptr;
while (*uptr && *uptr != '/' && sptr < zptr) *sptr++ = *uptr++;
while (*cptr && *cptr != '\"') cptr++;
}
while (*cptr && *cptr != ':' && sptr < zptr) *sptr++ = *cptr++;
}
else
if (rqptr->rqAuth.VmsUserScriptAs)
{
/* authorization rule has precendence over mapping rule */
if (rqptr->RemoteUser[0] &&
rqptr->rqAuth.SysUafAuthenticated)
{
ScriptAsPtr = uptr = rqptr->RemoteUser;
if (sptr < zptr) *sptr++ = '\"';
while (*uptr && sptr < zptr) *sptr++ = *uptr++;
if (sptr < zptr) *sptr++ = '\"';
}
else
{
rqptr->rqResponse.HttpStatus = 403;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_AUTH_REQUIRED), FI_LI);
DECnetEnd (rqptr);
return;
}
}
else
if (rqptr->rqPathSet.ScriptAsPtr)
{
/* no account detail string, but the path is set script=as= */
if (SAME2(rqptr->rqPathSet.ScriptAsPtr[0],'$?'))
{
/* optionally use a SYSUAF authenticated username for proxy access */
if (rqptr->RemoteUser[0] &&
rqptr->rqAuth.SysUafAuthenticated)
{
ScriptAsPtr = uptr = rqptr->RemoteUser;
if (sptr < zptr) *sptr++ = '\"';
while (*uptr && sptr < zptr) *sptr++ = *uptr++;
if (sptr < zptr) *sptr++ = '\"';
}
}
else
if (rqptr->rqPathSet.ScriptAsPtr[0] == '$')
{
/* must use the SYSUAF authenticated username for proxy access */
if (rqptr->RemoteUser[0] &&
rqptr->rqAuth.SysUafAuthenticated)
{
ScriptAsPtr = uptr = rqptr->RemoteUser;
if (sptr < zptr) *sptr++ = '\"';
while (*uptr && sptr < zptr) *sptr++ = *uptr++;
if (sptr < zptr) *sptr++ = '\"';
}
else
{
rqptr->rqResponse.HttpStatus = 403;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_AUTH_REQUIRED), FI_LI);
DECnetEnd (rqptr);
return;
}
}
else
if (rqptr->rqPathSet.ScriptAsPtr[0] == '~')
{
/* use the URI /~username/ for proxy access */
uptr = rqptr->rqHeader.RequestUriPtr;
if (!SAME2(uptr,'/~'))
{
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_MAPPING_DENIED_RULE), FI_LI);
DECnetEnd (rqptr);
return;
}
uptr += 2;
ScriptAsPtr = uptr;
if (sptr < zptr) *sptr++ = '\"';
while (*uptr && *uptr != '/' && sptr < zptr) *sptr++ = *uptr++;
if (sptr < zptr) *sptr++ = '\"';
}
else
{
/* an explicitly specified username */
ScriptAsPtr = uptr = rqptr->rqPathSet.ScriptAsPtr;
if (sptr < zptr) *sptr++ = '\"';
while (*uptr && sptr < zptr) *sptr++ = *uptr++;
if (sptr < zptr) *sptr++ = '\"';
}
}
else
if (HttpdScriptAsUserName[0])
{
ScriptAsPtr = uptr = HttpdScriptAsUserName;
if (sptr < zptr) *sptr++ = '\"';
while (*uptr && sptr < zptr) *sptr++ = *uptr++;
if (sptr < zptr) *sptr++ = '\"';
}
if (!SAME2(cptr,'::'))
{
/* shouldn't be in this function if no DECnet in specification! */
ErrorGeneral (rqptr, ErrorSanityCheck, FI_LI);
DECnetEnd (rqptr);
return;
}
/* isolate the DECnet component from the script file specification */
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (*cptr == '\"')
{
/* mapping rule is supplying the DECnet task information */
if (sptr < zptr) *sptr++ = *cptr++;
while (*cptr && *cptr != '\"' && sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
tkptr->ScriptPtr = cptr;
DECnetSetDialog (tkptr);
}
else
{
/* supply the default WASD CGI DECnet task */
tkptr->ScriptPtr = cptr;
cptr = "\"TASK=";
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
cptr = DECNET_TASK_CGI;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = '\"';
tkptr->ScriptType = SCRIPT_CGI;
}
if (sptr >= zptr)
{
ErrorGeneralOverflow (rqptr, FI_LI);
DECnetEnd (rqptr);
return;
}
*sptr = '\0';
tkptr->ConnectStringLength = sptr - tkptr->ConnectString;
if (WATCHING (rqptr, WATCH_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_DECNET,
"!AZ !AZ", tkptr->ConnectString, tkptr->ScriptPtr);
if (WATCHING (rqptr, WATCH_RESPONSE))
{
if (ScriptAsPtr)
{
/* allow for possible URI '/~username/blah' */
for (uptr = ScriptAsPtr; *uptr && *uptr != '/'; uptr++);
switch (tkptr->ScriptType)
{
case SCRIPT_CGI :
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE,
"SCRIPT as !#AZ CGI !AZ",
uptr - ScriptAsPtr, ScriptAsPtr, MappedScript);
break;
case SCRIPT_OSU :
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE,
"SCRIPT as !#AZ OSU !AZ",
uptr - ScriptAsPtr, ScriptAsPtr, MappedScript);
break;
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
}
else
{
switch (tkptr->ScriptType)
{
case SCRIPT_CGI :
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE,
"SCRIPT CGI !AZ", MappedScript);
break;
case SCRIPT_OSU :
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE,
"SCRIPT OSU !AZ", MappedScript);
break;
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
}
}
/**********************/
/* access DECnet task */
/**********************/
DECnetConnectBegin(tkptr);
}
/*****************************************************************************/
/*
End of request's DECnet task. If outstanding I/O cancel and wait for that to
complete. Disassociate (disconnect) the request and the connection structure.
Queue an AST for the next task.
*/
BOOL DECnetEnd (REQUEST_STRUCT *rqptr)
{
int status;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetEnd() !&F !UL !UL !UL", &DECnetEnd,
rqptr->DECnetTaskPtr->QueuedBodyRead,
rqptr->DECnetTaskPtr->QueuedNetWrite,
rqptr->DECnetTaskPtr->QueuedDECnetIO);
tkptr = rqptr->DECnetTaskPtr;
if (!tkptr->NextTaskFunction) return (true);
if (tkptr->QueuedDECnetIO)
{
sys$cancel (tkptr->DECnetChannel);
return (false);
}
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
if (tkptr->cnptr)
tkptr->cnptr->ReuseConnection = false;
DECnetConnectEnd (tkptr);
if (!tkptr->ScriptResponded)
{
/* hmmm, script has not provided any output! */
if (tkptr->RequestPtr->rqHeader.Method == HTTP_METHOD_GET)
{
/* blame script for general GET method failures */
tkptr->RequestPtr->rqResponse.HttpStatus = 502;
ErrorGeneral (tkptr->RequestPtr,
MsgFor(tkptr->RequestPtr,MSG_SCRIPT_RESPONSE_ERROR), FI_LI);
}
else
{
/* other methods are probably not implemented by the script */
tkptr->RequestPtr->rqResponse.HttpStatus = 501;
ErrorGeneral (tkptr->RequestPtr,
MsgFor(tkptr->RequestPtr,MSG_REQUEST_METHOD), FI_LI);
}
}
tkptr->WatchItem = 0;
/* declare the next task */
SysDclAst (tkptr->NextTaskFunction, rqptr);
tkptr->NextTaskFunction = NULL;
return (false);
}
/*****************************************************************************/
/*
Examine the connect string to determine the scripting dialog required (CGI or
OSU). Set a flag in the task structure to indicate the type of dialog.
*/
DECnetSetDialog (DECNET_TASK *tkptr)
{
char *cptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(tkptr), WATCH_MOD_DECNET,
"DECnetSetDialog() !&Z", tkptr->ConnectString);
cptr = tkptr->ConnectString;
while (*cptr)
{
if (strsame (cptr, "\"TASK=CGI", 9) || strsame (cptr, "\"0=CGI", 6))
{
tkptr->ScriptType = SCRIPT_CGI;
return;
}
cptr++;
}
/* any task name not otherwise recognized becomes an OSU-based script */
tkptr->ScriptType = SCRIPT_OSU;
}
/*****************************************************************************/
/*
Set up a connection between the request and the DECnet task involved. Scan
through the list of already created connection items, looking for an item,
idle but network-connected task-string of the required flavour. If none is
found scan again, this time looking for any unused item (idle, not connected).
If none is found create a new one and place it in the list. If already
network-connected to the task just increment a counter and queue a "fake" AST
to the connection-established function. If not already network-connected
assign a channel and queue an I/O to connect to the desired network task, a
real AST being deliver this time to the connection-established function.
*/
DECnetConnectBegin (DECNET_TASK *tkptr)
{
static $DESCRIPTOR (NetDeviceDsc, "_NET:");
static $DESCRIPTOR (NcbDsc, "");
int status;
DECNET_CONNECT *cnptr;
LIST_ENTRY *leptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(tkptr), WATCH_MOD_DECNET,
"DECnetConnectBegin()");
cnptr = NULL;
/*****************************************/
/* look for available AND connected item */
/*****************************************/
for (leptr = DECnetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
cnptr = (DECNET_CONNECT*)leptr;
if (!cnptr->DECnetChannel ||
!cnptr->ReuseConnection ||
cnptr->RequestPtr ||
!strsame (tkptr->ConnectString, cnptr->ConnectString, -1))
{
cnptr = NULL;
continue;
}
break;
}
if (!cnptr)
{
/****************************************/
/* look for available disconnected item */
/****************************************/
for (leptr = DECnetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
cnptr = (DECNET_CONNECT*)leptr;
if (cnptr->DECnetChannel)
{
cnptr = NULL;
continue;
}
break;
}
}
if (!cnptr)
{
/********************************/
/* create a new connection item */
/********************************/
if (Config.cfScript.DECnetConnectListMax &&
DECnetConnectListCount >= Config.cfScript.DECnetConnectListMax)
{
tkptr->RequestPtr->rqResponse.HttpStatus = 500;
ErrorGeneral (tkptr->RequestPtr, ErrorDECnetReuseListExhausted, FI_LI);
DECnetEnd (tkptr->RequestPtr);
return;
}
DECnetConnectListCount++;
cnptr = VmGet (sizeof(DECNET_CONNECT));
ListAddTail (&DECnetConnectList, cnptr, LIST_ENTRY_TYPE_DECNET);
}
/*******************/
/* initialize item */
/*******************/
if (cnptr->DECnetChannel)
{
/* (probably) still connected */
cnptr->ReUsageCount++;
}
else
{
/* assign channel for new connection */
status = sys$assign (&NetDeviceDsc, &cnptr->DECnetChannel, 0, 0);
if (VMSnok (status))
{
cnptr->DECnetChannel = 0;
tkptr->RequestPtr->rqResponse.HttpStatus = 502;
tkptr->RequestPtr->rqResponse.ErrorTextPtr =
tkptr->RequestPtr->ScriptName;
ErrorVmsStatus (tkptr->RequestPtr, status, FI_LI);
DECnetEnd (tkptr->RequestPtr);
return;
}
cnptr->ReUsageCount = 0;
cnptr->ReuseConnection = false;
strcpy (cnptr->ConnectString, tkptr->ConnectString);
}
/* associate the request, task and connect instance */
tkptr->cnptr = cnptr;
cnptr->RequestPtr = tkptr->RequestPtr;
tkptr->DECnetChannel = cnptr->DECnetChannel;
tkptr->BuildRecords = tkptr->ScriptResponded = false;
tkptr->BuildCount = 0;
cnptr->UsageCount++;
cnptr->LastUsedTime64 = tkptr->RequestPtr->rqTime.BeginTime64;
/* for the first call to DECnetRead() ensure status check is OK */
tkptr->RequestPtr->NetIoPtr->WriteStatus = SS$_NORMAL;
if (cnptr->ReuseConnection)
{
/******************************/
/* (probably) still connected */
/******************************/
/* restart the connected task lifetime */
tkptr->cnptr->LifeTimeSecond =
HttpdTickSecond + Config.cfScript.DECnetReuseLifeTime;
switch (tkptr->ScriptType)
{
case SCRIPT_CGI :
/* reusing, check the connection, ASTs to DECnetCgiDialog() */
tkptr->CgiDialogState = CGI_REUSE;
DECnetConnectProbeCgi (tkptr);
return;
case SCRIPT_OSU :
/* reusing, check the connection, ASTs to DECnetOsuDialog() */
tkptr->OsuDialogState = OSU_REUSE;
DECnetConnectProbeOsu (tkptr);
return;
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
}
/**************************/
/* connect to DECnet task */
/**************************/
DECnetCountConnection ();
if (WATCHMOD (tkptr, WATCH_MOD_DECNET))
WatchDataFormatted ("{!UL}!-!#AZ\n", tkptr->ConnectStringLength,
tkptr->ConnectString);
/* apply that to the network Connect Block descriptor */
NcbDsc.dsc$w_length = tkptr->ConnectStringLength;
NcbDsc.dsc$a_pointer = tkptr->ConnectString;
tkptr->QueuedDECnetIO++;
status = sys$qio (EfnNoWait, tkptr->DECnetChannel, IO$_ACCESS,
&tkptr->DECnetConnectIOsb,
&DECnetConnectAst, tkptr->RequestPtr,
0, &NcbDsc, 0, 0, 0, 0);
if (VMSok (status)) return;
/* report error via AST */
tkptr->DECnetConnectIOsb.Status = status;
tkptr->DECnetConnectIOsb.Count = 0;
SysDclAst (&DECnetConnectAst, tkptr->RequestPtr);
}
/*****************************************************************************/
/*
The connection request to the specified DECnet task has completed (real or
"faked"). Check the status and report any error. If no error then initialize
the required script dialog and call the appropriate function to begin it.
Connection that may be reused begin with the ..._REUSE dialog, which probes the
connection ensuring it's still valid. Non-reused connections begin with the
appropriate ..._BEGIN dialog.
*/
DECnetConnectAst (REQUEST_STRUCT *rqptr)
{
int status;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET, "DECnetConnectAst() !&X",
rqptr->DECnetTaskPtr->DECnetConnectIOsb.Status);
tkptr = rqptr->DECnetTaskPtr;
if (tkptr->QueuedDECnetIO) tkptr->QueuedDECnetIO--;
if (VMSnok (tkptr->DECnetConnectIOsb.Status))
{
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = false;
tkptr->RequestPtr->rqResponse.HttpStatus = 502;
rqptr->rqResponse.ErrorTextPtr = rqptr->ScriptName;
ErrorVmsStatus (rqptr, tkptr->DECnetConnectIOsb.Status, FI_LI);
DECnetEnd (rqptr);
return;
}
if (Config.cfScript.DECnetReuseLifeTime)
{
/* reuse enabled, plus one allows at least that period */
tkptr->cnptr->LifeTimeSecond =
HttpdTickSecond + Config.cfScript.DECnetReuseLifeTime+1;
/* start the supervisor ticking for connected task lifetimes */
DECnetSupervisor (0);
}
switch (tkptr->ScriptType)
{
case SCRIPT_CGI :
/* just begin the CGI dialog phase */
tkptr->CgiDialogState = CGI_BEGIN;
DECnetCgiDialog (rqptr);
return;
case SCRIPT_OSU :
/* just begin the OSU dialog phase */
tkptr->OsuDialogState = OSU_BEGIN;
DECnetOsuDialog (rqptr);
return;
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
}
/*****************************************************************************/
/*
Write just a DCL comment character to the script network process (will be
ignored by DCL) to check that the connection still exists. Delivers an AST to
DECnetCGIDialog() which checks the success of the probe.
*/
DECnetConnectProbeCgi (DECNET_TASK *tkptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(tkptr), WATCH_MOD_DECNET,
"DECnetConnectProbeCgi()");
tkptr->QueuedDECnetIO++;
status = sys$qio (EfnNoWait, tkptr->DECnetChannel, IO$_WRITEVBLK,
&tkptr->DECnetWriteIOsb, &DECnetCgiDialog,
tkptr->RequestPtr, "!", 1, 0, 0, 0, 0);
if (VMSok (status)) return;
/* report error via AST */
tkptr->DECnetWriteIOsb.Status = status;
tkptr->DECnetWriteIOsb.Count = 0;
SysDclAst (&DECnetCgiDialog, tkptr->RequestPtr);
}
/*****************************************************************************/
/*
Write a <DNETREUSE> dialog tag to the script (will be ignored by the task
procedure WWWEXEC.COM) to check that the connection still exists. Delivers an
AST to DECnetOsuDialog() which checks the success of the probe.
*/
DECnetConnectProbeOsu (DECNET_TASK *tkptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(tkptr), WATCH_MOD_DECNET,
"DECnetConnectProbeOsu()");
tkptr->QueuedDECnetIO++;
status = sys$qio (EfnNoWait, tkptr->DECnetChannel, IO$_WRITEVBLK,
&tkptr->DECnetWriteIOsb,
&DECnetOsuDialog, tkptr->RequestPtr,
"<DNETREUSE>", 11, 0, 0, 0, 0);
if (VMSok (status)) return;
/* report error via AST */
tkptr->DECnetWriteIOsb.Status = status;
tkptr->DECnetWriteIOsb.Count = 0;
SysDclAst (&DECnetOsuDialog, tkptr->RequestPtr);
}
/*****************************************************************************/
/*
Conclude a request's use of a DECnet connect item. If the connection can
reused then leave the channel assigned, otherwise deassign it disconnecting
from the network task.
*/
DECnetConnectEnd (DECNET_TASK *tkptr)
{
int status;
DECNET_CONNECT *cnptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(tkptr), WATCH_MOD_DECNET,
"DECnetConnectEnd()");
if (!(cnptr = tkptr->cnptr)) return;
if (!cnptr->ReuseConnection ||
cnptr->IsMarkedForDisconnect)
{
status = sys$dassgn (cnptr->DECnetChannel);
cnptr->DECnetChannel = cnptr->LifeTimeSecond = 0;
DECnetCountConnection ();
}
/* disassociate the request, task and connect instance */
tkptr->cnptr = cnptr->RequestPtr = NULL;
}
/*****************************************************************************/
/*
Write a record to the remote DECnet task. AST function will process any
errors at all.
*/
DECnetWrite
(
REQUEST_STRUCT *rqptr,
char *DataPtr,
int DataLength
)
{
int status;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetWrite() 0x!8XL !UL !UL",
DataPtr, DataLength, rqptr->DECnetTaskPtr->QueuedDECnetIO);
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
{
DECnetEnd (rqptr);
return;
}
tkptr = rqptr->DECnetTaskPtr;
if (DataLength < 0) DataLength = strlen(DataPtr);
if (WATCHING (rqptr, WATCH_DECNET))
{
WatchThis (WATCHITM(rqptr), WATCH_DECNET,
"WRITE !UL bytes", DataLength);
WatchDataDump (DataPtr, DataLength);
}
tkptr->QueuedDECnetIO++;
status = sys$qio (EfnNoWait, tkptr->DECnetChannel, IO$_WRITEVBLK,
&tkptr->DECnetWriteIOsb, &DECnetWriteAst, rqptr,
DataPtr, DataLength, 0, 0, 0, 0);
if (VMSok (status)) return;
/* report error via AST */
tkptr->DECnetWriteIOsb.Status = status;
tkptr->DECnetWriteIOsb.Count = 0;
SysDclAst (&DECnetWriteAst, rqptr);
}
/*****************************************************************************/
/*
*/
DECnetWriteAst (REQUEST_STRUCT *rqptr)
{
int status;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetWriteAst() !&F !UL !&X",
&DECnetWriteAst, rqptr->DECnetTaskPtr->QueuedDECnetIO,
rqptr->DECnetTaskPtr->DECnetWriteIOsb.Status);
tkptr = rqptr->DECnetTaskPtr;
if (tkptr->QueuedDECnetIO) tkptr->QueuedDECnetIO--;
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
{
DECnetEnd (rqptr);
return;
}
/* reusing the IOsb, expect it to occasionally have been initialized! */
if (!tkptr->DECnetWriteIOsb.Status)
tkptr->DECnetWriteIOsb.Status = SS$_NORMAL;
if (WATCHING (rqptr, WATCH_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_DECNET,
"WRITE !&S", tkptr->DECnetWriteIOsb.Status);
if (VMSnok (tkptr->DECnetWriteIOsb.Status))
{
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = false;
rqptr->rqResponse.ErrorTextPtr = rqptr->ScriptName;
ErrorVmsStatus (rqptr, tkptr->DECnetWriteIOsb.Status, FI_LI);
DECnetEnd (rqptr);
return;
}
}
/*****************************************************************************/
/*
Write a chunk of the request header or body to the script. When the content
data is exhausted write an empty record as and end-of-data marker. This must
be checked for and detected by the script as there is no end-of-file
associated with this stream!
*/
DECnetWriteRequest (REQUEST_STRUCT *rqptr)
{
int status,
DataLength;
char *cptr,
*DataPtr;
DECNET_TASK *tkptr;
DICT_ENTRY_STRUCT *denptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetWriteRequest() !&F 0x!8XL !UL !UL",
&DECnetWriteRequest, rqptr->DECnetTaskPtr->ContentPtr,
rqptr->DECnetTaskPtr->ContentCount,
rqptr->DECnetTaskPtr->QueuedDECnetIO);
tkptr = rqptr->DECnetTaskPtr;
if (!tkptr->ContentPtr)
{
switch (tkptr->ScriptType)
{
case SCRIPT_CGI :
if (rqptr->rqBody.DataStatus)
BodyRead (rqptr);
else
BodyReadBegin (rqptr, DECnetWriteRequestBody, NULL);
tkptr->QueuedBodyRead++;
return; /* NOTE: RETURN! */
case SCRIPT_OSU :
switch (tkptr->OsuDialogState)
{
case OSU_DNET_HDR :
/* request header (excluding first line) */
if (!(cptr = rqptr->rqHeader.RequestHeaderPtr))
{
denptr = RequestDictHeader (rqptr);
cptr = DICT_GET_VALUE(denptr);
}
while (NOTEOL(*cptr)) cptr++;
if (*cptr == '\r') cptr++;
if (*cptr == '\n') cptr++;
tkptr->ContentPtr = cptr;
tkptr->ContentCount = -1;
break; /* FALL THRU TO HEADER PROCESSING */
case OSU_DNET_INPUT :
if (rqptr->rqBody.DataStatus)
BodyRead (rqptr);
else
BodyReadBegin (rqptr, DECnetWriteRequestBody, NULL);
tkptr->QueuedBodyRead++;
return; /* NOTE: RETURN! */
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
break;
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
}
/***************************/
/* send header data (only) */
/***************************/
/* OSU gets the header line-by-line (excluding carriage-control) */
for (cptr = DataPtr = tkptr->ContentPtr; NOTEOL(*cptr); cptr++);
DataLength = cptr - DataPtr;
if (*cptr == '\r') cptr++;
if (*cptr == '\n') cptr++;
/* if end-of-header blank line, indicate this */
if (*DataPtr == '\r' || *DataPtr == '\n')
tkptr->ContentPtr = NULL;
else
tkptr->ContentPtr = cptr;
if (WATCHING (rqptr, WATCH_DECNET))
{
WatchThis (WATCHITM(rqptr), WATCH_DECNET,
"WRITE !UL bytes", DataLength);
WatchDataDump (DataPtr, DataLength);
}
tkptr->QueuedDECnetIO++;
status = sys$qio (EfnNoWait, tkptr->DECnetChannel, IO$_WRITEVBLK,
&tkptr->DECnetWriteIOsb, &DECnetWriteRequestAst, rqptr,
DataPtr, DataLength, 0, 0, 0, 0);
if (VMSok (status)) return;
/* report error via AST */
tkptr->DECnetWriteIOsb.Status = status;
tkptr->DECnetWriteIOsb.Count = 0;
SysDclAst (&DECnetWriteRequestAst, rqptr);
}
/*****************************************************************************/
/*
Write a chunk of the request header or body to the script. When the content
data is exhausted write an empty record as an end-of-data marker. This must
be checked for and detected by the script as there is no end-of-file
associated with this stream!
*/
DECnetWriteRequestBody (REQUEST_STRUCT *rqptr)
{
int status,
DataLength;
char *cptr,
*DataPtr;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetWriteRequestBody() !&F !&S 0x!8XL !UL !UL !UL",
&DECnetWriteRequestBody, rqptr->rqBody.DataStatus,
rqptr->rqBody.DataPtr, rqptr->rqBody.DataCount,
rqptr->DECnetTaskPtr->QueuedBodyRead,
rqptr->DECnetTaskPtr->QueuedDECnetIO);
tkptr = rqptr->DECnetTaskPtr;
if (tkptr->QueuedBodyRead) tkptr->QueuedBodyRead--;
if (VMSok (rqptr->rqBody.DataStatus))
{
DataPtr = rqptr->rqBody.DataPtr;
DataLength = rqptr->rqBody.DataCount;
}
else
if (rqptr->rqBody.DataStatus == SS$_ENDOFFILE)
{
if (tkptr->ScriptType == SCRIPT_OSU)
{
SysDclAst (&DECnetWriteRequestAst, rqptr);
return;
}
DataPtr = "";
DataLength = 0;
}
else
{
/* report error via AST */
tkptr->DECnetWriteIOsb.Status = rqptr->rqBody.DataStatus;
tkptr->DECnetWriteIOsb.Count = 0;
tkptr->QueuedDECnetIO++;
SysDclAst (&DECnetWriteRequestAst, rqptr);
return;
}
if (WATCHING (rqptr, WATCH_DECNET))
{
WatchThis (WATCHITM(rqptr), WATCH_DECNET, "WRITE !UL bytes", DataLength);
WatchDataDump (DataPtr, DataLength);
}
tkptr->QueuedDECnetIO++;
status = sys$qio (EfnNoWait, tkptr->DECnetChannel, IO$_WRITEVBLK,
&tkptr->DECnetWriteIOsb, &DECnetWriteRequestAst, rqptr,
DataPtr, DataLength, 0, 0, 0, 0);
if (VMSok (status)) return;
/* report error via AST */
tkptr->DECnetWriteIOsb.Status = status;
tkptr->DECnetWriteIOsb.Count = 0;
SysDclAst (&DECnetWriteRequestAst, rqptr);
}
/*****************************************************************************/
/*
A content write has completed. Check the IO status block for errors. If no
error then check for more content to be written, if so the write it!
*/
DECnetWriteRequestAst (REQUEST_STRUCT *rqptr)
{
int status;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetWriteRequestAst() !&F !UL !&X !UL",
&DECnetWriteRequestAst, rqptr->DECnetTaskPtr->QueuedDECnetIO,
rqptr->DECnetTaskPtr->DECnetWriteIOsb.Status,
rqptr->DECnetTaskPtr->DECnetWriteIOsb.Count);
tkptr = rqptr->DECnetTaskPtr;
if (tkptr->QueuedDECnetIO) tkptr->QueuedDECnetIO--;
/* reusing the IOsb, expect it to occasionally have been initialized! */
if (!tkptr->DECnetWriteIOsb.Status)
tkptr->DECnetWriteIOsb.Status = SS$_NORMAL;
if (WATCHING (rqptr, WATCH_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_DECNET,
"WRITE !&S", tkptr->DECnetWriteIOsb.Status);
if (VMSnok (tkptr->DECnetWriteIOsb.Status))
{
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = false;
rqptr->rqResponse.ErrorTextPtr = rqptr->ScriptName;
ErrorVmsStatus (rqptr, tkptr->DECnetWriteIOsb.Status, FI_LI);
DECnetEnd (rqptr);
return;
}
if (tkptr->ScriptType == SCRIPT_OSU)
{
if (tkptr->OsuDialogState == OSU_DNET_HDR)
{
if (!tkptr->ContentPtr)
{
/* back from <DNETHDR> into dialog */
tkptr->OsuDialogState = OSU_DIALOG;
DECnetRead (rqptr);
return;
}
}
else
{
/* must be OSU_DNET_INPUT */
if (rqptr->rqBody.DataStatus == SS$_ENDOFFILE)
{
/* back from <DNETinput> into dialog */
tkptr->OsuDialogState = OSU_DIALOG;
DECnetRead (rqptr);
return;
}
}
/* write more data */
DECnetWriteRequest (rqptr);
return;
}
/* CGI script */
if (rqptr->rqBody.DataStatus == SS$_ENDOFFILE) return;
/* write more data */
DECnetWriteRequest (rqptr);
}
/*****************************************************************************/
/*
Queue a read from the remote DECnet task. AST function will process any errors
at all.
*/
DECnetRead (REQUEST_STRUCT *rqptr)
{
int status;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET, "DECnetRead() !&F !&X",
&DECnetRead, rqptr->NetIoPtr->WriteStatus);
tkptr = rqptr->DECnetTaskPtr;
if (tkptr->QueuedNetWrite) tkptr->QueuedNetWrite--;
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
{
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = false;
DECnetEnd (rqptr);
return;
}
/* abort task if NETWORK ERROR when writing TO CLIENT */
if (VMSnok (rqptr->NetIoPtr->WriteStatus))
{
/* best way to clean out network buffers, etc., is to break link */
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = false;
DECnetEnd (rqptr);
return;
}
StrDscIfNotBegin (rqptr, &rqptr->NetWriteBufferDsc, OutputBufferSize);
tkptr->QueuedDECnetIO++;
status = sys$qio (EfnNoWait, tkptr->DECnetChannel,
IO$_READVBLK | IO$M_MULTIPLE,
&tkptr->DECnetReadIOsb, &DECnetReadAst, rqptr,
STR_DSC_PTR(&rqptr->NetWriteBufferDsc),
STR_DSC_SIZE(&rqptr->NetWriteBufferDsc),
0, 0, 0, 0);
if (VMSok (status)) return;
/* report error via AST */
tkptr->DECnetReadIOsb.Status = status;
tkptr->DECnetReadIOsb.Count = 0;
SysDclAst (&DECnetReadAst, rqptr);
}
/*****************************************************************************/
/*
The queued read from the remote DECnet task has completed. Check for any
errors reported in the IO status block. If no errors call the function
appropriate for processing the dialog being used by this script.
*/
DECnetReadAst (REQUEST_STRUCT *rqptr)
{
int status;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetReadAst() !&F !UL !&X !UL",
&DECnetReadAst, rqptr->DECnetTaskPtr->QueuedDECnetIO,
rqptr->DECnetTaskPtr->DECnetReadIOsb.Status,
rqptr->DECnetTaskPtr->DECnetReadIOsb.Count);
tkptr = rqptr->DECnetTaskPtr;
if (tkptr->QueuedDECnetIO) tkptr->QueuedDECnetIO--;
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
{
DECnetEnd (rqptr);
return;
}
/* reusing the IOsb, expect it to occasionally have been initialized! */
if (!tkptr->DECnetReadIOsb.Status)
tkptr->DECnetReadIOsb.Status = SS$_NORMAL;
if (WATCHING (rqptr, WATCH_DECNET))
{
WatchThis (WATCHITM(rqptr), WATCH_DECNET,
"READ !&S !UL byte!%s",
tkptr->DECnetReadIOsb.Status,
tkptr->DECnetReadIOsb.Count);
if (tkptr->DECnetReadIOsb.Count)
{
if (tkptr->BuildRecords)
WatchDataDump (STR_DSC_PTR(&rqptr->NetWriteBufferDsc) +
tkptr->BuildCount,
tkptr->DECnetReadIOsb.Count);
else
WatchDataDump (STR_DSC_PTR(&rqptr->NetWriteBufferDsc),
tkptr->DECnetReadIOsb.Count);
}
}
if (VMSnok (tkptr->DECnetReadIOsb.Status))
{
if (tkptr->DECnetReadIOsb.Status != SS$_LINKDISCON)
{
rqptr->rqResponse.ErrorTextPtr = rqptr->ScriptName;
ErrorVmsStatus (rqptr, tkptr->DECnetReadIOsb.Status, FI_LI);
}
DECnetEnd (rqptr);
return;
}
switch (tkptr->ScriptType)
{
case SCRIPT_CGI :
DECnetCgiDialog (rqptr);
return;
case SCRIPT_OSU :
DECnetOsuDialog (rqptr);
return;
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
}
/*****************************************************************************/
/*
Dialog for a WASD standard CGI DECnet-based script. These scripts behave
identically to script process-based standard CGI scripts. The dialog comprises
two phases. The first sends a stream of records to the CGI DECnet task. These
records comprise DCL commands, used to set up the CGI environment and to
execute the script. The second phase uses the generic CGI modules functions to
process CGI script output, writing it to the client.
*/
DECnetCgiDialog (REQUEST_STRUCT *rqptr)
{
static $DESCRIPTOR (DefineEofFaoDsc, "DEFINE/PROCESS CGIEOF \"!AZ\"");
static $DESCRIPTOR (DclCommandDsc, "");
int cnt, status;
unsigned short Length;
char *cptr;
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
tkptr = rqptr->DECnetTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetCgiDialog() !UL", tkptr->CgiDialogState);
if (tkptr->CgiDialogState == CGI_REUSE)
{
/**********************/
/* probing connection */
/**********************/
if (tkptr->QueuedDECnetIO) tkptr->QueuedDECnetIO--;
/* reuse needs to be reset with each use of the DECnet task */
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = false;
if (VMSnok (tkptr->DECnetWriteIOsb.Status))
{
/* problem writing to established connection, restart */
DECnetConnectEnd (tkptr);
DECnetConnectBegin (tkptr);
return;
}
InstanceGblSecIncrLong (&AccountingPtr->DoDECnetReuseCount);
InstanceGblSecIncrLong (&AccountingPtr->DoDECnetCgiReuseCount);
tkptr->CgiDialogState = CGI_BEGIN;
/* drop through to continue with first phase of dialog */
}
if (tkptr->CgiDialogState == CGI_BEGIN)
{
/*****************/
/* WASD_FILE_DEV */
/*****************/
if (InstanceEnvNumber == 1)
DECnetWrite (rqptr, DECnetWasdFileDev, sizeof(DECnetWasdFileDev)-1);
else
{
DclCommandDsc.dsc$a_pointer = tkptr->DclCommand;
DclCommandDsc.dsc$w_length = sizeof(tkptr->DclCommand)-1;
sys$fao (&DECnetWasdFileDevFaoDsc, &Length, &DclCommandDsc,
InstanceEnvNumber, InstanceEnvNumber, InstanceEnvNumber);
tkptr->DclCommand[Length] = '\0';
DECnetWrite (rqptr, tkptr->DclCommand, Length);
}
tkptr->CgiDialogState = CGI_SEARCH;
}
if (tkptr->CgiDialogState == CGI_SEARCH)
{
/***********************/
/* look for the script */
/***********************/
status = DECnetFindCgiScript (rqptr);
/* retry indicates the search is still underway */
if (status == SS$_RETRY) return;
InstanceGblSecIncrLong (&AccountingPtr->DoDECnetCgiCount);
if (VMSnok (status))
{
/* fudge the status so the write AST reports the problem */
tkptr->DECnetWriteIOsb.Status = status;
tkptr->QueuedDECnetIO++;
SysDclAst (&DECnetWriteAst, rqptr);
return;
}
/* must have found the script, set up the DCL/CGI environment */
tkptr->CgiDialogState = CGI_DCL;
}
if (tkptr->CgiDialogState == CGI_DCL)
{
/*****************/
/* define CGIEOF */
/*****************/
/* always generate a new EOF string for standard CGI scripts */
CgiSequenceEof (tkptr->CgiEof, &tkptr->CgiEofLength);
strcpy (rqptr->rqCgi.EofStr, tkptr->CgiEof);
rqptr->rqCgi.EofLength = tkptr->CgiEofLength;
DclCommandDsc.dsc$a_pointer = tkptr->DclCommand;
DclCommandDsc.dsc$w_length = sizeof(tkptr->DclCommand)-1;
sys$fao (&DefineEofFaoDsc, &Length, &DclCommandDsc, tkptr->CgiEof);
tkptr->DclCommand[Length] = '\0';
DECnetWrite (rqptr, tkptr->DclCommand, Length);
/*******************/
/* define CGIREUSE */
/*******************/
if (Config.cfScript.DECnetReuseLifeTime)
{
/* reuse enabled, do not drop DECnet link, reuse it */
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = true;
/* indicate this to the task procedure */
DECnetWrite (rqptr, "DEFINE/PROCESS CGIREUSE 1", 25);
}
/*****************/
/* CGI variables */
/*****************/
if (VMSnok (status = CgiGenerateVariables (rqptr, CGI_VARIABLE_DCL)))
{
DECnetEnd (rqptr);
return;
}
cptr = rqptr->rqCgi.BufferPtr;
for (;;)
{
if (!(Length = *(USHORTPTR)cptr)) break;
DECnetWrite (rqptr, cptr+sizeof(short), Length-1);
cptr += Length + sizeof(short);
}
/*******************************/
/* DCL command/procedure/image */
/*******************************/
if (tkptr->CgiScriptForeignVerb[0])
DECnetWrite (rqptr, tkptr->CgiScriptForeignVerb, -1);
DECnetWrite (rqptr, "GOTO DOIT", 9);
DECnetWrite (rqptr, tkptr->CgiScriptDcl, -1);
if (rqptr->rqHeader.Method == HTTP_METHOD_POST ||
rqptr->rqHeader.Method == HTTP_METHOD_PUT)
{
/* begin to write the request content (body) */
DECnetWriteRequest (rqptr);
}
/*******************************/
/* begin to read script output */
/*******************************/
/* now into dialog state */
tkptr->CgiDialogState = CGI_OUTPUT;
DECnetRead (rqptr);
return;
}
/*****************/
/* script output */
/*****************/
if (!tkptr->ScriptResponded)
{
/*********************/
/* finally it's true */
/*********************/
tkptr->ScriptResponded = true;
if (tkptr->DECnetReadIOsb.Count == 1)
{
/* hmmm, one byte only - start 'building records'! */
tkptr->BuildRecords = true;
if (WATCHING (tkptr, WATCH_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_DECNET, "BUILD records");
}
}
if (tkptr->BuildRecords)
{
/*****************************************/
/* building 'records' from single bytes! */
/*****************************************/
cptr = STR_DSC_PTR(&rqptr->NetWriteBufferDsc) + tkptr->BuildCount;
if (tkptr->DECnetReadIOsb.Count)
{
tkptr->BuildCount += tkptr->DECnetReadIOsb.Count;
cnt = STR_DSC_SIZE(&rqptr->NetWriteBufferDsc) - tkptr->BuildCount;
if (tkptr->DECnetReadIOsb.Count == 1 &&
*cptr != '\n' && cnt > 0)
{
/* not a newline and still space in the buffer */
tkptr->QueuedDECnetIO++;
status = sys$qio (EfnNoWait, tkptr->DECnetChannel,
IO$_READVBLK | IO$M_MULTIPLE,
&tkptr->DECnetReadIOsb, &DECnetReadAst, rqptr,
cptr+1, cnt, 0, 0, 0, 0);
if (VMSok (status)) return;
/* report error via AST */
tkptr->DECnetReadIOsb.Status = status;
tkptr->DECnetReadIOsb.Count = 0;
SysDclAst (&DECnetReadAst, rqptr);
return;
}
}
else
{
*cptr = '\n';
tkptr->BuildCount++;
}
/* newline, zero bytes, multiple bytes, or out of buffer space */
tkptr->DECnetReadIOsb.Count = tkptr->BuildCount;
tkptr->BuildCount = 0;
if (WATCHING (tkptr, WATCH_DECNET))
{
WatchThis (WATCHITM(rqptr), WATCH_DECNET, "BUILT record !UL byte!%s",
tkptr->DECnetReadIOsb.Count);
WatchDataDump (STR_DSC_PTR(&rqptr->NetWriteBufferDsc),
tkptr->DECnetReadIOsb.Count);
}
}
/******************/
/* process record */
/******************/
cptr = STR_DSC_PTR(&rqptr->NetWriteBufferDsc);
cnt = tkptr->DECnetReadIOsb.Count;
cptr[cnt] = '\0';
/* explcitly look for EOF sentinal because it's hardwired in CGIWASD.COM */
if (cnt >= rqptr->rqCgi.EofLength &&
cnt <= rqptr->rqCgi.EofLength+2 &&
MATCH0 (cptr, rqptr->rqCgi.EofStr, rqptr->rqCgi.EofLength))
{
DECnetEnd (rqptr);
return;
}
if (tkptr->RequestPtr->rqResponse.HttpStatus / 100 == 5)
{
/* absorbing all output up until the EOF sentinal */
DECnetRead (rqptr);
return;
}
cnt = CgiOutput (rqptr, cptr, cnt);
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET, "!SL", cnt);
if (cnt == CGI_OUTPUT_END)
{
/* terminate processing */
DECnetEnd (rqptr);
return;
}
if (cnt < 0)
{
/* CgiOutput() error responses have codes less than zero */
rqptr->rqResponse.HttpStatus = 502;
ErrorGeneral (rqptr,
MsgFor(tkptr->RequestPtr,MSG_SCRIPT_RESPONSE_ERROR), FI_LI);
/* absorb output, queue the next read from the script */
DECnetRead (rqptr);
return;
}
if (!cnt)
{
/* absorb output, queue the next read from the script */
DECnetRead (rqptr);
return;
}
tkptr->QueuedNetWrite++;
NetWrite (rqptr, &DECnetRead, cptr, cnt);
}
/*****************************************************************************/
/*
Use the DECnet CGI task to search for the script file. A DCL command is
constructed with the F$SEARCH() lexical and written to the DECnet task which
then executes it, writing the result as an output record which is read by
DECnetRead(), passed to DECnetCgiDialog() and passed back to this same
function for result assessment. If not found and if no explicit file type,
step through each of ".COM", ".EXE" and then any configuration specified file
types and run-time environments, repeating this until found or until all file
types exhausted, at which time a "script not found" report is generated. If
found the DCL required to execute the script is generated in
'tkptr->CgiScriptForeignVerb' and 'tkptr->CgiScriptDcl'.
*/
int DECnetFindCgiScript (REQUEST_STRUCT *rqptr)
{
static $DESCRIPTOR (SearchFaoDsc, "WRITE NET$LINK F$SEARCH(\"!AZ\")");
static $DESCRIPTOR (DclCommandDsc, "");
int cnt, idx, status;
unsigned short Length;
char *cptr, *sptr, *zptr,
*StringPtr;
char String [256];
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetFindCgiScript() !&F", &DECnetFindCgiScript);
tkptr = rqptr->DECnetTaskPtr;
if (tkptr->FindScriptCount && tkptr->DECnetReadIOsb.Count)
{
STR_DSC_PTR(&rqptr->NetWriteBufferDsc)
[tkptr->DECnetReadIOsb.Count] = '\0';
if (strsame (STR_DSC_PTR(&rqptr->NetWriteBufferDsc),
tkptr->FindScript,
tkptr->FindScriptTotalLength))
{
/*************/
/* found it! */
/*************/
tkptr->CgiScriptDcl[0] = tkptr->CgiScriptForeignVerb[0] = '\0';
if (tkptr->ScriptRunTime[0] == '!')
{
/* mapped runtime environment */
tkptr->RunTimePtr = tkptr->ScriptRunTime+1;
}
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"!&Z", tkptr->RunTimePtr);
cptr = tkptr->RunTimePtr;
if (SAME2(cptr,'@\0'))
{
/* DCL procedure */
zptr = (sptr = tkptr->CgiScriptDcl) + sizeof(tkptr->CgiScriptDcl)-1;
*sptr++ = '@';
cptr = rqptr->rqCgi.ScriptFileNamePtr = tkptr->FindScript;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
}
else
if (SAME2(cptr,'=\0'))
{
/* command definition */
zptr = (sptr = tkptr->CgiScriptForeignVerb) +
sizeof(tkptr->CgiScriptForeignVerb)-1;
for (cptr = "SET COMMAND "; *cptr; *sptr++ = *cptr++);
cptr = rqptr->rqCgi.ScriptFileNamePtr = tkptr->FindScript;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
/* now use the command defintion file name as the verb */
while (sptr > tkptr->CgiScriptForeignVerb && *sptr != ']') sptr--;
if (*sptr == ']') sptr++;
cptr = sptr;
zptr = (sptr = tkptr->CgiScriptDcl) + sizeof(tkptr->CgiScriptDcl)-1;
while (*cptr && *cptr != '.' && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
}
else
if (SAME2(cptr,'$\0'))
{
/* execute an image */
zptr = (sptr = tkptr->CgiScriptForeignVerb) +
sizeof(tkptr->CgiScriptForeignVerb)-1;
memcpy (sptr, "WASDVERB:=$", 11);
sptr += 11;
cptr = rqptr->rqCgi.ScriptFileNamePtr = tkptr->FindScript;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
/* now use it as a verb, in case mapped params need to be added */
zptr = (sptr = tkptr->CgiScriptDcl) + sizeof(tkptr->CgiScriptDcl)-1;
memcpy (sptr, "WASDVERB", 9);
sptr += 8;
}
else
{
if (*cptr == '@' || *cptr == '$')
{
/* foreign-verb DCL procedure or executable, create the verb */
zptr = (sptr = tkptr->CgiScriptForeignVerb) +
sizeof(tkptr->CgiScriptForeignVerb)-1;
memcpy (sptr, "WASDVERB:=", 10);
sptr += 10;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
/* now place it as the verb before the script file */
zptr = (sptr = tkptr->CgiScriptDcl) +
sizeof(tkptr->CgiScriptDcl)-1;
memcpy (sptr, "WASDVERB ", 9);
sptr += 9;
cptr = rqptr->rqCgi.ScriptFileNamePtr = tkptr->FindScript;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
}
else
{
/* verb already exists, place before the script file */
zptr = (sptr = tkptr->CgiScriptDcl) +
sizeof(tkptr->CgiScriptDcl)-1;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = ' ';
cptr = rqptr->rqCgi.ScriptFileNamePtr = tkptr->FindScript;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
}
}
if (rqptr->rqPathSet.ScriptCommandPtr)
{
/* add script activation command elements from path SETing */
StringPtr = rqptr->rqPathSet.ScriptCommandPtr;
cnt = 0;
for (;;)
{
status = StringParseValue (&StringPtr, String, sizeof(String));
if (VMSnok (status)) break;
cnt++;
cptr = String;
if (cnt == 1 && *cptr != '*')
{
tkptr->CgiScriptForeignVerb[0] = '\0';
zptr = (sptr = tkptr->CgiScriptDcl) +
sizeof(tkptr->CgiScriptDcl)-1;
}
while (*cptr == '*') cptr++;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
}
if (status != SS$_ENDOFFILE)
{
ErrorVmsStatus (rqptr, status, FI_LI);
tkptr->CgiScriptDcl[0] = tkptr->CgiScriptForeignVerb[0] = '!';
}
}
return (SS$_NORMAL);
}
/* not our dialog, force not found report */
tkptr->FindScriptCount = 999999;
}
/*******************/
/* not found (yet) */
/*******************/
if (tkptr->FindScriptCount == 1)
{
/* explicitly supplied file type was not found */
rqptr->rqResponse.HttpStatus = 404;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_SCRIPT_NOT_FOUND), FI_LI);
return (STS$K_ERROR);
}
/* if started searching then search for the next one */
if (tkptr->FindScriptCount > 1) tkptr->FindScriptCount++;
if (!tkptr->FindScriptCount)
{
/****************/
/* initial call */
/****************/
/* get the script file name (minus all DECnet-related stuff) */
zptr = (sptr = tkptr->FindScript) +
sizeof(tkptr->FindScript) - FIND_SCRIPT_OVERHEAD;
for (cptr = tkptr->MappedScript; *cptr && *cptr != ':'; cptr++);
if (*cptr == ':') cptr++;
if (*cptr == ':') cptr++;
if (*cptr == '\"')
{
/* task specification string */
cptr++;
while (*cptr != '\"') cptr++;
if (*cptr == '\"') cptr++;
}
/* here we go with the file name */
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr >= zptr)
{
ErrorGeneralOverflow (rqptr, FI_LI);
return (STS$K_ERROR);
}
*sptr = '\0';
tkptr->FindScriptLength = sptr - tkptr->FindScript;
/* look backwards to see if a file type has been supplied */
cptr = tkptr->FindScript;
while (*sptr != '.' && *sptr != ']' && sptr > cptr) sptr--;
if (*sptr != '.')
{
/* indicate no file type using 2 */
tkptr->FindScriptCount = 2;
}
else
{
/**********************/
/* file type supplied */
/**********************/
/* indicate file type supplied using 1 */
tkptr->FindScriptCount = 1;
tkptr->FindScriptTypePtr = sptr;
tkptr->FindScriptTotalLength = tkptr->FindScriptLength;
if (tkptr->ScriptRunTime[0] == '!')
tkptr->RunTimePtr = tkptr->ScriptRunTime+1;
else
if (strsame (sptr, ".COM", -1))
tkptr->RunTimePtr = "@";
else
if (strsame (sptr, ".CLD", -1))
tkptr->RunTimePtr = "=";
else
if (strsame (sptr, ".EXE", -1))
tkptr->RunTimePtr = "$";
else
{
/* let's look for it in the run-time environment information */
for (idx = 0; idx < Config.cfScript.RunTimeCount; idx++)
{
sptr = tkptr->FindScriptTypePtr;
cptr = Config.cfScript.RunTime[idx].StringPtr;
while (*cptr && *cptr != ';' && *sptr)
{
if (TOUP(*cptr) != TOUP(*sptr)) break;
cptr++;
sptr++;
}
if (*cptr == ';' && !*sptr) break;
}
if (idx >= Config.cfScript.RunTimeCount)
{
/* nope, not found */
rqptr->rqResponse.HttpStatus = 500;
ErrorGeneral (rqptr,
"Execution of <tt>!AZ</tt> script types not configured.",
tkptr->FindScriptTypePtr, FI_LI);
return (STS$K_ERROR);
}
/* found the file type, point to the run-time stuff */
if (*cptr) cptr++;
while (ISLWS(*cptr)) cptr++;
tkptr->RunTimePtr = cptr;
}
}
}
if (tkptr->FindScriptCount == 2)
{
/*************************/
/* first, DCL procedures */
/*************************/
memcpy (sptr = tkptr->FindScript+tkptr->FindScriptLength, ".COM", 5);
tkptr->FindScriptTypePtr = sptr;
tkptr->FindScriptTotalLength = tkptr->FindScriptLength + 4;
tkptr->RunTimePtr = "@";
}
else
if (tkptr->FindScriptCount == 3)
{
/*******************************/
/* second, command definitions */
/*******************************/
memcpy (sptr = tkptr->FindScript+tkptr->FindScriptLength, ".CLD", 5);
tkptr->FindScriptTypePtr = sptr;
tkptr->FindScriptTotalLength = tkptr->FindScriptLength + 4;
tkptr->RunTimePtr = "=";
}
else
if (tkptr->FindScriptCount == 4)
{
/**********************/
/* third, executables */
/**********************/
memcpy (sptr = tkptr->FindScript+tkptr->FindScriptLength, ".EXE", 5);
tkptr->FindScriptTypePtr = sptr;
tkptr->FindScriptTotalLength = tkptr->FindScriptLength + 4;
tkptr->RunTimePtr = "$";
}
else
if (tkptr->FindScriptCount != 1 &&
tkptr->FindScriptCount-5 < Config.cfScript.RunTimeCount)
{
/*************************************/
/* subsequent, run-time environments */
/*************************************/
tkptr->FindScriptTypePtr = sptr =
tkptr->FindScript + tkptr->FindScriptLength;
for (cptr = Config.cfScript.RunTime[tkptr->FindScriptCount-5].StringPtr;
*cptr && *cptr != ';';
*sptr++ = *cptr++);
*sptr = '\0';
tkptr->FindScriptTotalLength = sptr - tkptr->FindScript;
if (*cptr) cptr++;
while (*cptr && ISLWS(*cptr)) cptr++;
tkptr->RunTimePtr = cptr;
}
else
if (tkptr->FindScriptCount != 1)
{
/**************/
/* not found! */
/**************/
rqptr->rqResponse.HttpStatus = 404;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_SCRIPT_NOT_FOUND), FI_LI);
return (STS$K_ERROR);
}
/* else 'tkptr->FindScriptCount' can be -1, when the type is supplied! */
/********************/
/* write search DCL */
/********************/
DclCommandDsc.dsc$a_pointer = tkptr->DclCommand;
DclCommandDsc.dsc$w_length = sizeof(tkptr->DclCommand)-1;
sys$fao (&SearchFaoDsc, &Length, &DclCommandDsc, tkptr->FindScript);
DECnetWrite (rqptr, tkptr->DclCommand, Length);
DECnetRead (rqptr);
return (SS$_RETRY);
}
/*****************************************************************************/
/*
Implement (most) OSU server scripting dialogs.
Behaviour determined from the OSU 'script_execute.c' module.
*/
DECnetOsuDialog (REQUEST_STRUCT *rqptr)
{
int cnt,
status;
unsigned short Length;
char *cptr, *sptr, *zptr;
char Buffer [2048];
$DESCRIPTOR (BufferDsc, Buffer);
DECNET_TASK *tkptr;
/*********/
/* begin */
/*********/
tkptr = rqptr->DECnetTaskPtr;
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetOsuDialog() !UL", tkptr->OsuDialogState);
if (tkptr->OsuDialogState == OSU_REUSE)
{
/**********************/
/* probing connection */
/**********************/
if (tkptr->QueuedDECnetIO) tkptr->QueuedDECnetIO--;
/* reuse needs to be reset with each use of the DECnet task */
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = false;
if (VMSnok (tkptr->DECnetWriteIOsb.Status))
{
/* problem writing to established connection, restart */
DECnetConnectEnd (tkptr);
DECnetConnectBegin (tkptr);
return;
}
InstanceGblSecIncrLong (&AccountingPtr->DoDECnetReuseCount);
InstanceGblSecIncrLong (&AccountingPtr->DoDECnetOsuReuseCount);
tkptr->OsuDialogState = OSU_BEGIN;
/* drop through to continue with first phase of dialog */
}
if (tkptr->OsuDialogState == OSU_BEGIN)
{
InstanceGblSecIncrLong (&AccountingPtr->DoDECnetOsuCount);
tkptr->OsuDnetRecMode = tkptr->OsuDnetCgi = false;
/*****************/
/* WASD_FILE_DEV */
/*****************/
/* if the v10 OSU DECnet object (logical name) is detected */
if (v10orPrev10("?WASD_DECNET_OSU_OBJECT\0",NULL))
{
/* requires a modified WWWEXEC.COM to accomodate this datum */
if (InstanceEnvNumber == 1)
DECnetWrite (rqptr, DECnetWasdFileDev, sizeof(DECnetWasdFileDev)-1);
else
{
sys$fao (&DECnetWasdFileDevFaoDsc, &Length, &BufferDsc,
InstanceEnvNumber, InstanceEnvNumber, InstanceEnvNumber);
Buffer[Length] = '\0';
DECnetWrite (rqptr, Buffer, Length);
}
}
/******************/
/* initial dialog */
/******************/
/*
OSU task executive expects four records as initial and unsolicited
data from the server. These are: script type, HTTP method name,
HTTP protocol version, request path (excluding any query string).
*/
DECnetWrite (rqptr, "HTBIN", 5);
DECnetWrite (rqptr, rqptr->rqHeader.MethodName, -1);
if (rqptr->rqResponse.HttpVersion == HTTP_VERSION_1_1)
cptr = "HTTP/1.1";
else
cptr = "HTTP/1.0";
DECnetWrite (rqptr, cptr, -1);
/*
URL (everything before any query string in original request)
OSU requires the mapped script portion, which we have have to
construct from the script name and the path information.
"<DNETRQURL>" provides the unmapped (original) request path.
*/
zptr = (sptr = Buffer) + sizeof(Buffer);
cptr = rqptr->ScriptName;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
cptr = rqptr->MappedPathPtr;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr >= zptr)
{
ErrorGeneralOverflow (rqptr, FI_LI);
DECnetEnd (rqptr);
return;
}
*sptr = '\0';
/* it's an asynchronous write so we need some persistent storage */
cptr = VmGetHeap (rqptr, sptr-Buffer+1);
memcpy (cptr, Buffer, sptr-Buffer+1);
DECnetWrite (rqptr, cptr, sptr-Buffer);
/* now into dialog state */
tkptr->OsuDialogState = OSU_DIALOG;
DECnetRead (rqptr);
return;
}
/**********************/
/* dialog established */
/**********************/
cptr = STR_DSC_PTR(&rqptr->NetWriteBufferDsc);
cnt = tkptr->DECnetReadIOsb.Count;
cptr[cnt] = '\0';
if (tkptr->OsuDialogState == OSU_DIALOG && *cptr != '<')
{
/************************/
/* start of data stream */
/************************/
/* now set the carriage-control appropriately */
if (tkptr->OsuDnetRecMode)
tkptr->OsuDialogState = OSU_OUTPUT_REC;
else
tkptr->OsuDialogState = OSU_OUTPUT_RAW;
/* drop through so the line can be processed by "_REC" or "_RAW" */
}
switch (tkptr->OsuDialogState)
{
case OSU_DIALOG :
/********************/
/* stream massaging */
/********************/
/* treat the same until I can work out what 2 does differently */
if (MATCH0 (cptr, "<DNETRECMODE>", 13) ||
MATCH0 (cptr, "<DNETRECMODE2>", 14))
{
/* forces text mode */
tkptr->OsuDnetRecMode = true;
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETCGI>", 9))
{
/* similar to raw mode except response header is checked */
tkptr->OsuDnetCgi = true;
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETRAW>", 9))
{
/* script handles all response formatting, return byte-for-byte */
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETTEXT>", 10))
{
/* script sends status line then plain text */
tkptr->OsuDialogState = OSU_DNETTEXT;
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "</DNETCGI>", 10) ||
MATCH0 (cptr, "</DNETRAW>", 10) ||
MATCH0 (cptr, "</DNETTEXT>", 11))
{
/* end of script output */
DECnetEnd (rqptr);
return;
}
/**********************/
/* information dialog */
/**********************/
if (MATCH0 (cptr, "<DNETARG>", 9))
{
/* full search argument (query string) */
cptr = VmGetHeap (rqptr, rqptr->rqHeader.QueryStringLength+2);
/* OSU supplies a leading '?' query separator */
*cptr = '?';
if (rqptr->rqHeader.QueryStringLength)
memcpy (cptr+1, rqptr->rqHeader.QueryStringPtr,
rqptr->rqHeader.QueryStringLength);
DECnetWrite (rqptr, cptr, rqptr->rqHeader.QueryStringLength+1);
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETARG2>", 10))
{
/* truncated search argument (query string) */
cptr = VmGetHeap (rqptr, 256);
/* OSU supplies a leading '?' query separator */
*cptr = '?';
if (rqptr->rqHeader.QueryStringLength > 253)
{
memcpy (cptr+1, rqptr->rqHeader.QueryStringPtr, 253);
DECnetWrite (rqptr, cptr, 254);
}
else
{
if (rqptr->rqHeader.QueryStringLength)
memcpy (cptr+1, rqptr->rqHeader.QueryStringPtr,
rqptr->rqHeader.QueryStringLength);
DECnetWrite (rqptr, cptr, rqptr->rqHeader.QueryStringLength+1);
}
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETPATH>", 10))
{
/* script path (but excluding script name itself) */
char *cptr;
for (cptr = rqptr->ScriptName; *cptr; cptr++);
while (cptr > rqptr->ScriptName && *cptr != '/') cptr--;
DECnetWrite (rqptr, rqptr->ScriptName,
cptr-(char*)rqptr->ScriptName+1);
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETHDR>", 9))
{
/* send the full request header */
tkptr->OsuDialogState = OSU_DNET_HDR;
DECnetWriteRequest (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETINPUT>", 11))
{
/* begin to write the request body */
tkptr->OsuDialogState = OSU_DNET_INPUT;
DECnetWriteRequest (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETBINDIR>", 12))
{
/*
OSU script and binaries VMS directory specification.
Isolate the 'HT_ROOT:[dir]' from the example
'node::"0=wwwexec"HT_ROOT:[dir]script.ext'
*/
for (cptr = tkptr->MappedScript; *cptr && *cptr != ':'; cptr++);
if (*cptr == ':') cptr++;
if (*cptr == ':') cptr++;
if (*cptr == '\"')
{
cptr++;
while (*cptr && *cptr != '\"') cptr++;
if (*cptr) cptr++;
}
sptr = cptr;
while (*cptr) cptr++;
while (cptr > sptr && *cptr != ']') cptr--;
DECnetWrite (rqptr, sptr, cptr - sptr + 1);
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETRQURL>", 11))
{
/* full request URL prior to any mapping */
DECnetWrite (rqptr, rqptr->rqHeader.RequestUriPtr, -1);
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETINVCACHE>", 14))
{
/* invalidate cache */
rqptr->rqResponse.HttpStatus = 501;
ErrorGeneral (rqptr, ErrorOsuNoInvCache, FI_LI);
DECnetEnd (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETHOST>", 10))
{
/* server host name */
DECnetWrite (rqptr, rqptr->ServicePtr->ServerHostName, -1);
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETID>", 8))
{
/* composite line of request data */
DECnetOsuDnetId (rqptr, tkptr, false);
return;
}
if (MATCH0 (cptr, "<DNETID2>", 9))
{
/* composite line of request data (plus a bit!) */
DECnetOsuDnetId (rqptr, tkptr, true);
return;
}
if (MATCH0 (cptr, "<DNETMANAGE>", 12))
{
/* server management */
rqptr->rqResponse.HttpStatus = 500;
ErrorGeneral (rqptr, ErrorOsuNoManage, FI_LI);
DECnetEnd (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETREUSE>", 11))
{
if (Config.cfScript.DECnetReuseLifeTime)
{
/* reuse enabled, do not drop DECnet link */
if (tkptr->cnptr) tkptr->cnptr->ReuseConnection = true;
}
DECnetRead (rqptr);
return;
}
if (MATCH0 (cptr, "<DNETXLATE>", 11) ||
MATCH0 (cptr, "<DNETXLATEV>", 12))
{
/* into translate state */
tkptr->OsuDialogState = OSU_DNET_XLATE;
/* read the path to be translated */
DECnetRead (rqptr);
return;
}
/* hmmm, unknown dialog tag */
{
status = FaoToBuffer (Buffer, sizeof(Buffer), NULL,
ErrorOsuUnknown, cptr);
if (VMSnok (status) || status == SS$_BUFFEROVF)
ErrorNoticed (rqptr, status, NULL, FI_LI);
rqptr->rqResponse.HttpStatus = 500;
ErrorGeneral (rqptr, Buffer, FI_LI);
DECnetEnd (rqptr);
return;
}
/****************/
/* other states */
/****************/
case OSU_DNETTEXT :
/*
This output record contains a status line something like "200 ok".
Get the status code, ignore the rest, generate an HTTP header.
Then move into a state to accept record-oriented script output.
*/
while (*cptr && !isdigit(*cptr) && *cptr != '\n') cptr++;
if (isdigit(*cptr)) rqptr->rqResponse.HttpStatus = atoi(cptr);
ResponseHeader (rqptr, rqptr->rqResponse.HttpStatus,
"text/plain", -1, NULL, NULL);
/* note that the script has generated some output */
tkptr->ScriptResponded = true;
/* now move into record output state */
tkptr->OsuDialogState = OSU_OUTPUT_REC;
DECnetRead (rqptr);
return;
case OSU_OUTPUT_RAW :
/*
This script output record is "binary" data. Write it to
the client via the network without any further processing.
*/
if (MATCH0 (cptr, "</DNETCGI>", 10) ||
MATCH0 (cptr, "</DNETRAW>", 10) ||
MATCH0 (cptr, "</DNETTEXT>", 11))
{
/* end of script output */
DECnetEnd (rqptr);
return;
}
/* note that the script has generated some output */
tkptr->ScriptResponded = true;
if (tkptr->OsuDnetCgi && !rqptr->rqCgi.ProcessingBody)
{
/* force output processor into stream mode */
rqptr->rqCgi.OutputMode = CGI_OUTPUT_MODE_STREAM;
/* "CGI" script, check header */
cnt = CgiOutput (rqptr, cptr, cnt);
if (cnt < 0)
{
/* CgiOutput() error responses have codes less than zero */
rqptr->rqResponse.HttpStatus = 502;
ErrorGeneral (rqptr,
MsgFor(tkptr->RequestPtr,MSG_SCRIPT_RESPONSE_ERROR), FI_LI);
DECnetEnd (rqptr);
return;
}
}
if (!cnt)
{
/* absorb output, queue the next read from the script */
DECnetRead (rqptr);
return;
}
tkptr->QueuedNetWrite++;
NetWrite (rqptr, &DECnetRead, cptr, cnt);
return;
case OSU_OUTPUT_REC :
/*
This record of script output is essentially a line of "text".
Ensure it has correct HTTP carriage-control (trailing newline).
Write this (possibly) massaged record to the client (network).
*/
if (MATCH0 (cptr, "</DNETCGI>", 10) ||
MATCH0 (cptr, "</DNETRAW>", 10) ||
MATCH0 (cptr, "</DNETTEXT>", 11))
{
/* end of script output */
DECnetEnd (rqptr);
return;
}
/* note that the script has generated some output */
tkptr->ScriptResponded = true;
if (tkptr->OsuDnetCgi && !rqptr->rqCgi.ProcessingBody)
{
/* force output processor into record mode */
rqptr->rqCgi.OutputMode = CGI_OUTPUT_MODE_RECORD;
/* "CGI" script, check header */
cnt = CgiOutput (rqptr, cptr, cnt);
if (cnt < 0)
{
/* CgiOutput() error responses have codes less than zero */
rqptr->rqResponse.HttpStatus = 502;
ErrorGeneral (rqptr,
MsgFor(tkptr->RequestPtr,MSG_SCRIPT_RESPONSE_ERROR), FI_LI);
DECnetEnd (rqptr);
return;
}
}
else
{
/* adjust carriage-control if necessary */
if (cnt)
{ if (cptr[cnt-1] != '\n') cptr[cnt++] = '\n'; }
else
cptr[cnt++] = '\n';
cptr[cnt] = '\0';
}
if (!cnt)
{
/* absorb output, queue the next read from the script */
DECnetRead (rqptr);
return;
}
tkptr->QueuedNetWrite++;
NetWrite (rqptr, &DECnetRead, cptr, cnt);
return;
case OSU_DNET_XLATE :
/* record contains a URL-style path to be translated into RMS */
DECnetOsuDnetXlate (rqptr, tkptr, cptr);
return;
default :
/* Hmmm, problem? */
rqptr->rqResponse.HttpStatus = 500;
ErrorGeneral (rqptr, ErrorOsuImplementation, FI_LI);
DECnetEnd (rqptr);
return;
}
}
/*****************************************************************************/
/*
Write a single record comprising a series of white-space separated request
data to the OSU task.
*/
DECnetOsuDnetId
(
REQUEST_STRUCT *rqptr,
DECNET_TASK *tkptr,
BOOL Id2
)
{
static $DESCRIPTOR (SignedLongFaoDsc, "!SL\0");
static $DESCRIPTOR (UnsignedLongFaoDsc, "!UL\0");
char Buffer [1024],
String [256];
char *cptr, *sptr, *zptr;
$DESCRIPTOR (StringDsc, String);
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET, "DECnetOsuDnetId()");
cptr = STR_DSC_PTR(&rqptr->NetWriteBufferDsc);
zptr = (sptr = Buffer) + sizeof(Buffer);
/* server identification (underscores substituted for spaces) */
cptr = SoftwareID;
while (*cptr && sptr < zptr)
{
if (*cptr == ' ')
{
*sptr++ = '_';
cptr++;
}
else
*sptr++ = *cptr++;
}
/* local host */
if (sptr < zptr) *sptr++ = ' ';
for (cptr = rqptr->ServicePtr->ServerHostName;
*cptr && sptr < zptr; *sptr++ = *cptr++);
/* local port */
if (sptr < zptr) *sptr++ = ' ';
for (cptr = rqptr->ServicePtr->ServerPortString;
*cptr && sptr < zptr; *sptr++ = *cptr++);
/* remote (client) port */
if (sptr < zptr) *sptr++ = ' ';
sys$fao (&UnsignedLongFaoDsc, 0, &StringDsc,
rqptr->ClientPtr->IpPort);
for (cptr = String; *cptr && sptr < zptr; *sptr++ = *cptr++);
/* remote host address (OSU cannot support IPv6 using this mechanism) */
if (sptr < zptr) *sptr++ = ' ';
if (IPADDRESS_IS_V4(&rqptr->ClientPtr->IpAddress))
sys$fao (&SignedLongFaoDsc, 0, &StringDsc,
IPADDRESS_ADR4(&rqptr->ClientPtr->IpAddress));
else
strcpy (String, "0");
for (cptr = String; *cptr && sptr < zptr; *sptr++ = *cptr++);
/* remote user */
if (rqptr->RemoteUser[0])
{
if (sptr < zptr) *sptr++ = ' ';
for (cptr = rqptr->RemoteUser; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
else
if (Id2)
if (sptr < zptr) *sptr++ = ' ';
if (Id2 && Config.cfMisc.DnsLookupClient)
{
/* remote host name */
if (sptr < zptr) *sptr++ = ' ';
for (cptr = rqptr->ClientPtr->Lookup.HostName;
*cptr && sptr < zptr;
*sptr++ = *cptr++);
}
*sptr = '\0';
/* it's an asynchronous write so we need some persistent storage */
cptr = VmGetHeap (rqptr, sptr-Buffer+1);
memcpy (cptr, Buffer, sptr-Buffer+1);
DECnetWrite (rqptr, cptr, sptr-Buffer);
DECnetRead (rqptr);
}
/*****************************************************************************/
/*
Map the supplied path (either absolute or relative to the request path) into a
VMS file system specification and write that to the OSU task.
*/
DECnetOsuDnetXlate
(
REQUEST_STRUCT *rqptr,
DECNET_TASK *tkptr,
char *Path
)
{
int TransPathLength;
char *cptr;
char AbsPath [256],
TransPath [256],
VmsPath [256+7];
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET,
"DECnetOsuDnetXlate() !&Z", Path);
/* WASD always ignores any method */
if (*(cptr = Path) == '(')
{
while (*cptr && *cptr != ')') cptr++;
if (*cptr) cptr++;
}
TransPath[0] = VmsPath[0] = '\0';
TransPathLength = 0;
if (*cptr == '.')
{
MapUrl_VirtualPath (rqptr->rqHeader.PathInfoPtr, cptr,
AbsPath, sizeof(AbsPath));
cptr = AbsPath;
}
if (*cptr)
{
MapUrl_Map (cptr, 0, VmsPath, sizeof(VmsPath), NULL, 0, NULL, 0, NULL, 0,
NULL, rqptr, NULL);
TransPathLength = MapOdsVmsToUrl (TransPath, VmsPath,
sizeof(TransPath), false, 0);
}
DECnetWrite (rqptr, TransPath, TransPathLength);
DECnetRead (rqptr);
/* back from translate into dialog state */
tkptr->OsuDialogState = OSU_DIALOG;
}
/*****************************************************************************/
/*
Every minute scan the list of network connections looking for those whose
lifetimes have expired. Break the connection of those who have. As this is a
one minute tick set the lifetime counters to configuration plus one to ensure
at least that number of minutes before expiry.
*/
BOOL DECnetSupervisor (int PeriodSeconds)
{
static int TaskScanSeconds = 0;
BOOL ContinueTicking;
int status,
DassgnCount,
MinSeconds;
LIST_ENTRY *leptr;
DECNET_CONNECT *cnptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_DECNET) && PeriodSeconds != -1)
WatchThis (WATCHALL, WATCH_MOD_DECNET,
"DECnetSupervisor() !SL !UL", PeriodSeconds, HttpdTickSecond);
if (PeriodSeconds >= 0)
{
/* initiate or reset the task supervisor ticking */
if (PeriodSeconds)
{
if (HttpdTickSecond + PeriodSeconds < TaskScanSeconds &&
PeriodSeconds >= DECNET_SUPERVISOR_TICK_MIN &&
PeriodSeconds <= DECNET_SUPERVISOR_TICK_MAX)
TaskScanSeconds = HttpdTickSecond + PeriodSeconds;
}
else
if (!TaskScanSeconds)
TaskScanSeconds = HttpdTickSecond + DECNET_SUPERVISOR_TICK_MAX;
return (false);
}
/*******************/
/* task supervisor */
/*******************/
/* no script process is currently executing */
if (!TaskScanSeconds) return (false);
/* script process executing, but no need to do a scan just yet */
if (TaskScanSeconds > HttpdTickSecond)
{
DECnetCountConnection ();
return (true);
}
DassgnCount = 0;
ContinueTicking = false;
MinSeconds = DECNET_SUPERVISOR_TICK_MAX;
for (leptr = DECnetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
cnptr = (DECNET_CONNECT*)leptr;
/* only interested in those which are currently connected */
if (!cnptr->DECnetChannel) continue;
if (cnptr->RequestPtr)
{
if (cnptr->RequestPtr->RequestState >= REQUEST_STATE_ABORT)
{
ContinueTicking = true;
DECnetEnd (cnptr->RequestPtr);
continue;
}
}
if (cnptr->LifeTimeSecond > HttpdTickSecond)
{
ContinueTicking = true;
if (cnptr->LifeTimeSecond - HttpdTickSecond < MinSeconds)
MinSeconds = cnptr->LifeTimeSecond - HttpdTickSecond;
continue;
}
status = sys$dassgn (cnptr->DECnetChannel);
cnptr->DECnetChannel = cnptr->LifeTimeSecond = 0;
DassgnCount++;
}
if (WATCH_MODULE(WATCH_MOD_DECNET))
WatchThis (WATCHALL, WATCH_MOD_DECNET,
"SUPERVISOR !&B !UL", ContinueTicking, MinSeconds);
if (DassgnCount) DECnetCountConnection ();
if (ContinueTicking)
{
/* at least one item in the connect list */
if (MinSeconds < 0) MinSeconds = 0;
TaskScanSeconds = HttpdTickSecond + MinSeconds;
return (true);
}
/* reinitialize the supervisor timings */
TaskScanSeconds = 0;
return (false);
}
/*****************************************************************************/
/*
Update the accounting accumulator.
*/
DECnetCountConnection ()
{
int CgiCount,
ConnectCount,
OsuCount;
DECNET_CONNECT *cnptr;
LIST_ENTRY *leptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_DECNET))
WatchThis (WATCHALL, WATCH_MOD_DECNET,
"DECnetCountConnection()");
ConnectCount = CgiCount = OsuCount = 0;
for (leptr = DECnetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
cnptr = (DECNET_CONNECT*)leptr;
if (!cnptr->DECnetChannel) continue;
ConnectCount++;
if (!cnptr->RequestPtr) continue;
if (!cnptr->RequestPtr->DECnetTaskPtr) continue;
if (cnptr->RequestPtr->DECnetTaskPtr->ScriptType == SCRIPT_CGI)
CgiCount++;
else
if (cnptr->RequestPtr->DECnetTaskPtr->ScriptType == SCRIPT_OSU)
OsuCount++;
}
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
AccountingPtr->CurrentDECnetTasks[InstanceNumber] = ConnectCount;
AccountingPtr->CurrentDECnetCGI[InstanceNumber] = CgiCount;
AccountingPtr->CurrentDECnetOSU[InstanceNumber] = OsuCount;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
/*****************************************************************************/
/*
Return a report on DECnet scripting, in particular displaying each item in the
connection list.
*/
DECnetScriptingReport (REQUEST_STRUCT *rqptr)
{
static char BeginPageFao [] =
"<p><table class=\"ctgry\">\n\
<tr><td>\n\
<table class=\"rghtrght\">\n\
<tr><td></td><th><u>Count</u></th><th><u>Reuse</u></th></tr>\n\
<tr><th>Total:</th><td>!&L</td><td>!&L</td></tr>\n\
<tr><th>CGI-script:</th><td>!&L</td><td>!&L</td></tr>\n\
<tr><th>OSU-script:</th><td>!&L</td><td>!&L</td></tr>\n\
<tr><th>As:</th><td colspan=\"2\" class=\"talft\">!AZ</td></tr>\n\
</table>\n\
</td></tr>\n\
</table>\n\
\
<p><table class=\"rghtrght\">\n\
<tr>\
<th></th>\
<th class=\"sbttl talft\">Connect / Client</th>\
<th class=\"sbttl talft\">Lifetime / Request</th>\
<th class=\"sbttl\">Reused</th>\
<th class=\"sbttl\">Total</th>\
<th class=\"sbttl talft\">Last</th>\
</tr>\n";
static char ItemFao [] =
"<tr><th>!3ZL</th>\
<td class=\"talft\">!&@</td>\
<td class=\"talft\">!AZ</td>\
<td>!&L</td>\
<td>!&L</td>\
<td class=\"talft\">!20%D</td>\
<tr>\n\
!&@";
static char EmptyConnectListFao [] =
"<tr class=\"hlght\"><th>000</th>\
<td class=\"talft\" colspan=\"5\"><i>empty</i></td><tr>\n";
static char ButtonsFao [] =
"</table>\n\
<p><table class=\"lftlft\">\n\
<tr><td>\n\
<form method=\"GET\" action=\"!AZ\">\n\
<input type=\"submit\" value=\" Purge Idle \">\n\
</form>\n\
</td><td>\n\
<form method=\"GET\" action=\"!AZ\">\n\
<input type=\"submit\" value=\" Force Disconnect \">\n\
</form>\n\
</td></tr>\n\
</table>\n\
!AZ\
</div>\n\
</body>\n\
</html>\n";
int status,
Count;
unsigned long FaoVector [32];
unsigned long *vecptr;
char *cptr;
DECNET_CONNECT *cnptr;
LIST_ENTRY *leptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET, "DECnetScriptingReport()");
AdminPageTitle (rqptr, "DECnet Scripting Report");
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
vecptr = FaoVector;
*vecptr++ = AccountingPtr->DoDECnetCount;
*vecptr++ = AccountingPtr->DoDECnetReuseCount;
*vecptr++ = AccountingPtr->DoDECnetCgiCount;
*vecptr++ = AccountingPtr->DoDECnetCgiReuseCount;
*vecptr++ = AccountingPtr->DoDECnetOsuCount;
*vecptr++ = AccountingPtr->DoDECnetOsuReuseCount;
if (HttpdScriptAsUserName[0])
*vecptr++ = HttpdScriptAsUserName;
else
*vecptr++ = HttpdProcess.UserName;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
status = FaolToNet (rqptr, BeginPageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
Count = 0;
for (leptr = DECnetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
cnptr = (DECNET_CONNECT*)leptr;
if (WATCHMOD (rqptr, WATCH_MOD_DECNET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_DECNET, "!&X !UL !&X",
cnptr, cnptr->DECnetChannel, cnptr->RequestPtr);
vecptr = FaoVector;
*vecptr++ = ++Count;
if (cnptr->DECnetChannel)
{
*vecptr++ = "!AZ";
*vecptr++ = cnptr->ConnectString;
}
else
{
*vecptr++ = "<i>!AZ</i>";
*vecptr++ = cnptr->ConnectString;
}
*vecptr++ = MetaConShowSeconds (rqptr, cnptr->LifeTimeSecond -
HttpdTickSecond);
*vecptr++ = cnptr->ReUsageCount;
*vecptr++ = cnptr->UsageCount;
*vecptr++ = &cnptr->LastUsedTime64;
if (cnptr->RequestPtr)
{
*vecptr++ =
"<tr class=\"hlght\"><td></td><td>!&@!AZ</td>\
<td colspan=\"4\">!&;AZ</td></tr>\n";
if (cnptr->RequestPtr->RemoteUser[0])
{
*vecptr++ = "!&;AZ@";
*vecptr++ = cnptr->RequestPtr->RemoteUser;
}
else
*vecptr++ = "";
*vecptr++ = cnptr->RequestPtr->ClientPtr->Lookup.HostName;
*vecptr++ = cnptr->RequestPtr->rqHeader.RequestUriPtr;
}
else
*vecptr++ =
"<tr class=\"hlght\"><td></td>\
<td class=\"talft\" colspan=\"5\"><i>idle</i></td></tr>\n";
status = FaolToNet (rqptr, ItemFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
if (!DECnetConnectList.HeadPtr)
{
status = FaolToNet (rqptr, EmptyConnectListFao, NULL);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
vecptr = FaoVector;
*vecptr++ = ADMIN_CONTROL_DECNET_PURGE;
*vecptr++ = ADMIN_CONTROL_DECNET_DISCONNECT;
*vecptr++ = AdminRefresh();
status = FaolToNet (rqptr, ButtonsFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
rqptr->rqResponse.PreExpired = PRE_EXPIRE_ADMIN;
ResponseHeader200 (rqptr, "text/html", &rqptr->NetWriteBufferDsc);
AdminEnd (rqptr);
}
/*****************************************************************************/
/*
Same as for DECnetPurgeAllConnect() except called from control module from
command line!
*/
char* DECnetControlDisconnect (BOOL WithExtremePrejudice)
{
static char Response [64];
static $DESCRIPTOR (ResponseFaoDsc,
"!UL disconnected, !UL marked for disconnection");
static $DESCRIPTOR (ResponseDsc, Response);
int status,
DassgnCount,
DisconnectedCount,
MarkedCount;
unsigned short Length;
LIST_ENTRY *leptr;
DECNET_CONNECT *cnptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_DECNET))
WatchThis (WATCHALL, WATCH_MOD_DECNET,
"DECnetControlPurgeAllConnect() !UL", WithExtremePrejudice);
DECnetPurgeAllConnectCount++;
DassgnCount = DisconnectedCount = MarkedCount = 0;
for (leptr = DECnetConnectList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
cnptr = (DECNET_CONNECT*)leptr;
/* only interested in those which are currently connected */
if (!cnptr->DECnetChannel) continue;
if (WithExtremePrejudice ||
!cnptr->RequestPtr)
{
/* connection not active, or we don't care, disconnect */
status = sys$dassgn (cnptr->DECnetChannel);
cnptr->DECnetChannel = cnptr->LifeTimeSecond = 0;
DisconnectedCount++;
DassgnCount++;
continue;
}
else
{
/* connection is currently active, disconnect when finished */
cnptr->IsMarkedForDisconnect = true;
MarkedCount++;
}
}
if (DassgnCount) DECnetCountConnection ();
sys$fao (&ResponseFaoDsc, &Length, &ResponseDsc,
DisconnectedCount, MarkedCount);
Response[Length] = '\0';
return (Response);
}
/*****************************************************************************/