[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]
/*****************************************************************************/
/*
Control.c
This module implements the HTTPd command-line, and the distributed, to-all
server processes (from command-line or Admin Menu), control functionality.
Command-line server control commands:
*/
static char ControlHelp[] =
"\n\
o ALIGN= START, STOP, ZERO with [<buf-size>,<items>,<mask>]\n\
o AUTH reload authorization file\n\
AUTH=CHECK elementary check of authorization file\n\
(may require additional server command-line parameters)\n\
AUTH=LOAD reload authorization file\n\
AUTH=PURGE purge authentication records from cache\n\
o AUTH=SKELKEY=_<name>:<psswd>[:<hours>] temporary authorisation\n\
o CACHE=ON turn file caching on\n\
CACHE=OFF turn file caching off\n\
CACHE=PURGE purge all data cached\n\
o CONFIG=CHECK elementary check of all configuration files\n\
(may require additional server command-line parameters)\n\
o DCL=DELETE unconditionally delete all DCL script processes\n\
DCL=DELETE=FILE=<pattern>\n\
DCL=DELETE=SCRIPT=<pattern>\n\
DCL=DELETE=USER=<username>\n\
o DCL=PROCTOR=APPLY apply any additional rule(s)\n\
DCL=PROCTOR=LOAD (re)load [DclScriptProctor] configuration\n\
(DCL=PURGE or DCL=DELETE to proactively change)\n\
o DCL=PURGE delete idle script processes, mark busy for later deletion\n\
DCL=PURGE=FILE=<pattern>\n\
DCL=PURGE=SCRIPT=<pattern>\n\
DCL=PURGE=USER=<username>\n\
o DECNET=PURGE disconnect idle DECnet script tasks\n\
DECNET=DISCONNECT forceably disconnect all DECnet script tasks\n\
o EXIT exit after all current client activity complete\n\
EXIT=NOW exit right now regardless of connections\n\
o GLOBAL=CHECK elementary check of the global configuration file\n\
o HTTP2=PURGE purge idle HTTP/2 connections\n\
HTTP2=PURGE=<integer> this particular HTTP/2 connection number\n\
HTTP2=PURGE=ALL purge all HTTP/2 connections\n\
o INSTANCE=MAX|CPU|<integer> explicitly set the startup instance value\n\
INSTANCE=ACTIVE|STANDBY move between active and standby mode\n\
o LIST when used with /ALL just list all servers\n\
o LOG=CLOSE close the log file(s)\n\
LOG=FLUSH flush the log file(s)\n\
LOG=OPEN open the log file(s)\n\
LOG=REOPEN closes then reopens the log\n\
o MAP reload mapping rule file\n\
MAP=CHECK elementary check of the mapping rule file\n\
(may require additional server command-line parameters)\n\
MAP=LOAD reload mapping rule file\n\
o MSG=CHECK elementary check of the message file\n\
o NET=LIST list all network connections\n\
o NET=PURGE purge persistent (idle) connections\n\
NET=PURGE=<integer> purge this particular connection number\n\
NET=PURGE=ALL purge all (idle and non-idle) connections\n\
NET=PURGE=HTTP1 purge all (ditto) HTTP/1.n connections\n\
NET=PURGE=HTTP2 purge all (ditto) HTTP/2 connections\n\
NET=PURGE=URI=<pattern> purge connections with matching request URI\n\
o NET=RESUME resume accepting connections (see suspend)\n\
o NET=SUSPEND stop accepting connections (see resume)\n\
NET=SUSPEND=NOW as for suspend and terminate those in-progress\n\
o NOTE=<string> provide an admin note to the metacon rules\n\
o PROXY=ON proxy processing enabled\n\
PROXY=OFF proxy processing disabled\n\
o REQUEST=RUNDOWN=<integer> run down (terminate) the specified request\n\
REQUEST=RUNDOWN=ALL run down all current requests\n\
o RESTART effectively exit server image then re-activate\n\
RESTART=NOW restart NOW regardless of connections\n\
RESTART=QUIET restart if-and-when current requests reach zero\n\
o SERVICE=CHECK elementary check of service file\n\
o SSL=CA=LOAD reload the CA verification file\n\
SSL=CERT=LOAD reload all service Certificate files\n\
SSL=KEY=PASSWORD prompt/supply private key password\n\
o STATUS display the status of all instances\n\
STATUS=NOW instances immediately update their status\n\
STATUS=PURGE reset stale instance status information\n\
STATUS=RESET reset all instance status information\n\
o THROTTLE=RELEASE release all queued requests for processing\n\
THROTTLE=RELEASE=SCRIPT=<pattern>\n\
THROTTLE=RELEASE=USER=<username>\n\
THROTTLE=TERMINATE terminate all queued requests \n\
THROTTLE=TERMINATE=SCRIPT=<pattern>\n\
THROTTLE=TERMINATE=USER=<username>\n\
THROTTLE=ZERO zero throttle statistics\n\
o WEBSOCKET=DISCONNECT all WebSocket connections\n\
WEBSOCKET=DISCONNECT=<integer> this WebSocket connection number\n\
WEBSOCKET=DISCONNECT=SCRIPT=<pattern> matching this script name\n\
WEBSOCKET=DISCONNECT=USER=<pattern> matching this scripting user name\n\
o ZERO zero all accounting\n\
ZERO=NOTICED zero the \'errors noticed\' accounting\n\
ZERO=PROXY zero proxy accounting\n\
ZERO=STATUS clear any STATUS message as displayed by HTTPDMON\n\
\n";
/*
o /NOTE=<string> *INTERNAL* CLI /NOTE=<string> to prcoess log
o SSL=CERT=LOAD *INTERNAL* (re)load SSL server certificate(s)
o TICKET=KEY\0<48-bytes> *INTERNAL* propagate session ticket key\n\
o LOG=OPEN=<name> *OBSOLETE* open log file using the specified name
o LOG=REOPEN=<name> *OBSOLETE* log reopened using specified name
o LOG=FORMAT=<string> *OBSOLETE* set the log format
o LOG=PERIOD=<string> *OBSOLETE* set the log period
o PROXY=STATISTICS *OBSOLETE* perform statistics scan of cache\n\
o PROXY=PURGE=BACKGROUND *OBSOLETE* background cache purge\n\
PROXY=PURGE=HOST *OBSOLETE* host name cache purge\n\
PROXY=PURGE=REACTIVE *OBSOLETE* reactive cache purge\n\
PROXY=PURGE=ROUTINE *OBSOLETE* routine cache purge\n\
o PROXY=STOP=SCAN *OBSOLETE* stop in-progress purge or statistics\n\
These commands are entered at the DCL command line (interpreted in the CLI.c
module) in the following manner.
$ HTTPD /DO=command
If /ALL is added then the command is applied to all HTTPd server processes on
the node or cluster (asuming there is more than one executing, requires
SYSLCK). Due to architectural constraints, those commands marked "*" in the
above list cannot be used with the /ALL qualifier.
$ HTTPD /DO=command /ALL
For example:
$ HTTPD /DO=HELP display the above summary
$ HTTPD /DO=EXIT the server exits if when clients connected
$ HTTPD /DO=EXIT=NOW the server exists immediately
$ HTTPD /DO=RESTART server exits and then restarts
$ HTTPD /DO=RESTART/ALL all servers on node/cluster exit and restarts
$ HTTPD /DO=DCL=PURGE delete all persistent DCL script processes
$ HTTPD /DO=LOG=CLOSE close the log file
$ HTTPD /DO=ZERO/ALL zero the accounting on all servers
$ HTTPD /DO=LIST/ALL *special-case*, just list all servers
Single node and cluster directives are implemented using cluster-wide locking
resource names and shared memory. For single server /DO= control the
lock-resource name serves to notify (all) server(s) that a directive has been
written into the global section shared memory control buffer. All
participating servers check this area, only the one with a current directive
written into its shared-memory control buffer performs it. For multiple server
/DO=/ALL control, the lock value block contains the actual directive and so
participating servers act on that alone. The originating image requests a
cluster-wide lock before originating a directive, effectively locking others
out during the process (which is most commonly a very short period).
Servers could potentially be grouped using the resource names. The /ALL
qualifier accepts an optional string that will become part of the lock resource
name. Hence when servers belonging to a particular group are started up the
startup procedure would include something like "/ALL=1", and then Admin Menu
directives would apply to only those in that group, and command-line directives
would be used "/DO=command/ALL=1", etc. Note that the /ALL= parameter can be
any alphanumeric string up to 8 characters.
DCL PURGE/DELETE PARAMETERS
---------------------------
On non-VAX systems under VMS V8.2 or later (and supported by the 64 byte lock
value block) is is possible to supply further parameters refining the scope of
the PURGE/DELETE.
The following directive limits the PURGE/DELETE to script processes executing
under the specified account.
HTTPD/DO=DCL=PURGE=USER=<username>
HTTPD/DO=DCL=DELETE=USER=<username>
This variant acts only on script processes with script paths matching the
specified pattern.
HTTPD/DO=DCL=PURGE=SCRIPT=<pattern>
HTTPD/DO=DCL=DELETE=SCRIPT=<pattern>
This variant acts only on script processes with script VMS file specifications
matching the specified pattern.
HTTPD/DO=DCL=PURGE=FILE=<pattern>
HTTPD/DO=DCL=DELETE=FILE=<pattern>
These cannot be combined.
THROTTLE RELEASE/TERMINATE PARAMETERS
-------------------------------------
In a similar fashion to the DCL= parameters, on non-VAX systems under VMS V8.2
or later is is possible to supply further parameters refining the scope of the
RELEASE/TERMINATE.
The following directive limits the PURGE/DELETE to script processes executing
under the specified account.
HTTPD/DO=THROTTLE=RELEASE=USER=<username>
HTTPD/DO=THROTTLE=TERMINATE=USER=<username>
This variant acts only on script processes with script paths matching the
specified pattern.
HTTPD/DO=THROTTLE=RELEASE=SCRIPT=<pattern>
HTTPD/DO=THROTTLE=TERMINATE=SCRIPT=<pattern>
These cannot be combined.
SERVER CONTROL LOCK
-------------------
When a server starts up it uses InstanceNotifySet() to enqueue a CR
(concurrent read) lock against the resource name using ControlHttpdLock().
This lock allows a "blocking" AST to be delivered (back to ControlHttpdLock())
indicating a CLI-command or other server is wishing to initiate a control
action. It releases that original CR lock then immediately enqueues another CR
so that it can read the lock value block subsequently written to by the
initiator's now-granted EX mode lock (see immediately below). For VAX and
pre-V8.2 Alpha and Itanium the lock value block will contain a maximum 15
character, null-terminated string (the 16 bytes) with the directive. For
non-VAX V8.2 and later the lock value block has a maximum size of 64 bytes,
allowing a 63 character string. The AST delivery will provide this value block
to ControlHttpdAst() which calls the appropriate function to perform or ignore
the directive.
INITIATOR CONTROL LOCK
----------------------
To initiate some control activity on one or more servers the initiator (either
at the command-line or from the Admin Menu) enqueues a CR (concurrent read)
lock on the appropriate resource name. It then converts that lock to EX
(exclusive). Those with original CR locks enqueued have a "blocking" AST
delivered, release their locks allowing the initiator to obtain the requested
EX lock. It then, using a sys$deq(), writes the command string into the lock
value block. When the exclusive lock is dequeued the servers waiting on the
subsequent CR locks have them delivered, allowing them to read the value block
and they can then check the lock status block for a directive (which they may
or may not act upon depending on the contents).
VERSION HISTORY
---------------
11-SEP-2021 MGD /DO=NET=LIST
/DO=NET=PURGE=HTTP1
/DO=NET=PURGE=HTTP2
27-DEC-2020 MGD /DO=DCL=PROCTOR=APPLY
/DO=DCL=PROCTOR=LOAD
05-AUG-2020 MGD bugfix; ControlDoHelp() remove non-existant DISCONNECT=..
26-FEB-2020 MGD /DO=SSL=RESET (careful! experimental)
20-AUG-2019 MGD /DO=NET=BREAK=<integer> see NetTestBreak()
30-JUL-2019 MGD bugfix; /DO=AUTH=SKELKEY=.. expiry (arghhh)
07-SEP-2018 MGD bugfix; /DO=AUTH=SKELKEY=.. cluster wide - yet again :-(
23-AUG-2018 MGD ControlHttpdAst() CONTROL_ZERO_STATUS
30-JUN-2018 MGD bugfix; /DO=AUTH=SKELKEY=.. cluster wide (yet again :-)
11-JUN-2018 MGD /REQUEST=RUNDOWN=.. to terminate (a) request(s)
03-JUN-2018 MGD SesolaControlReloadCert() undoes SesolaControlReloadService()
because it didn't actually work :-/
so /DO=SSL=SERVICE=LOAD[=<host:port>] no longer works
19-MAY-2018 MGD /DO=ADHOC=... intended for ad-hoc development commands
15-MAY-2018 MGD bugfix; /DO=AUTH=SKELKEY=.. cluster wide
28-APR-2018 MGD refactor Admin..() AST delivery
02-FEB-2018 MGD SesolaControlCertLoad() becomes SesolaControlServiceLoad()
/DO=SSL=SERVICE=LOAD[=<host:port>] SSL context reload
12-NOV-2017 MGD ControlZeroAccounting () save/restore instance status data
18-OCT-2017 MGD /DO=HELP brief summary of command-ine /DOs
/NOTE=<string> annotation to server process log
/STATUS[=RESET] report on all instance status
12-JUN-2016 MGD /DO=TICKET=KEY to refresh TLS session ticket key
02-DEC-2015 MGD /DO=HTTP2=PURGE[=<integer>]
19-NOV-2014 MGD refine ControlMessage() for direct call
bugfix; ControlCommand() exit after CONTROL_SSL_PKPASSWD
15-OCT-2011 MGD /DO=NET=PURGE[=..] expanded
/DO=WEBSOCKET=DISCONNECT[=..]
12-MAR-2011 MGD /DO=ALIGN=..
14-JUL-2010 MGD command-line checks of configuration files
/DO=AUTH=CHECK /DO=CONFIG=CHECK (all configuration files)
/DO=GLOBAL=CHECK /DO=MAP=CHECK /DO=MSG=CHECK
/DO=SERVICE=CHECK
01-JUL-2010 MGD Mapurl_ControlReload() rather than Mapurl_Load()
15-JUL-2006 MGD DO=INSTANCE=ACTIVE|STANDBY
DO=NET=PURGE[=NOW]|SUSPEND[=NOW]|RESUME
20-JUL-2005 MGD DO=ZERO=NOTICED to reset 'errors noticed' accounting
25-MAY-2005 MGD allow for VMS V8.2 64 byte lksb$b_valblk
NOTE=<string> to provide note to metacon rules
30-APR-2005 MGD AUTH=SKELKEY period is allowed to be zero
05-DEC-2004 MGD ControlHttpdAst() CONTROL_ZERO_PROXY
30-NOV-2004 MGD ControlZeroProxyAccounting()
31-DEC-2003 MGD ControlDelay() if multiple instances add a further, random
delay to prevent mass suicide with reduced instances and a
RESTART=NOW directive
06-JAN-2003 MGD bugfix; ControlEnqueueCommand() occasional race condition
between InstanceLockList() and InstanceNotifyNow() AST
disabling SYSLCK during list (happy birthday Naomi)
07-DEC-2002 MGD skeleton-key authentication
30-MAY-2002 MGD RESTART=QUIET restart when(-and-if) requests reach zero
21-MAY-2002 MGD ControlZeroAccounting() under instance supervisor control
04-APR-2002 MGD proxy maintenance STOP scan
29-SEP-2001 MGD significant changes in support of per-node instances
04-AUG-2001 MGD support module WATCHing
30-JUN-2001 MGD bugfix; missing log open code, strlen(.._AS),
obsolete "log=open=" and "log=reopen="
18-MAY-2001 MGD global section shared memory and DLM for control,
provide SSL private key password directive
06-APR-2001 MGD allow WATCH to note control events
13-MAR-2001 MGD add THROTTLE=...
28-DEC-2000 MGD add SSL=CA=LOAD
03-DEC-2000 MGD bugfix; CachePurge()
18-JUN-2000 MGD add node/cluster-wide, sys$enq()-driven directives (/ALL)
12-JAN-2000 MGD rework control reporting, adding OPCOM messages
20-JAN-1999 MGD proxy serving controls
15-AUG-1998 MGD decnet=purge, decnet=disconnect
16-MAR-1998 MGD restart=now
05-OCT-1997 MGD cache and logging period control
28-SEP-1997 MGD reinstated some convenience commands (AUTH, DCL, and ZERO)
01-FEB-1997 MGD HTTPd version 4 (removed much of its previous functionality)
01-OCT-1996 MGD minor changes to authorization do commands
01-JUL-1996 MGD controls for path/realm-based authorization/authentication
01-DEC-1995 MGD HTTPd version 3
12-APR-1995 MGD support logging
03-APR-1995 MGD support authorization
20-DEC-1994 MGD initial development for multi-threaded version of HTTPd
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
/* VMS related header files */
#include <descrip.h>
#include <jpidef.h>
#include <lckdef.h>
#include <lkidef.h>
#include <prvdef.h>
#include <psldef.h>
#include <secdef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application-related header files */
#include "wasd.h"
#define WASD_MODULE "CONTROL"
/******************/
/* global storage */
/******************/
BOOL ControlDoAllHttpd,
ControlExitRequested,
ControlRestartQuiet,
ControlRestartRequested;
ulong ControlPid;
char *ControlCommandPtr;
char ControlBuffer [256],
ControlNodeName [16],
ControlProcessName [16],
ControlUserName [13];
/********************/
/* external storage */
/********************/
extern BOOL CacheEnabled,
HttpdServerExecuting,
HttpdTicking,
InstanceNodeSupervisor,
OperateWithSysPrv,
ProxyServingEnabled;
extern const int64 Delta01Sec,
Delta100mSec;
extern int CliServerPort,
EfnWait,
ExitStatus,
HttpdGblSecPages,
HttpdGblSecVersion,
HttpdTickSecond,
InstanceNumber,
InstanceEnvNumber,
InstanceNodeConfig,
InstanceNodeCurrent,
NetCurrentProcessing,
OpcomMessages,
ServerPort;
extern ushort HttpdTime7[];
extern ulong GblSecPrvMask[],
SysLckMask[],
SysPrvMask[],
WorldMask[];
extern char ErrorSanityCheck[],
ErrorXvalNotValid[],
LoggingFileName[],
LoggingPeriodName[],
SoftwareID[];
extern INSTANCE_LOCK InstanceLockTable[];
extern ACCOUNTING_STRUCT *AccountingPtr;
extern HTTPD_GBLSEC *HttpdGblSecPtr;
extern PROXY_ACCOUNTING_STRUCT *ProxyAccountingPtr;
extern SYS_INFO SysInfo;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
This is the primary function called when a /DO= is made at the command line.
This function attempts to map the appropriate global section to access memory
shared with the server. It then call the appropriate function to request the
server perform the directive, either locally or if /ALL was used on the CLI
across all servers in the group (cluster). NOTE: AST delivery is disabled when
this function is called.
*/
int ControlCommand
(
char *Command,
BOOL ReportIt
)
{
int astatus, cnt, status,
LockIndex,
PeriodMinutes,
ServerCount;
char *cptr, *sptr, *zptr;
char String [512];
char PrivateKeyPasswd [64];
META_CONFIG *mcptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "ControlCommand()");
if (strsame (Command, CONTROL_HELP, -1))
{
ControlDoHelp (NULL);
return (SS$_NORMAL);
}
if (strsame (Command, CONTROL_CONFIG_CHECK, -1))
{
status = ConfigLoad (&mcptr);
cnt = ControlCheck (mcptr, "global", status);
status = ServiceConfigLoad (&mcptr);
cnt += ControlCheck (mcptr, "service", status);
status = MapUrl_ConfigLoad (&mcptr);
cnt += ControlCheck (mcptr, "map", status);
status = AuthConfigLoad (&mcptr);
cnt += ControlCheck (mcptr, "auth", status);
status = MsgConfigLoad (&mcptr);
cnt += ControlCheck (mcptr, "msg", status);
if (cnt)
FaoToStdout ("%HTTPD-F-CHECK, !UL fatal error!%s\n", cnt);
else
FaoToStdout ("%HTTPD-I-CHECK, 0 fatal errors \
(does not mean it will work as intended!!)\n");
return (SS$_NORMAL);
}
if (strsame (Command, CONTROL_AUTH_CHECK, -1))
{
status = AuthConfigLoad (&mcptr);
ControlCheck (mcptr, "auth", status);
return (SS$_NORMAL);
}
if (strsame (Command, CONTROL_GLOBAL_CHECK, -1))
{
status = ConfigLoad (&mcptr);
ControlCheck (mcptr, "global", status);
return (SS$_NORMAL);
}
if (strsame (Command, CONTROL_MAP_CHECK, -1))
{
status = MapUrl_ConfigLoad (&mcptr);
ControlCheck (mcptr, "map", status);
return (SS$_NORMAL);
}
if (strsame (Command, CONTROL_MSG_CHECK, -1))
{
status = MsgConfigLoad (&mcptr);
ControlCheck (mcptr, "msg", status);
return (SS$_NORMAL);
}
if (strsame (Command, CONTROL_SERVICE_CHECK, -1))
{
status = ServiceConfigLoad (&mcptr);
ControlCheck (mcptr, "service", status);
return (SS$_NORMAL);
}
if (CliServerPort) ServerPort = CliServerPort;
if (ServerPort < 1 || ServerPort > 65535)
{
FaoToStdout ("%HTTPD-E-PORT, IP port out-of-range\n");
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
if (strsame (Command, CONTROL_LIST, -1))
{
/****************/
/* /DO=LIST/ALL */
/****************/
if (ControlDoAllHttpd)
LockIndex = INSTANCE_CLUSTER_DO;
else
LockIndex = INSTANCE_NODE_DO;
ServerCount = InstanceLockList (LockIndex, ", ", &cptr);
FaoToStdout ("!UL server!%s; !AZ", ServerCount, ServerCount ? cptr : "?");
if (cptr) VmFree (cptr, FI_LI);
return (SS$_NORMAL);
}
/***************************/
/* now need global section */
/***************************/
HttpdGblSecMap ();
if (strsame (Command, CONTROL_AUTH_SKELKEY, sizeof(CONTROL_AUTH_SKELKEY)-1))
{
/******************************/
/* authorisation skeleton key */
/******************************/
/* if parse error then cancel any/all other nodes */
if (VMSnok (ControlAuthSkelKey (Command, true)))
strcpy (Command, "AUTH=SKELKEY=0");
#if !WATCH_MOD
/* if single node then already configured in this one's global common */
if (InstanceNodeCurrent <= 1) return (SS$_NORMAL);
#endif
/* else drop through to enqueue the command */
}
if (strsame (Command, CONTROL_STATUS, -1))
{
/***************/
/* /DO=STATUS */
/**************/
InstanceStatusCliReport (NULL);
return (SS$_NORMAL);
}
if (strsame (Command, CONTROL_SSL_PKPASSWD, -1))
{
/************************/
/* private key password */
/************************/
stdin = freopen ("SYS$INPUT", "r", stdin,
"ctx=rec", "rop=rne", "rop=tmo", "tmo=60");
if (!stdin) exit (vaxc$errno);
memset (PrivateKeyPasswd, 0, sizeof(PrivateKeyPasswd));
fprintf (stdout, "Enter private key password []: ");
fgets (PrivateKeyPasswd, sizeof(PrivateKeyPasswd), stdin);
fputc ('\n', stdout);
/* ensure it's null terminated */
PrivateKeyPasswd [sizeof(PrivateKeyPasswd)-1] = '\0';
/* remove any trailing newline */
if (PrivateKeyPasswd[0])
PrivateKeyPasswd [strlen(PrivateKeyPasswd)-1] = '\0';
/* enable SYSPRV to allow writing into the global section */
sys$setprv (1, &SysPrvMask, 0, 0);
zptr = (sptr = HttpdGblSecPtr->PkPasswd) +
sizeof(HttpdGblSecPtr->PkPasswd)-1;
for (cptr = PrivateKeyPasswd; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
sys$setprv (0, &SysPrvMask, 0, 0);
return (SS$_NORMAL);
}
/*********************/
/* need AST delivery */
/*********************/
if (ControlDoAllHttpd)
{
LockIndex = INSTANCE_CLUSTER_DO;
sptr = "ALL";
}
else
{
LockIndex = INSTANCE_NODE_DO;
sptr = "";
}
if (strsame (Command, CONTROL_NET_LIST, sizeof(CONTROL_NET_LIST)-1))
ReportIt = false;
cptr = ControlEnqueueCommand (LockIndex, Command);
if (cptr)
{
/* always report failure */
if (*cptr == '!')
FaoToStdout ("%HTTPD-E-DO!AZ, !AZ\n", sptr, cptr+1);
else
if (ReportIt)
FaoToStdout ("%HTTPD-I-DO!AZ, !AZ\n", sptr, cptr);
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Some /DO=.. help.
*/
void ControlDoHelp (REQUEST_STRUCT *rqptr)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "ControlDoHelp()");
if (rqptr)
{
ResponseHeader (rqptr, 200, "text/plain", -1, NULL, NULL);
NetWrite (rqptr, AdminEnd, ControlHelp, sizeof(ControlHelp)-1);
}
else
fputs (ControlHelp, stdout);
}
/*****************************************************************************/
/*
Provide output to the command-line check of the configuration file.
*/
int ControlCheck
(
META_CONFIG *mcptr,
char *config,
int status
)
{
char *severity;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "ControlCheck()");
if (VMSnok (status))
{
FaoToStdout ("%HTTPD-F-CHECK, !AZ config\n!AZ\n!AZ\n",
config,
mcptr->LoadReport.FileName,
mcptr->LoadReport.TextPtr);
return (1);
}
if (mcptr->LoadReport.ErrorCount)
severity = "E";
else
if (mcptr->LoadReport.WarningCount)
severity = "W";
else
if (mcptr->LoadReport.InformCount)
severity = "I";
else
severity = "S";
FaoToStdout ("%HTTPD-!AZ-CHECK, !AZ config; \
!UL informational!%s, !UL warning!%s, !UL error!%s\n!AZ\n!AZ\n",
severity, config,
mcptr->LoadReport.InformCount,
mcptr->LoadReport.WarningCount,
mcptr->LoadReport.ErrorCount,
mcptr->LoadReport.FileName,
mcptr->LoadReport.TextPtr);
return (0);
}
/*****************************************************************************/
/*
Check that the command is known and can be done via a /ALL or via the
ADMINISTRATION MENU. Enqueues a CR (concurrent read) lock on the specified
resource name, then gets the number of current locks (i.e. other processes)
currently with an interest in that lock. Then converts that lock to EX
(exclusive) and using a sys$deq() writes the command string into the lock value
block. When the exclusive lock is removed the other processes waiting on CR
locks get them, reading the value block and executing the command therein.
*/
char* ControlEnqueueCommand
(
int LockIndex,
char *Command
)
{
static char String [256];
BOOL check16,
dlm820;
int cnt, clen, plen, status,
ServerCount;
char *cptr;
char Command64 [64],
CommandRedux [64];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"ControlEnqueueCommand() !UL !&Z", LockIndex, Command);
String[0] = '\0';
if (strsame (Command, CONTROL_NET_LIST, sizeof(CONTROL_NET_LIST)-1))
{
/* append the current terminal to the command */
strcpy (CommandRedux, Command);
strcat (CommandRedux, "=");
strcat (CommandRedux, getenv("SYS$OUTPUT"));
Command = CommandRedux;
}
/* length of command (up to any second equate symbol) */
for (cptr = Command; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
while (*cptr && *cptr != '=') cptr++;
clen = cptr - Command;
/* now the length of any parameter */
if (*cptr) cptr++;
while (*cptr) cptr++;
plen = cptr - Command - clen;
check16 = false;
if (!(strsame (Command, CONTROL_ADHOC, sizeof(CONTROL_ADHOC)-1) ||
strsame (Command, CONTROL_ALIGN_FAULT,
sizeof(CONTROL_ALIGN_FAULT)-1) ||
strsame (Command, CONTROL_AUTH_LOAD1, -1) ||
strsame (Command, CONTROL_AUTH_LOAD2, -1) ||
strsame (Command, CONTROL_AUTH_PURGE, -1) ||
(check16 = strsame (Command, CONTROL_AUTH_SKELKEY, clen)) ||
strsame (Command, CONTROL_CACHE_ON, -1) ||
strsame (Command, CONTROL_CACHE_OFF, -1) ||
strsame (Command, CONTROL_CACHE_PURGE, -1) ||
strsame (Command, CONTROL_DCL_PROCTOR_APPLY, -1) ||
strsame (Command, CONTROL_DCL_PROCTOR_LOAD, -1) ||
(check16 = strsame (Command, CONTROL_DCL_DELETE, clen)) ||
(check16 = strsame (Command, CONTROL_DCL_PURGE, clen)) ||
strsame (Command, CONTROL_DECNET_PURGE, -1) ||
strsame (Command, CONTROL_DECNET_DISCONNECT, -1) ||
strsame (Command, CONTROL_EXIT, -1) ||
strsame (Command, CONTROL_EXIT_NOW, -1) ||
strsame (Command, CONTROL_HTTP2_PURGE_ALL, -1) ||
strsame (Command, CONTROL_HTTP2_PURGE,
sizeof(CONTROL_HTTP2_PURGE)-1) ||
strsame (Command, CONTROL_INSTANCE, sizeof(CONTROL_INSTANCE)-1) ||
strsame (Command, CONTROL_LIST, -1) ||
strsame (Command, CONTROL_LOG_OPEN, -1) ||
strsame (Command, CONTROL_LOG_CLOSE, -1) ||
strsame (Command, CONTROL_LOG_FLUSH, -1) ||
strsame (Command, CONTROL_LOG_REOPEN, -1) ||
strsame (Command, CONTROL_MAP_LOAD1, -1) ||
strsame (Command, CONTROL_MAP_LOAD2, -1) ||
(check16 = strsame (Command, CONTROL_NET_LIST,
sizeof(CONTROL_NET_LIST)-1)) ||
(check16 = strsame (Command, CONTROL_NET_PURGE_URI,
sizeof(CONTROL_NET_PURGE_URI)-1)) ||
strsame (Command, CONTROL_NET_PURGE_ALL, -1) ||
strsame (Command, CONTROL_NET_PURGE_HTTP1, -1) ||
strsame (Command, CONTROL_NET_PURGE_HTTP2, -1) ||
strsame (Command, CONTROL_NET_PURGE, sizeof(CONTROL_NET_PURGE)-1) ||
strsame (Command, CONTROL_NET_RESUME, -1) ||
strsame (Command, CONTROL_NET_SUSPEND, -1) ||
strsame (Command, CONTROL_NET_SUSPEND_NOW, -1) ||
strsame (Command, CONTROL_NET_NOSUSPEND, -1) ||
(check16 = strsame (Command, CONTROL_NOTE_META,
sizeof(CONTROL_NOTE_META)-1)) ||
strsame (Command, CONTROL_PROXY_ON, -1) ||
strsame (Command, CONTROL_PROXY_OFF, -1) ||
strsame (Command, CONTROL_PROXY_PURGE_HOST, -1) ||
strsame (Command, CONTROL_PROXY_STATISTICS, -1) ||
/* must be before =<integer> */
strsame (Command, CONTROL_REQUEST_RUNDOWN_ALL, -1) ||
(check16 = strsame (Command, CONTROL_REQUEST_RUNDOWN,
sizeof(CONTROL_REQUEST_RUNDOWN)-1)) ||
strsame (Command, CONTROL_RESTART, -1) ||
strsame (Command, CONTROL_RESTART_NOW, -1) ||
strsame (Command, CONTROL_RESTART_QUIET, -1) ||
(check16 = strsame (Command, CONTROL_NOTE_SERVER,
sizeof(CONTROL_NOTE_SERVER)-1)) ||
(check16 = strsame (Command, CONTROL_SESSION_TICKET_KEY, clen)) ||
strsame (Command, CONTROL_SSL_CA_LOAD, -1) ||
strsame (Command, CONTROL_SSL_CERT_LOAD, -1) ||
strsame (Command, CONTROL_STATUS_NOW, -1) ||
strsame (Command, CONTROL_STATUS_PURGE, -1) ||
strsame (Command, CONTROL_STATUS_RESET, -1) ||
(check16 = strsame (Command, CONTROL_THROTTLE_RELEASE, clen)) ||
(check16 = strsame (Command, CONTROL_THROTTLE_TERMINATE, clen)) ||
strsame (Command, CONTROL_THROTTLE_ZERO, -1) ||
(check16 = strsame (Command, CONTROL_WEBSOCKET_DISCONNECT, clen)) ||
strsame (Command, CONTROL_ZERO_NOTICED, -1) ||
strsame (Command, CONTROL_ZERO_PROXY, -1) ||
strsame (Command, CONTROL_ZERO_STATUS, -1) ||
strsame (Command, CONTROL_ZERO, -1)))
{
if (strsame (Command, CONTROL_LOG_FORMAT_AS,
strlen(CONTROL_LOG_FORMAT_AS)) ||
strsame (Command, CONTROL_LOG_OPEN_AS,
strlen(CONTROL_LOG_OPEN_AS)) ||
strsame (Command, CONTROL_LOG_PERIOD_AS,
strlen(CONTROL_LOG_PERIOD_AS)) ||
strsame (Command, CONTROL_LOG_REOPEN_AS,
strlen(CONTROL_LOG_REOPEN_AS)))
strcpy (String, "!this directive is OBSOLETE");
else
strcpy (String, "!directive not understood");
}
if (!String[0] && ControlDoAllHttpd)
if (strsame (Command, CONTROL_SSL_PKPASSWD, -1))
strcpy (String, "!cannot do this via /ALL");
if (!String[0] && check16 &&
SysInfo.LockValueBlockSize == LOCK_VALUE_BLOCK_16)
{
/* size of command constraints (basically free-form directives) */
if ((strsame (Command, CONTROL_NOTE_META,
strlen(CONTROL_NOTE_META)) ||
strsame (Command, CONTROL_NOTE_SERVER,
strlen(CONTROL_NOTE_SERVER))) &&
strlen(Command) > 15)
dlm820 = true;
else
if (plen)
dlm820 = true;
else
dlm820 = false;
if (dlm820) strcpy (String, "!requires VMS V8.2 DLM (clusterwide)");
}
if (!String[0])
{
/* ensure we have 64 bytes for the (largest) lock value block */
memset (Command64, 0, sizeof(Command64));
strncpy (Command64, Command, sizeof(Command64)-1);
if (strsame (Command, CONTROL_SESSION_TICKET_KEY, clen))
{
/* command-line generation of new ticket key data */
cptr = SesolaSessionTicketNewKey ();
/* 48 byte binary key follows the null-terminated string command */
memcpy (Command64 + sizeof(CONTROL_SESSION_TICKET_KEY), cptr, 48);
/* this directive can only be applied cluster-wide */
LockIndex = INSTANCE_CLUSTER_DO;
}
ServerCount = InstanceLockList (LockIndex, ", ", &cptr);
status = InstanceNotifyWait (LockIndex, Command64,
CONTROL_WAIT_SECONDS);
if (VMSok (status))
FaoToBuffer (String, sizeof(String), 0,
"\"!AZ\"; !UL instance!%s notified; !AZ",
Command64, ServerCount, ServerCount ? cptr : "?");
else
if (status == SS$_NOTQUEUED)
FaoToBuffer (String, sizeof(String), 0,
"!!command (en)queueing did not complete within !UL seconds",
CONTROL_WAIT_SECONDS);
else
if (status == SS$_TIMEOUT)
FaoToBuffer (String, sizeof(String), 0,
"!!command (en)queueing timed-out after !UL seconds",
CONTROL_WAIT_SECONDS);
else
FaoToBuffer (String, sizeof(String), 0,
"!!failed with status %X!8XL", status);
if (cptr) VmFree (cptr, FI_LI);
}
// if (strsame (Command, CONTROL_NET_LIST, sizeof(CONTROL_NET_LIST)-1))
// sleep (1);
return (String);
}
/*****************************************************************************/
/*
The EX (exclusive) lock enqueued by the controlling process has been dequeued
allowing this AST to be delivered. The control directive is now in the lock
value block. Do what it is requesting. This AST is required to allow
AdminControl() to use it as part of an executing server. The CONTROL_BUFFER
value indicates the server should examine 'ControlBuffer' in the global section
shared memory for a this-system-only command.
*/
ControlHttpdAst (struct lksb *lksbptr)
{
BOOL WithExtremePrejudice;
int clen, status,
ConnectNumber = 0,
StartupMax;
char *cptr, *sptr, *zptr;
char NetListTerm [64] = "",
RemoteUser [64] = "",
RequestUri [64] = "",
ScriptName [64] = "",
ScriptFileName [64] = "",
UserName [64] = "";
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"ControlHttpdAst() !&F !UL !&Z",
&ControlHttpdAst, lksbptr, (char*)lksbptr->lksb$b_valblk);
/* get the lock value block written by the dequeued EX mode lock */
cptr = ControlCommandPtr = (char*)lksbptr->lksb$b_valblk;
clen = strlen(cptr);
/* special case - this message is not to be reported */
if (isalnum(*cptr)) ControlMessage (cptr);
if (WATCH_CAT && Watch.Category)
{
if (isalnum(*cptr))
WatchThis (WATCHALL, WATCH_INTERNAL, "HTTPD/DO=\'!AZ\'", cptr);
else
if (WATCH_CATEGORY (WATCH_INTERNAL))
WatchThis (WATCHALL, WATCH_INTERNAL, "DO \'!AZ\' !64&H", cptr, cptr);
}
if (strsame (cptr, CONTROL_ADHOC, sizeof(CONTROL_ADHOC)-1))
{
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=') cptr++;
ControlAdhoc (cptr);
}
else
if (strsame (cptr, CONTROL_ALIGN_FAULT, sizeof(CONTROL_ALIGN_FAULT)-1))
{
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=') cptr++;
HttpdAlignFault (cptr);
}
else
if (strsame (cptr, CONTROL_AUTH_SKELKEY, sizeof(CONTROL_AUTH_SKELKEY)-1))
ControlAuthSkelKey (cptr, false);
else
if (strsame (cptr, CONTROL_AUTH_LOAD1, clen) ||
strsame (cptr, CONTROL_AUTH_LOAD2, clen))
AuthConfigInit ();
else
if (strsame (cptr, CONTROL_AUTH_PURGE, clen))
AuthCachePurge (true);
else
if (strsame (cptr, CONTROL_CACHE_ON, clen))
CacheEnabled = true;
else
if (strsame (cptr, CONTROL_CACHE_OFF, clen))
CacheEnabled = false;
else
if (strsame (cptr, CONTROL_CACHE_PURGE, clen))
CachePurge (false, NULL, NULL);
else
if (strsame (cptr, CONTROL_DCL_PROCTOR_LOAD, clen))
ConfigControlProctorLoad ();
else
if (strsame (cptr, CONTROL_DCL_PROCTOR_APPLY, clen))
DclScriptProctor ();
else
if ((WithExtremePrejudice =
strsame (cptr, CONTROL_DCL_DELETE, sizeof(CONTROL_DCL_DELETE)-1)) ||
strsame (cptr, CONTROL_DCL_PURGE, sizeof(CONTROL_DCL_PURGE)-1))
{
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=') cptr++;
if (isdigit(*cptr)) ConnectNumber = atoi(cptr);
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=')
{
cptr++;
if (strsame (cptr, "FILE=", 5))
strzcpy (ScriptFileName, cptr+5, sizeof(ScriptFileName));
else
if (strsame (cptr, "SCRIPT=", 7))
strzcpy (ScriptName, cptr+7, sizeof(ScriptName));
else
if (strsame (cptr, "USER=", 5))
strzcpy (UserName, cptr+5, sizeof(UserName));
else
{
ErrorNoticed (NULL, 0, "unknown control directive", FI_LI);
return;
}
}
DclControlPurgeScriptProcesses (WithExtremePrejudice,
UserName, ScriptName, ScriptFileName);
}
else
if (strsame (cptr, CONTROL_DECNET_DISCONNECT, clen))
DECnetControlDisconnect (false);
else
if (strsame (cptr, CONTROL_DECNET_PURGE, clen))
DECnetControlDisconnect (true);
else
if (strsame (cptr, CONTROL_EXIT, clen))
{
/* stop the server from receiving incoming requests */
NetShutdownServerSocket ();
if (NetCurrentProcessing)
{
/* this will now be handled by RequestEnd() */
ControlExitRequested = true;
}
else
ControlDelay (CONTROL_DELAY_EXIT);
}
else
if (strsame (cptr, CONTROL_EXIT_NOW, clen))
ControlDelay (CONTROL_DELAY_EXIT);
else
if (strsame (cptr, CONTROL_HTTP2_PURGE_ALL,
sizeof(CONTROL_HTTP2_PURGE_ALL)-1))
{
/* delay by one second in case it's being initiated over HTTP/2 */
status = sys$setimr (0, &Delta01Sec, Http2NetControl, -9, 0);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
}
else
if (strsame (cptr, CONTROL_HTTP2_PURGE, sizeof(CONTROL_HTTP2_PURGE)-1))
{
cptr += sizeof(CONTROL_HTTP2_PURGE)-1;
if (*cptr == '=') cptr++;
ConnectNumber = atoi(cptr);
Http2NetControl (ConnectNumber);
}
else
if (strsame (cptr, CONTROL_INSTANCE_ACTIVE, clen))
NetActive (false);
else
if (strsame (cptr, CONTROL_INSTANCE_PASSIVE, clen))
NetPassive ();
else
/* MUST be the final "INSTANCE=" */
if (strsame (cptr, CONTROL_INSTANCE, sizeof(CONTROL_INSTANCE)-1))
{
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=') cptr++;
if (strsame (cptr, "max", -1))
StartupMax = 0;
else
if (strsame (cptr, "cpu", -1))
StartupMax = INSTANCE_PER_CPU;
else
StartupMax = atoi(cptr);
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
HttpdGblSecPtr->InstanceStartupMax = StartupMax;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
else
if (strsame (cptr, CONTROL_LOG_OPEN, clen))
Logging (NULL, LOGGING_OPEN);
else
if (strsame (cptr, CONTROL_LOG_REOPEN, clen))
{
/* close then open */
if (VMSok (Logging (NULL, LOGGING_CLOSE)))
Logging (NULL, LOGGING_OPEN);
}
else
if (strsame (cptr, CONTROL_LOG_CLOSE, clen))
Logging (NULL, LOGGING_CLOSE);
else
if (strsame (cptr, CONTROL_LOG_FLUSH, clen))
Logging (NULL, LOGGING_FLUSH);
else
if (strsame (cptr, CONTROL_MAP_LOAD1, clen) ||
strsame (cptr, CONTROL_MAP_LOAD2, clen))
MapUrl_ControlReload ();
else
if (strsame (cptr, CONTROL_NET_LIST, sizeof(CONTROL_NET_LIST)-1))
{
static char buf [64];
cptr += sizeof(CONTROL_NET_LIST)-1;
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=') cptr++;
strcpy (buf, cptr);
/* give the /DO=NET=LIST a chance to get back to the prompt */
status = sys$setimr (0, &Delta100mSec, NetListFor, buf, 0);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
}
else
if (strsame (cptr, CONTROL_NET_PURGE_ALL, sizeof(CONTROL_NET_PURGE_ALL)-1))
{
/* do not pull rugs from under */
status = sys$setimr (0, &Delta100mSec, NetControl, -9, 0);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
}
else
if (strsame (cptr, CONTROL_NET_PURGE_HTTP1, sizeof(CONTROL_NET_PURGE_HTTP1)-1))
{
/* do not pull rugs from under */
status = sys$setimr (0, &Delta100mSec, NetControl, -1, 0);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
}
else
if (strsame (cptr, CONTROL_NET_PURGE_HTTP2, sizeof(CONTROL_NET_PURGE_HTTP2)-1))
{
/* do not pull rugs from under */
status = sys$setimr (0, &Delta100mSec, NetControl, -2, 0);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
}
else
if (strsame (cptr, CONTROL_NET_PURGE_URI, sizeof(CONTROL_NET_PURGE_URI)-1))
{
cptr += sizeof(CONTROL_NET_PURGE_URI)-1;
if (*cptr == '=') cptr++;
strzcpy (RequestUri, cptr, sizeof(RequestUri));
NetControl (0, RequestUri);
}
else
if (strsame (cptr, CONTROL_NET_PURGE, sizeof(CONTROL_NET_PURGE)-1))
{
cptr += sizeof(CONTROL_NET_PURGE)-1;
if (*cptr == '=') cptr++;
ConnectNumber = atoi(cptr);
NetControl (ConnectNumber, NULL);
}
else
if (strsame (cptr, CONTROL_NET_RESUME, clen) ||
strsame (cptr, CONTROL_NET_NOSUSPEND, clen))
NetResume ();
else
if (strsame (cptr, CONTROL_NET_SUSPEND, clen))
NetSuspend (false);
else
if (strsame (cptr, CONTROL_NET_SUSPEND_NOW, clen))
NetSuspend (true);
else
if (strsame (cptr, CONTROL_NOTE_META, sizeof(CONTROL_NOTE_META)-1))
MetaConNoteThis (cptr+sizeof(CONTROL_NOTE_META)-1);
else
if (strsame (cptr, CONTROL_NOTE_SERVER, sizeof(CONTROL_NOTE_SERVER)-1))
HttpdNoteThis (cptr+sizeof(CONTROL_NOTE_SERVER)-1);
else
if (strsame (cptr, CONTROL_PROXY_ON, clen))
{
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
ProxyServingEnabled = ProxyAccountingPtr->ServingEnabled = true;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
else
if (strsame (cptr, CONTROL_PROXY_OFF, clen))
{
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
ProxyServingEnabled = ProxyAccountingPtr->ServingEnabled = false;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
else
if (strsame (cptr, CONTROL_PROXY_PURGE_HOST, clen))
TcpIpHostCacheSupervisor ((uint)-1);
else
/* must be before =<integer> */
if (strsame (cptr, CONTROL_REQUEST_RUNDOWN_ALL, clen))
RequestControlRunDown (-1);
else
if (strsame (cptr, CONTROL_REQUEST_RUNDOWN,
sizeof(CONTROL_REQUEST_RUNDOWN)-1))
{
cptr += sizeof(CONTROL_REQUEST_RUNDOWN)-1;
if (*cptr == '=') cptr++;
ConnectNumber = atoi(cptr);
if (ConnectNumber) RequestControlRunDown (ConnectNumber);
}
else
if (strsame (cptr, CONTROL_RESTART, clen))
ControlDelay (CONTROL_DELAY_RESTART);
else
if (strsame (cptr, CONTROL_RESTART_NOW, clen))
ControlDelay (CONTROL_DELAY_RESTART_NOW);
else
if (strsame (cptr, CONTROL_RESTART_QUIET, clen))
ControlDelay (CONTROL_DELAY_RESTART_QUIET);
else
if (strsame (cptr, CONTROL_SSL_CA_LOAD, clen))
SesolaControlReloadCA ();
else
if (strsame (cptr, CONTROL_SSL_CERT_LOAD, clen))
SesolaControlReloadCerts (NULL);
else
if (strsame (cptr, CONTROL_SESSION_TICKET_KEY, clen))
SesolaSessionTicketUseKey (cptr);
else
if (strsame (cptr, CONTROL_STATUS_NOW, clen))
InstanceStatusNow ();
else
if (strsame (cptr, CONTROL_STATUS_PURGE, clen))
InstanceStatusPurge ();
else
if (strsame (cptr, CONTROL_STATUS_RESET, clen))
InstanceStatusReset ();
else
if (WithExtremePrejudice =
strsame (cptr, CONTROL_THROTTLE_TERMINATE,
sizeof(CONTROL_THROTTLE_TERMINATE)-1) ||
strsame (cptr, CONTROL_THROTTLE_RELEASE,
sizeof(CONTROL_THROTTLE_RELEASE)-1))
{
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=') cptr++;
if (isdigit(*cptr)) ConnectNumber = atoi(cptr);
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=')
{
cptr++;
if (strsame (cptr, "REMOTE=", 7))
strzcpy (RemoteUser, cptr+7, sizeof(RemoteUser));
else
if (strsame (cptr, "SCRIPT=", 7))
strzcpy (ScriptName, cptr+7, sizeof(ScriptName));
else
if (strsame (cptr, "USER=", 5))
/* backward compatible with REMOTE=<name> */
strzcpy (RemoteUser, cptr+5, sizeof(RemoteUser));
else
{
ErrorNoticed (NULL, 0, "unknown control directive", FI_LI);
return;
}
}
ThrottleControl (WithExtremePrejudice, ConnectNumber,
RemoteUser, ScriptName);
}
else
if (strsame (cptr, CONTROL_WEBSOCKET_DISCONNECT,
sizeof(CONTROL_WEBSOCKET_DISCONNECT)-1))
{
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=') cptr++;
if (isdigit(*cptr)) ConnectNumber = atoi(cptr);
while (*cptr && *cptr != '=') cptr++;
if (*cptr == '=')
{
cptr++;
if (strsame (cptr, "SCRIPT=", 7))
strzcpy (ScriptName, cptr+7, sizeof(ScriptName));
else
if (strsame (cptr, "USER=", 5))
strzcpy (UserName, cptr+5, sizeof(UserName));
else
{
ErrorNoticed (NULL, 0, "unknown control directive", FI_LI);
return;
}
}
WebSockControl (ConnectNumber, ScriptName, UserName);
}
else
if (strsame (cptr, CONTROL_THROTTLE_ZERO, clen))
ThrottleZero ();
else
if (strsame (cptr, CONTROL_ZERO, clen))
ControlZeroAccounting ();
else
if (strsame (cptr, CONTROL_ZERO_NOTICED, clen))
ControlZeroNoticed ();
else
if (strsame (cptr, CONTROL_ZERO_PROXY, clen))
ControlZeroProxyAccounting ();
else
if (strsame (cptr, CONTROL_ZERO_STATUS, clen))
ControlZeroStatus ();
else
ErrorNoticed (NULL, 0, "unknown control directive", FI_LI);
}
/*****************************************************************************/
/*
Using the supplied PID fill out 'ControlPid', 'ControlProcessName, abnd
'ControlUserName' with the appropriate information. If 'Pid' is zero then it
will be the datils of the current process.
*/
ControlAccount (ulong Pid)
{
static BOOL NoWorldPriv;
static ulong GetJpiControlFlags = JPI$M_IGNORE_TARGET_STATUS;
static struct
{
ushort buf_len;
ushort item;
uchar *buf_addr;
ushort *short_ret_len;
}
JpiItems [] =
{
{ sizeof(GetJpiControlFlags), JPI$_GETJPI_CONTROL_FLAGS,
&GetJpiControlFlags, 0 },
{ sizeof(ControlPid), JPI$_PID, &ControlPid, 0 },
{ sizeof(ControlNodeName), JPI$_NODENAME, &ControlNodeName, 0 },
{ sizeof(ControlProcessName), JPI$_PRCNAM, &ControlProcessName, 0 },
{ sizeof(ControlUserName), JPI$_USERNAME, &ControlUserName, 0 },
{ 0,0,0,0 }
};
int status;
char *cptr;
IO_SB IOsb;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "ControlAccount() !8XL", Pid);
/* use WORLD to allow access to other processes */
status = sys$setprv (1, &WorldMask, 0, 0);
if (VMSnok (status) || status == SS$_NOTALLPRIV)
{
if (!NoWorldPriv)
{
NoWorldPriv = true;
fprintf (stdout,
"%%HTTPD-W-CONTROL, installed without WORLD privilege\n");
}
}
if (!NoWorldPriv && Pid)
{
status = sys$getjpiw (EfnWait, &Pid, 0, &JpiItems, &IOsb, 0, 0);
if (VMSok (status)) status = IOsb.Status;
}
else
status = SS$_NOPRIV;
if (VMSok (status))
{
ControlNodeName[15] = '\0';
for (cptr = ControlNodeName; *cptr && *cptr != ' '; cptr++);
*cptr = '\0';
(cptr = ControlProcessName)[15] = '\0';
cptr--;
while (cptr > ControlProcessName && *cptr == ' ') cptr--;
*cptr = '\0';
ControlUserName[12] = '\0';
for (cptr = ControlUserName; *cptr && *cptr != ' '; cptr++);
*cptr = '\0';
}
else
{
strcpy (ControlNodeName, "?");
strcpy (ControlProcessName, "?");
strcpy (ControlUserName, "?");
}
sys$setprv (0, &WorldMask, 0, 0);
}
/*****************************************************************************/
/*
Report a control request/response, to the process log (SYS$OUTPUT) and
optionally as OPCOM messages.
*/
ControlMessage (char *Message)
{
static ulong LkiValBlkLen,
Lki_XVALNOTVALID;
static char LkiValBlk [LOCK_VALUE_BLOCK_64];
static VMS_ITEM_LIST3 LkiItems [] =
{
/* careful, values are dynamically assigned in code below! */
{ 0, 0, 0, 0 }, /* reserved for LKI$_[X]VALBLK item */
{ 0, 0, 0, 0 }, /* reserved for LKI$_XVALNOTVALID item */
{0,0,0,0}
};
int status;
char *cptr, *sptr, *zptr;
char buf [64];
IO_SB IOsb;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"ControlMessage() !&Z", Message);
if (!isalnum(Message[0])) return;
if (SysInfo.LockValueBlockSize == LOCK_VALUE_BLOCK_64)
{
LkiItems[0].buf_len = LOCK_VALUE_BLOCK_64;
LkiItems[0].buf_addr = &LkiValBlk;
LkiItems[0].item = LKI$_XVALBLK;
LkiItems[0].ret_len = &LkiValBlkLen;
LkiItems[1].buf_len = sizeof(Lki_XVALNOTVALID);
LkiItems[1].buf_addr = &Lki_XVALNOTVALID;
LkiItems[1].item = LKI$_XVALNOTVALID;
}
else
{
LkiItems[0].buf_len = LOCK_VALUE_BLOCK_16;
LkiItems[0].buf_addr = &LkiValBlk;
LkiItems[0].item = LKI$_VALBLK;
LkiItems[0].ret_len = &LkiValBlkLen;
/* in this case this terminates the item list */
LkiItems[1].buf_len = 0;
LkiItems[1].buf_addr = 0;
LkiItems[1].item = 0;
Lki_XVALNOTVALID = 0;
}
memset (LkiValBlk, 0, sizeof(LkiValBlk));
sys$setprv (1, &SysLckMask, 0, 0);
status = sys$getlkiw (EfnWait,
&InstanceLockTable[INSTANCE_CLUSTER_NOTIFY].Lksb.lksb$l_lkid,
&LkiItems, &IOsb, 0, 0, 0);
sys$setprv (0, &SysLckMask, 0, 0);
if (VMSok (status)) status = IOsb.Status;
if (VMSnok (status)) ErrorNoticed (NULL, status, NULL, FI_LI);
if (Lki_XVALNOTVALID)
{
/* hmmm, change in cluster composition? whatever! go back to 16 bytes */
SysInfo.LockValueBlockSize = LOCK_VALUE_BLOCK_16;
ErrorNoticed (NULL, SS$_XVALNOTVALID, ErrorXvalNotValid, FI_LI);
}
if (LkiValBlkLen >= sizeof(LkiValBlk))
LkiValBlk[sizeof(LkiValBlk)-1] = '\0';
else
LkiValBlk[LkiValBlkLen] = '\0';
if (sscanf (LkiValBlk, "%x", &ControlPid) < 1) ControlPid = 0;
ControlAccount (ControlPid);
zptr = (sptr = buf) + sizeof(buf)-1;
if (*(cptr = Message) == '!') cptr++;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
/* mask the sensitive information */
if (strsame (buf, CONTROL_AUTH_SKELKEY, sizeof(CONTROL_AUTH_SKELKEY)-1))
if (*(buf + sizeof(CONTROL_AUTH_SKELKEY)-1) != '0')
*(USHORTPTR)(buf + sizeof(CONTROL_AUTH_SKELKEY)-1) = '*\0';
if (Message[0] == '!') cptr = "E"; else cptr = "I";
if (ControlPid)
FaoToStdout ("%HTTPD-!AZ-CONTROL, \
!20%D, !8XL !AZ !AZ \"!AZ\", \'!AZ\'\n",
cptr, 0,
ControlPid, ControlNodeName, ControlUserName,
ControlProcessName, buf);
else
FaoToStdout ("%HTTPD-!AZ-CONTROL, !20%D, \'!AZ\'\n",
cptr, 0, buf);
if (OpcomMessages & OPCOM_CONTROL)
{
if (ControlPid)
FaoToOpcom ("%HTTPD-!AZ-CONTROL, !8XL !AZ !AZ \"!AZ\", \'!AZ\'",
cptr, ControlPid, ControlNodeName,
ControlUserName, ControlProcessName, buf);
else
FaoToOpcom ("%HTTPD-!AZ-CONTROL, \'!AZ\'", cptr, buf);
}
if (WATCH_CAT && Watch.Category)
{
WatchThis (WATCHALL, WATCH_INTERNAL, "HTTPD/DO=");
WatchDataFormatted (
"%HTTPD-!AZ-CONTROL, !20%D, !8XL !AZ !AZ \"!AZ\", \'!AZ\'\n",
cptr, 0, ControlPid, ControlNodeName,
ControlUserName, ControlProcessName, buf);
}
}
/*****************************************************************************/
/*
AUTH=SKELKEY=_<name>:<psswd>[:<hours>]
This parses the above string directly into the global section. It is used in
two ways. To parse and validate the elements when coming from the
command-line. If not valid a report is provided to <stdout> and the relevant
storage in the global section is reset and an error status returned. The
calling code checks the return status and when success and a cluster uses the
DLM to distribute to other nodes. When not from the command-line (i.e. is
from the lock value block) no <stdout> report is provided.
*/
int ControlAuthSkelKey
(
char *Command,
BOOL FromCli
)
{
int status,
PeriodMinutes;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "ControlAuthSkelKey() !AZ",
Command);
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
cptr = Command + sizeof(CONTROL_AUTH_SKELKEY)-1;
if (!*cptr || *cptr == '0')
{
PeriodMinutes = 0;
status = SS$_NORMAL;
}
else
{
status = SS$_ABORT;
zptr = (sptr = HttpdGblSecPtr->AuthSkelKeyUserName) +
sizeof(HttpdGblSecPtr->AuthSkelKeyUserName)-1;
while (*cptr && *cptr != ':' && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
if (*cptr == ':')
{
cptr++;
zptr = (sptr = HttpdGblSecPtr->AuthSkelKeyPassword) +
sizeof(HttpdGblSecPtr->AuthSkelKeyPassword)-1;
while (*cptr && *cptr != ':' && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
if (FromCli)
{
if (HttpdGblSecPtr->AuthSkelKeyUserName[0] != '_')
FaoToStdout ("%HTTPD-E-DO, _<username>:<password>[:<minutes>]\n");
else
if (strlen(HttpdGblSecPtr->AuthSkelKeyUserName) < 7)
FaoToStdout ("%HTTPD-E-DO, username too short\n");
else
if (strsame (HttpdGblSecPtr->AuthSkelKeyUserName, "_SKELE", 6))
FaoToStdout ("%HTTPD-E-DO, not a good choice!!\n");
else
if (sptr - HttpdGblSecPtr->AuthSkelKeyPassword < 8)
FaoToStdout ("%HTTPD-E-DO, password too short\n");
else
if (strsame (HttpdGblSecPtr->AuthSkelKeyUserName,
HttpdGblSecPtr->AuthSkelKeyPassword, -1) ||
strsame (HttpdGblSecPtr->AuthSkelKeyUserName+1,
HttpdGblSecPtr->AuthSkelKeyPassword, -1))
FaoToStdout ("%HTTPD-E-DO, not a good choice!!\n");
else
if (*cptr == ':')
{
PeriodMinutes = atoi(cptr+1);
/* less than a minute or greater than a week */
if (PeriodMinutes < 0 || PeriodMinutes > 10080)
FaoToStdout ("%HTTPD-E-DO, invalid period\n");
else
status = SS$_NORMAL;
}
else
{
PeriodMinutes = 60;
status = SS$_NORMAL;
}
}
else
if (*cptr == ':')
{
PeriodMinutes = atoi(cptr+1);
status = SS$_NORMAL;
}
else
{
PeriodMinutes = 60;
status = SS$_NORMAL;
}
}
else
if (FromCli)
FaoToStdout ("%HTTPD-E-DO, _<username>:<password>[:<minutes>]\n");
}
if (VMSok (status) && PeriodMinutes)
{
if (PeriodMinutes > 10080) PeriodMinutes = 10080;
HttpdGblSecPtr->AuthSkelKeyHttpdTickSecond = HttpdTickSecond +
PeriodMinutes * 60;
}
else
{
memset (HttpdGblSecPtr->AuthSkelKeyUserName, 0,
sizeof(HttpdGblSecPtr->AuthSkelKeyUserName));
memset (HttpdGblSecPtr->AuthSkelKeyPassword, 0,
sizeof(HttpdGblSecPtr->AuthSkelKeyPassword));
HttpdGblSecPtr->AuthSkelKeyHttpdTickSecond = 0;
}
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
return (status);
}
/*****************************************************************************/
/*
Exits or restarts the server after a short delay (0.5S to 0.9S for one
instance, 2.5S to 2.9S for second instance, 4.5S to 4.9S for third instance, up
to 14.5S to 14.9S for an eigth instance). This delay is introduced to give a
controlling request (e.g. via the Admin Menu) a chance to complete processing
(e.g. deliver success message) before the action is taken, to minmise
simultaneous actions in the DLM, and an additional delay to stagger multiple
instances, preventing mass suicide when RESTART=NOW and reducing the number of
instances.
*/
ControlDelay (int Action)
{
int number, status;
int64 DelayDelta;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "ControlDelay() !UL", Action);
if (!(Action & CONTROL_DELAY_DO))
{
if (number = InstanceNumber) number--;
DelayDelta = -5000000; /* 500mS */
DelayDelta += -20000000 * (number * 2); /* 1000mS * (0..14) */
DelayDelta += -10000 * (HttpdTime7[6] % 5); /* 100mS * (0..4) */
status = sys$setimr (0, &DelayDelta, &ControlDelay,
Action | CONTROL_DELAY_DO, 0);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
return;
}
switch (Action & ~CONTROL_DELAY_DO)
{
case CONTROL_DELAY_EXIT :
ExitStatus = SS$_NORMAL;
HttpdExit (&ExitStatus);
/* record server event */
GraphActivityEvent (ACTIVITY_DELPRC);
sys$delprc (0, 0);
case CONTROL_DELAY_RESTART :
ControlRestartRequested = true;
/* start the server supervisor in case it's not running */
if (!HttpdTicking) HttpdTick (0);
/* this will now be handled by InstanceSupervisor() */
return;
case CONTROL_DELAY_RESTART_QUIET :
ControlRestartQuiet = true;
/* start the server supervisor in case it's not running */
if (!HttpdTicking) HttpdTick (0);
/* this will now be handled by InstanceSupervisor() */
return;
case CONTROL_DELAY_RESTART_NOW :
exit (SS$_NORMAL);
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
}
/*****************************************************************************/
/*
Zero server accounting structure and service counters.
These are both process-local and node/instance-global.
Each gets reset under differing circumstances.
Those accumulating "current" values need to be buffered and then restored.
*/
ControlZeroAccounting ()
{
int idx, indsize, istcnt, istsize,
StartupCount,
ZeroedCount;
ulong CurrentDclScriptProcess [INSTANCE_MAX+1],
CurrentDclScriptCgiPlus [INSTANCE_MAX+1],
CurrentDclScriptRTE [INSTANCE_MAX+1],
CurrentDECnetCGI [INSTANCE_MAX+1],
CurrentDECnetOSU [INSTANCE_MAX+1],
CurrentDECnetTasks [INSTANCE_MAX+1],
CurrentPersistentHttp1 [INSTANCE_MAX+1],
CurrentThrottleProcessing [INSTANCE_MAX+1],
CurrentThrottleQueued [INSTANCE_MAX+1],
CurrentWebSockets [INSTANCE_MAX+1];
/* total (HTTP/1+2) [0], HTTP/1 [1], HTTP/2 [2] */
ulong CurrentConnected [HTTPN],
CurrentProcessing [HTTPN];
ulong CurrentInstanceConnected [HTTPN][INSTANCE_MAX+1],
CurrentInstanceProcessing [HTTPN][INSTANCE_MAX+1];
ACCOUNTING_STRUCT *accptr;
INSTANCE_NODE_DATA *indptr;
INSTANCE_STATUS *istptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"ControlZeroAccounting() !UL !&B",
InstanceNodeConfig, InstanceNodeSupervisor);
/* these two get done on a per-process basis regardless */
ThrottleZero ();
NetServiceZeroAccounting ();
/* in a multi-instance config, shared data only by the supervisor */
if (InstanceNodeConfig > 1 && !InstanceNodeSupervisor) return;
accptr = AccountingPtr;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
/**********/
/* buffer */
/**********/
StartupCount = accptr->StartupCount;
ZeroedCount = accptr->ZeroedCount;
CurrentConnected[HTTP12] = accptr->CurrentConnected[HTTP12];
CurrentConnected[HTTP1] = accptr->CurrentConnected[HTTP1];
CurrentConnected[HTTP2] = accptr->CurrentConnected[HTTP2];
CurrentProcessing[HTTP12] = accptr->CurrentProcessing[HTTP12];
CurrentProcessing[HTTP1] = accptr->CurrentProcessing[HTTP1];
CurrentProcessing[HTTP2] = accptr->CurrentProcessing[HTTP2];
/* the zero index is when instances are not enabled */
for (idx = 0; idx <= INSTANCE_MAX; idx++)
{
CurrentInstanceConnected[HTTP12][idx] =
accptr->CurrentInstanceConnected[HTTP12][idx];
CurrentInstanceConnected[HTTP1][idx] =
accptr->CurrentInstanceConnected[HTTP1][idx];
CurrentInstanceConnected[HTTP2][idx] =
accptr->CurrentInstanceConnected[HTTP2][idx];
CurrentInstanceProcessing[HTTP12][idx] =
accptr->CurrentInstanceProcessing[HTTP12][idx];
CurrentInstanceProcessing[HTTP1][idx] =
accptr->CurrentInstanceProcessing[HTTP1][idx];
CurrentInstanceProcessing[HTTP2][idx] =
accptr->CurrentInstanceProcessing[HTTP2][idx];
CurrentDclScriptProcess[idx] = accptr->CurrentDclScriptProcess[idx];
CurrentDclScriptCgiPlus[idx] = accptr->CurrentDclScriptCgiPlus[idx];
CurrentDclScriptRTE[idx] = accptr->CurrentDclScriptRTE[idx];
CurrentDECnetCGI[idx] = accptr->CurrentDECnetCGI[idx];
CurrentDECnetOSU[idx] = accptr->CurrentDECnetOSU[idx];
CurrentDECnetTasks[idx] = accptr->CurrentDECnetTasks[idx];
CurrentPersistentHttp1[idx] = accptr->CurrentPersistentHttp1[idx];
CurrentThrottleProcessing[idx] = accptr->CurrentThrottleProcessing[idx];
CurrentThrottleQueued[idx] = accptr->CurrentThrottleQueued[idx];
CurrentWebSockets[idx] = accptr->CurrentWebSockets[idx];
}
/* save instance status data */
indsize = sizeof(AccountingPtr->InstanceNodeData);
indptr = VmGet (indsize);
memcpy (indptr, &AccountingPtr->InstanceNodeData, indsize);
istcnt = AccountingPtr->InstanceStatusTableCount;
istsize = sizeof(AccountingPtr->InstanceStatusTable);
istptr = VmGet (istsize);
memcpy (istptr, &AccountingPtr->InstanceStatusTable, istsize);
/********/
/* zero */
/********/
memset (accptr, 0, sizeof(ACCOUNTING_STRUCT));
memset (ProxyAccountingPtr, 0, sizeof(PROXY_ACCOUNTING_STRUCT));
for (idx = 1; idx <= INSTANCE_MUTEX_COUNT; idx++)
HttpdGblSecPtr->MutexCount[idx] = HttpdGblSecPtr->MutexWaitCount[idx] = 0;
/***********/
/* restore */
/***********/
accptr->StartupCount = StartupCount;
accptr->ZeroedCount = ZeroedCount + 1;
accptr->CurrentConnected[HTTP12] = CurrentConnected[HTTP12];
accptr->CurrentConnected[HTTP1] = CurrentConnected[HTTP1];
accptr->CurrentConnected[HTTP2] = CurrentConnected[HTTP2];
accptr->CurrentProcessing[HTTP12] = CurrentProcessing[HTTP12];
accptr->CurrentProcessing[HTTP1] = CurrentProcessing[HTTP1];
accptr->CurrentProcessing[HTTP2] = CurrentProcessing[HTTP2];
/* the zero index is when instances are not enabled */
for (idx = 0; idx <= INSTANCE_MAX; idx++)
{
accptr->CurrentInstanceConnected[HTTP12][idx] =
CurrentInstanceConnected[HTTP12][idx];
accptr->CurrentInstanceConnected[HTTP1][idx] =
CurrentInstanceConnected[HTTP1][idx];
accptr->CurrentInstanceConnected[HTTP2][idx] =
CurrentInstanceConnected[HTTP2][idx];
accptr->CurrentInstanceProcessing[HTTP12][idx] =
CurrentInstanceProcessing[HTTP12][idx];
accptr->CurrentInstanceProcessing[HTTP1][idx] =
CurrentInstanceProcessing[HTTP1][idx];
accptr->CurrentInstanceProcessing[HTTP2][idx] =
CurrentInstanceProcessing[HTTP2][idx];
accptr->CurrentDclScriptProcess[idx] = CurrentDclScriptProcess[idx];
accptr->CurrentDclScriptCgiPlus[idx] = CurrentDclScriptCgiPlus[idx];
accptr->CurrentDclScriptRTE[idx] = CurrentDclScriptRTE[idx];
accptr->CurrentDECnetCGI[idx] = CurrentDECnetCGI[idx];
accptr->CurrentDECnetOSU[idx] = CurrentDECnetOSU[idx];
accptr->CurrentDECnetTasks[idx] = CurrentDECnetTasks[idx];
accptr->CurrentPersistentHttp1[idx] = CurrentPersistentHttp1[idx];
accptr->CurrentThrottleProcessing[idx] = CurrentThrottleProcessing[idx];
accptr->CurrentThrottleQueued[idx] = CurrentThrottleQueued[idx];
accptr->CurrentWebSockets[idx] = CurrentWebSockets[idx];
}
/* "restore" these from the global equivalents */
ProxyAccountingPtr->ServingEnabled = ProxyServingEnabled;
/* restore instance status data */
memcpy (&AccountingPtr->InstanceNodeData, indptr, indsize);
VmFree (indptr, FI_LI);
AccountingPtr->InstanceStatusTableCount = istcnt;
memcpy (&AccountingPtr->InstanceStatusTable, istptr, istsize);
VmFree (istptr, FI_LI);
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
/*****************************************************************************/
/*
Zero proxy accounting structure.
*/
ControlZeroProxyAccounting ()
{
int idx,
StartupCount,
ZeroedCount;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"ControlZeroProxyAccounting() !UL !&B",
InstanceNodeConfig, InstanceNodeSupervisor);
/* in a multi-instance config, shared data only by the supervisor */
if (InstanceNodeConfig > 1 && !InstanceNodeSupervisor) return;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
memset (ProxyAccountingPtr, 0, sizeof(PROXY_ACCOUNTING_STRUCT));
ProxyAccountingPtr->ServingEnabled = ProxyServingEnabled;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
/*****************************************************************************/
/*
Zero the errors noticed accounting data.
*/
ControlZeroNoticed ()
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "ControlZeroNoticed()");
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
AccountingPtr->ErrorsNoticedCount = 0;
AccountingPtr->ErrorsNoticedTime64 = 0;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
/*****************************************************************************/
/*
Zero (empty) the HTTPDMON status string.
*/
ControlZeroStatus ()
{
int idx,
StartupCount,
ZeroedCount;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"ControlZeroStatus() !UL !&B",
InstanceNodeConfig, InstanceNodeSupervisor);
/* in a multi-instance config, shared data only by the supervisor */
if (InstanceNodeConfig > 1 && !InstanceNodeSupervisor) return;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
HttpdGblSecPtr->StatusMessage[0] = '\0';
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
/*****************************************************************************/
/*
Intended for development purpose ad-hoc commands.
*/
ControlAdhoc (char* ControlString)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "ControlAdhoc() !&Z",
ControlString);
if (strsame (ControlString, "STARTUP", -1))
{
AccountingPtr->StartupCount = 1;
AccountingPtr->LastExitStatus = 0;
AccountingPtr->LastExitPid = 0;
AccountingPtr->LastExitTime64 = 0;
}
else
ErrorNoticed (NULL, 0, "unknown directive", FI_LI);
}
/*****************************************************************************/