[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]
/*****************************************************************************/
/*
WOTSUP.c
The WASD Over-The-Shoulder Uptime Picket is designed to monitor WASD in a
production environment for the purpose of alerting operations staff to
conditions which might cause that production to be adversely impacted.
What follows could be considered the WOTSUP doc (thanks to Ben Burke for this
obvious - but not originally to me - pun). As a matter of fact it seems to fit
so well that this section should have a mascot ...
/\ /\
| \ \ `\
| \ \ `\
\ \ \ |
\ \| |
\ \ |
\ |\ |
.-' .--. |
/^\ ' .-. (
/\ / \ \
| | | | |
.'`|O|/ |__O|.'--.
{ '/___, \
`. ';(_Y_) `-'/ .'
\ \\\_| .' _.-'
`'.`._.'.''`
jgs `-..'
http://www.geocities.com/joan_stark/textcartoon.htm
Back to the serious stuff ...
Alert triggers include:
o server image exit and/or startup (default)
o server process non-existent or suspended (default)
o percentage thresholds on process quotas (optional)
o rates of HTTP status counter change (optional)
o maximum period without request processing (optional)
Alert reports can be delivered via any combination of:
o OPCOM message
o MAIL (VMS and RFC822)
o site-specific DCL command executed in a spawned subprocess
o log file entry
The utility monitors the server environment by periodically polling various
server data. The default interval is 30 seconds but can specified between 1
and 60 using the /INTERVAL qualifier. As the utility requires access to global
memory accounting a per-system WOTSUP is required for each node to be monitored.
The following (somewhat contrived) example illustrates the format and content
of a WOTSUP report delivered via OPCOM. Reports delivered via other mechanisms
have the same content and similar format.
%%%%%%%%%% OPCOM 7-MAY-2005 22:27:18.28 %%%%%%%%%%%
Message from user SYSTEM on KLAATU
Over-The-Shoulder (WASD_WOTSUP) reports:
1. server STARTUP after exit of %X00000001 (%SYSTEM-S-NORMAL)
2. pagfilcnt:395432 pgflquota:500000 79% <= 80%
Multiple items are consolidated and provided in the one report delivery if
noted during the same poll. An item is not re-reported unless it has
subsequently returned to the non-alert threshold and then exceeded it again.
NOTE ON MONIKER
---------------
You may think justifying the use of the cute acronym WOTSUP from a (somewhat
meaningful) functional description required no little effort, and you'd be
right! The 'WASD' is obvious. 'Over-The-Shoulder' refers to the approach the
utility takes; standing outside the server proper and looking over its shoulder
(so to speak) at process data and accounting global memory. 'Uptime' should
also be obvious; the utility is intended to assist in maximising server uptime.
'Picket' refers to it's role as lookout in the sense of this (partial)
dictionary definition:
picket
n 1: a person employed to watch for something to happen [syn: lookout,
lookout man, sentinel, sentry, watch, spotter, scout] 2: a detachment of
troops guarding an army from surprise attack ... 4: a vehicle performing
sentinel duty ...
There is also a very oblique reference intended to that famous signature line
belonging to the cartoon character Bugs Bunny, "Nyahh, what's up, Doc?", and in
this environment implies, "what's happening?" Of course WASD should be up but
we want to know if it's not, or if there's any likelihood it soon might not be.
And, yes, I know WOTSDOWN might be a more accurate moniker but apart from the
slightly negative connotation it's almost impossible to generate such an
acronym without really torturing the intended meaning :-) So, WOTSUP?
MULTIPLE INSTANCES
------------------
WOTSUP will monitor the quotas and status of all server processes associated
with multi-instance sites. It will also report on process exit (e.g.
STOP/IMAGE/ID=, and of course error exits) and process disappearance (e.g.
STOP/ID=). With multi-instance restarts, exit data in the global section is
shared between multiple server processes, and so this will always reflect the
most recent process exit. Generally WOTSUP reports on multi-instance restarts
and single instance failures in a relatively consistent and easily
understandable manner. It will provide a more complex sequence of reports and
report items where the number of instances is being administratively increased
or decreased, and this can require more careful interpretation.
PROCESS QUOTAS
--------------
Quotas are checked by comparing the $GETJPI count against the limit as a
percentage. The following quotas are checked:
ASTlm BIOlm BYTlm DIOlm Enqlm Fillm Pgflquo Tqlm
Should any one of more of these have reached the minimum available percentage
as specified by the /QUOTA qualifier a report is issued. The default is 30%.
Individual process quotas may be set using the appropriate keyword with the
/QUOTA qualifier specifying the individual quota percentage, though this
granularity of control should seldom be necessary. For example
/QUOTA=(20,BYTLM:20,PGFLQUO:50)
sets all quotas to a minimum of 20% but specifically sets BYTlm to 20% and
Pgflquo to 50%.
HTTP RESPONSE STATUS
--------------------
The command-line /HTTP qualifier allows specified HTTP status groups and
individual status codes to be monitored. Status *groups* available are 2xx,
3xx, 4xx and 5xx, although the only meaningful ones for such attention are the
4xx (not found, forbidden, etc.) and 5xx (server errors). Special categories
are 0xx, those requests that fail before any significant processing can be
accomplished, and 403, forbidden responses. Individual status codes might
include 409, 500, 502, etc.
NOTE: setting an individual status code in any groups resets that group's
monitoring so to monitor any individual status code in a group requires that
all codes of interest in that group be specified. There is one exception to
this (for backwards compatibility) 403 (forbidden).
The specified groups/codes are monitored every sixty seconds and any increase
beyond the specified threshold is reported. Groups and thresholds are provided
to the qualifier via a single digit and using the following syntax.
<HTTP-status-group>:<threshold-integer>
An example would be
5:10
which would intrepreted as; for status group 5xx (500, 501, 502, etc.) any
increase of ten or more over any one minute should be reported. The qualifier
allows multiple values to be specified as in the following example
/HTTP=(4:20,403:10,5:10)
where a threshold of 20 is set for the 4xx group, 10 specifically for the 403
status (forbidden), and 10 for the 5xx group.
To report on individual status codes specify a full three digits and the
threshold using the same syntax as for status groups.
<HTTP-status-code>:<threshold-integer>
This example monitors forbidden access (50 per minute), server internal errors
(any 1 in a minute), bad gateway (10 in the minute) and service unavailable (2
per minute).
/HTTP=(403:50,500:1,502:10,503:2)
SERVER GOING QUIET
------------------
The /QUIET qualifier allows a maximum expected period with no requests to be
specified in seconds. (Somewhat obviously) if no requests are received for the
period a report is issued. This period may be exceeded by up to /INTERVAL
seconds.
SPAWNED DCL REPORTING
---------------------
The command provided by the /SPAWN qualifier may be anything the subprocess can
execute. It would most commonly be the execution of a DCL procedure that would
deliver the reporting in some site-specific manner. For example:
/SPAWN=@PRODUCTION-DISK:[SUPPORT]WOTSUP_REPORT.COM
The spawned command accesses the lines of the report for delivery via the
multi-valued system-table logical name WASD_WOTSUP_REPORT. The following DCL
commands provide an example of how to retrieve the values from such a logical.
$ IDX = 0
$ REPORT_LOOP:
$ LINE = F$TRNLNM ("WASD_WOTSUP_REPORT", "LNM$SYSTEM", IDX)
$ IF LINE .EQS. "" THEN GOTO END_REPORT_LOOP
$ WRITE SYS$OUTPUT LINE
$ IDX = IDX + 1
$ GOTO REPORT_LOOP
$ END_REPORT_LOOP:
$!(all WOTSUP reports should contain at least four lines)
$ IF IDX .LT. 4 THEN GOTO REPORT_LOGICAL_NAME_ERROR
DETACHED PROCESS
----------------
The WOTSUP utility is intended to be run as a detached process. The DCL
procedure WOTSUP.COM provides such an infrastructure. WOTSUP can also be run
at the command line to provide some control over such a detached process.
$ WOTSUP /DO=RESTART
$ WOTSUP /DO=EXIT
The first causes the WOTSUP image to exit and the WOTSUP.COM procedure to
restart it. In this way a changed WASD_WOTSUP_PARAM logical name value can be
reread by the utility changing it's run-time behaviour. The second causes the
image to exit and the detached process to delete itself.
USAGE EXAMPLES
--------------
When the server is noticed to have exited, started or restarted, or the server
process no longer exists (this set of events are always reported), and the
first reporting to OPCOM CENTRAL and CLUSTER, the second to OPER1.
$ WOTSUP /OPCOM
$ WOTSUP /OPCOM=OPER1
Report server exit, startup, etc., any server process quota reaching 30% (the
default) or less of maximum (the second example down to 15%), and reporting to
OPCOM CLUSTER only as well as mailing a message to OPERATOR account.
$ WOTSUP /QUOTA /OPCOM=CLUSTER /MAIL=OPERATOR
$ WOTSUP /QUOTA=15 /OPCOM=CLUSTER /MAIL=OPERATOR
These examples add HTTP status reporting, the first any one per minute 5xx
(server error) status, the second any one internal server error (500), ten bad
gateways (502), any server unavailbilities (503), along with any 403
(forbidden) increase, and logging the reports to a site-specific file in
addition to those destinations in the above examples.
$ WOTSUP /QUOTA=15 /HTTP=5:1 /OPCOM=CLUSTER /MAIL=OPERATOR -
/LOG=PRODUCTION_LOGS:WOTSUP_REPORTS.LOG
$ WOTSUP /QUOTA=15 /HTTP=(403:1,500:1,502:10,503:2) /OPCOM=CLUSTER -
/MAIL=OPERATOR /LOG=PRODUCTION_LOGS:WOTSUP_REPORTS.LOG
This example expands the one above, adding a server quiet period of three
minutes, reporting to two mail destinations (one via RFC822) and spawning a
custom DCL command to report using a site-specific mechanism.
$ WOTSUP /QUOTA=15 /HTTP=(5:10,403:1) /QUIET=180 /OPCOM=CLUSTER -
/MAIL="OPERATOR,prod-mgr@home.net" -
/LOG=PRODUCTION_LOGS:WOTSUP_REPORTS.LOG -
/SPAWN=@PRODUCTION_DCL:WOTSUP_REPORTS.COM
This final example reports to all of the specified destinations as a
pre-production, or in-production change, integrity check of the reporting.
$ WOTSUP /CHECK -
/MAIL="OPERATOR,prod-mgr@home.net" -
/LOG=PRODUCTION_LOGS:WOTSUP_REPORTS.LOG -
/SPAWN=@PRODUCTION_DCL:WOTSUP_REPORTS.COM
LOGICAL NAMES
-------------
These are read each time they are required, and therefore can be modified
without restarting the utility, in contrast to the command-line qualifiers that
are only read at utility startup. If present they override anything supplied
at the command-line. These are accessed using LNM$FILE_DEV and so can be
defined in process, job or system tables (etc.) Using the system-level table
allows the value to be modified without restarting the utility.
WASD_WOTSUP_LOG same as /LOG qualifier
WASD_WOTSUP_MAIL same as /MAIL qualifier
WASD_WOTSUP_OPCOM same as /OPCOM qualifier
WASD_WOTSUP_SHUSH if defined reports only to log and OPCOM
WASD_WOTSUP_SPAWN same as /SPAWN qualifier
The following logical name is used by non-interactive WOTSUP in place of any
parameters supplied by the command-line. Defining this as a system-level
logical allows the logical value to be modified and the utility restarted
(obviating the need to modify WOTSUP wrapper procedures).
WASD_WOTSUP_PARAM if present used instead of command-line parameters
The following system-level logical names are created and used by the utility.
WASD_WOTSUP_PID the PID of an executing, non-interactive WOTSUP
WASD_WOTSUP_REPORT this is a multi-value logical created by WOTSUP in
the SYSTEM table containing the lines of report text
available to a spawned reporting DCL command
QUALIFIERS
----------
/CHECK interactive check of /MAIL, /OPCOM and /SPAWN reporting
/DBUG turns on all "if (Debug)" statements
/DO=<keyword> controls a detached process; DELETE, EXIT, RESTART
/EXIT=<integer> seconds wait after exit without restart before alert
/HTTP=<number>:<delta> HTTP status group/code counter threshold (per minute)
/HELP display brief usage information
/INTERVAL=<integer> seconds between checking (default 15)
/LOG=<filename> write alerts to this file as well
/MAIL[=<address(es)>] one or more comma-separated email addresses
(default is SYSTEM, can be RFC822 addresses)
/OPCOM[=<target>] target is CENTRAL, PRINTER, ... OPER12
(default is CENTRAL)
/QUIET[=<integer>] maximum seconds without any request being processed
(default is 300 - 5 minutes)
/QUOTA=<integer> alert when a process quota gets below this percentage
/SPAWN=<string> when a report is required execute this command
(there is a parameter as P1 containing a string)
REQUIRED PRIVILEGES
-------------------
WORLD for access to the server process' JPI data
SYSLCK for access to system locks for multi-instance support
SYSPRV for access to the global section containing the server data
to create logical names in the LNM$SYSTEM table
BUILD DETAILS
-------------
See BUILD_WOTSUP.COM
COPYRIGHT
---------
*/
char CopyrightInfo [] =
"Copyright (C) 2005-2021 Mark G.Daniel.\n\
\n\
Licensed under the Apache License, Version 2.0 (the \"License\");\n\
you may not use this file except in compliance with the License.\n\
You may obtain a copy of the License at\n\
\n\
http://www.apache.org/licenses/LICENSE-2.0\n\
\n\
Unless required by applicable law or agreed to in writing, software\n\
distributed under the License is distributed on an \"AS IS\" BASIS,\n\
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
See the License for the specific language governing permissions and\n\
limitations under the License.\n";
/*
VERSION HISTORY (update SOFTWAREVN as well!)
---------------
18-DEC-2020 MGD v1.1.6, VAX no longer implemented
use native 64bit data (rather than ulong[2])
07-FEB-2016 MGD v1.1.5, WASD v11 |LastExitBinTime| becomes |LastExitTime64|
20-AUG-2013 MGD v1.1.4, SysTrnLnm() becomes SysTrnLnm2() to avoid WASD.H
function prototype collision (differing arguments)
02-JAN-2013 MGD v1.1.3, bugfix; ReportLogFile() log file name pointer
30-AUG-2009 MGD v1.1.2, minor mod for WASD v10.0
WASD_WOTSUP_SHUSH logical name
10-FEB-2008 MGD v1.1.1, OverTheShoulder() check for GBLSEC mismatch
24-SEP-2006 MGD v1.1.0, improve granularity of HTTP status code monitoring
enhances /HTTP= parameters and reporting available
monitor all of multiple instance processes
modify email subject line to indicate report item(s)
increase default interval from 15 to 30 seconds
(all require support available with WASD v9.2.0)
24-APR-2006 MGD v1.0.1, bugfix; GetParameters() /QUIET parameter test
07-MAY-2005 MGD v1.0.0, initial development
*/
/*****************************************************************************/
#define SOFTWAREVN "v1.1.6"
#define SOFTWARENM "WOTSUP"
#ifdef __ALPHA
# define SOFTWAREID SOFTWARENM " AXP-" SOFTWAREVN
#endif
#ifdef __ia64
# define SOFTWAREID SOFTWARENM " IA64-" SOFTWAREVN
#endif
#ifdef __VAX
# error VAX no longer implemented
#endif
#ifdef __x86_64
# define SOFTWAREID SOFTWARENM " X86-" SOFTWAREVN
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
/* VMS related header files */
#include <descrip.h>
#include <dvidef.h>
#include <iodef.h>
#include <jpidef.h>
#include <lckdef.h>
#include <libclidef.h>
#include <libdtdef.h>
#include <lkidef.h>
#include <lnmdef.h>
#include <maildef.h>
#include <psldef.h>
#include <prvdef.h>
#include <secdef.h>
#include <ssdef.h>
#include <stsdef.h>
#include <syidef.h>
/* this header file contains the accounting structure definitions */
#include "../httpd/wasd.h"
/* only with 7.3-2 and later? */
#ifndef SS$_FORCEX
# define SS$_FORCEX 11228
#endif
/* these make it easier to have both VAX and Alpha declarations */
#define OPC$_RQ_RQST 3
#define OPC$M_OPR_CENTRAL 0x1
#define OPC$M_OPR_PRINTER 0x2
#define OPC$M_OPR_TAPES 0x4
#define OPC$M_OPR_DISKS 0x8
#define OPC$M_OPR_DEVICES 0x10
#define OPC$M_OPR_CARDS 0x20
#define OPC$M_OPR_NETWORK 0x40
#define OPC$M_OPR_CLUSTER 0x80
#define OPC$M_OPR_SECURITY 0x100
#define OPC$M_OPR_REPLY 0x200
#define OPC$M_OPR_SOFTWARE 0x400
#define OPC$M_OPR_LICENSE 0x800
#define OPC$M_OPR_USER1 0x1000
#define OPC$M_OPR_USER2 0x2000
#define OPC$M_OPR_USER3 0x4000
#define OPC$M_OPR_USER4 0x8000
#define OPC$M_OPR_USER5 0x10000
#define OPC$M_OPR_USER6 0x20000
#define OPC$M_OPR_USER7 0x40000
#define OPC$M_OPR_USER8 0x80000
#define OPC$M_OPR_USER9 0x100000
#define OPC$M_OPR_USER10 0x200000
#define OPC$M_OPR_USER11 0x400000
#define OPC$M_OPR_USER12 0x800000
#define BOOL int
#define TRUE 1
#define FALSE 0
#define FI_LI "WOTSUP", __LINE__
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define DEFAULT_INTERVAL_SECONDS 30
#define DEFAULT_QUIET_SECONDS 300
#define DEFAULT_QUOTA_MIN_PERCENT 30
#define INSTANCE_INTERVAL_SECONDS 75
#define SUSPENDED_RETRY_SECONDS 30
#define WASD_WOTSUP_LOG "WASD_WOTSUP_LOG"
#define WASD_WOTSUP_MAIL "WASD_WOTSUP_MAIL"
#define WASD_WOTSUP_OPCOM "WASD_WOTSUP_OPCOM"
#define WASD_WOTSUP_SHUSH "WASD_WOTSUP_SHUSH"
#define WASD_WOTSUP_SPAWN "WASD_WOTSUP_SPAWN"
#define WASD_WOTSUP_PID "WASD_WOTSUP_PID"
#define WASD_WOTSUP_REPORT "WASD_WOTSUP_REPORT"
#define INSTANCE_MAX 8
char ErrorSanityCheck [] = "sanity check",
Utility [] = "WOTSUP";
BOOL DoCheck,
Debug;
int CliStatusGroup403Delta,
CliOpcomTarget,
CliReportExitType,
DefaultOpcomTarget = OPC$M_OPR_CENTRAL | OPC$M_OPR_CLUSTER,
ExitStatus,
InstanceCount = -1,
InstanceCountChange,
InstanceGroupNumber = 1, /* default group number */
IntervalSeconds = DEFAULT_INTERVAL_SECONDS,
JpiMode,
JpiPid,
PercentMinAst = DEFAULT_QUOTA_MIN_PERCENT,
PercentMinBio = DEFAULT_QUOTA_MIN_PERCENT,
PercentMinByt = DEFAULT_QUOTA_MIN_PERCENT,
PercentMinDio = DEFAULT_QUOTA_MIN_PERCENT,
PercentMinEnq = DEFAULT_QUOTA_MIN_PERCENT,
PercentMinFil = DEFAULT_QUOTA_MIN_PERCENT,
PercentMinPg = DEFAULT_QUOTA_MIN_PERCENT,
PercentMinTq = DEFAULT_QUOTA_MIN_PERCENT,
PreviousInstanceCount,
PreviousStartupCount,
QuietSeconds,
SecondsAfterExit;
int CliStatusCodeNumber [RESPONSE_STATUS_CODE_MAX],
CliStatusCountDelta [RESPONSE_STATUS_CODE_MAX],
CliStatusGroupDelta [1+5],
InstancePid [INSTANCE_MAX];
int64 PreviousLastExitTime64;
unsigned long SetPrvMask [2] =
{ PRV$M_SYSLCK | PRV$M_SYSPRV | PRV$M_WORLD, 0 };
unsigned short SyiClusterNodes,
SyiNodeLength;
char *JpiModeName,
*CliLogPtr,
*CliMailToPtr,
*CliSpawnCommandPtr,
*CommandLinePtr;
char CommandLine [256],
JpiPrcNam [16],
JpiUserName [13],
MailPersonal [64],
SyiNodeName [16];
int HttpdGblSecLength;
HTTPD_GBLSEC *HttpdGblSecPtr;
ACCOUNTING_STRUCT *AccountingPtr;
struct AnExitHandler ExitHandler;
/* required prototypes */
GetInstancePid ();
LookBack (int*);
ReportLine (char*, ...);
ReportServerPidName ();
char* ReportSubj (char*, ...);
BOOL SetHttpStatusCode (int, int);
char* SysGetMsg (int);
char* SysTrnLnm2 (char*, char*);
/*****************************************************************************/
/*
*/
int main ()
{
static short PrcNamLength;
static struct
{
unsigned short buf_len;
unsigned short item;
unsigned char *buf_addr;
void *ret_len;
}
JpiItems [] =
{
{ sizeof(JpiPid), JPI$_PID, &JpiPid, 0 },
{ sizeof(JpiMode), JPI$_MODE, &JpiMode, 0 },
{ sizeof(JpiUserName)-1, JPI$_USERNAME, &JpiUserName, 0 },
{ sizeof(JpiPrcNam)-1, JPI$_PRCNAM, &JpiPrcNam, &PrcNamLength },
{ 0,0,0,0 }
},
SyiItems [] =
{
{ sizeof(SyiClusterNodes), SYI$_CLUSTER_NODES, &SyiClusterNodes, 0 },
{ sizeof(SyiNodeName)-1, SYI$_NODENAME, &SyiNodeName, &SyiNodeLength },
{ 0,0,0,0 }
};
int status;
char *cptr;
/*********/
/* begin */
/*********/
status = sys$setprv (1, &SetPrvMask, 0, 0);
if (VMSnok (status) || status == SS$_NOTALLPRIV)
ErrorExit (status, "$SETPRV()", FI_LI);
status = sys$getsyi (0, 0, 0, &SyiItems, 0, 0, 0);
if (VMSnok (status)) ErrorExit (status, "$GETSYI()", FI_LI);
SyiNodeName[SyiNodeLength] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", SyiNodeName);
status = sys$getjpiw (0, 0, 0, &JpiItems, 0, 0, 0);
if (VMSnok (status)) ErrorExit (status, "$GETJPIW()", FI_LI);
switch (JpiMode)
{
case JPI$K_INTERACTIVE : JpiModeName = "INTERACTIVE"; break;
case JPI$K_NETWORK : JpiModeName = "NETWORK"; break;
case JPI$K_OTHER : JpiModeName = "DETACHED"; break;
case JPI$K_BATCH : JpiModeName = "BATCH"; break;
default : JpiModeName = "?";
}
JpiPrcNam[PrcNamLength] = '\0';
for (cptr = JpiUserName; *cptr && *cptr != ' '; cptr++);
*cptr = '\0';
if (Debug)
fprintf (stdout, "%08.08X %d |%s|%s|%s|\n",
JpiPid, JpiMode, JpiModeName, JpiUserName, JpiPrcNam);
GetParameters ();
if (JpiMode == JPI$K_INTERACTIVE)
fprintf (stdout, "%%%s-I-INTERACTIVE, %s as %s\n%s",
Utility, JpiUserName, JpiPrcNam, CopyrightInfo);
/* build a personal name in case it's needed when mailing */
sprintf (MailPersonal, "WOTSUP on %s", SyiNodeName);
if (DoCheck)
{
ReportSubj ("/CHECK only, please ignore");
ReportLine ("!AZ /CHECK only, please ignore!!", SOFTWAREID);
ReportLine (NULL);
exit (SS$_NORMAL);
}
if (JpiMode != JPI$K_INTERACTIVE)
{
$DESCRIPTOR (LogFaoDsc,
"%%%%%%%%%% WOTSUP !%D %%%%%%%%%%%\n\
Message from user !AZ on !AZ\n\
Over-The-Shoulder (!AZ) !AZ mode startup\n\
!AZ\0");
char Buffer [512];
$DESCRIPTOR (BufferDsc, Buffer);
fprintf (stdout, "%%%s-I-SOFTWAREID, %s\n\n", Utility, SOFTWAREID);
status = sys$fao (&LogFaoDsc, 0, &BufferDsc,
0, JpiUserName, SyiNodeName, JpiPrcNam,
JpiModeName, CommandLinePtr);
if (VMSnok (status) || status == SS$_BUFFEROVF)
ErrorExit (status, "$FAO()", FI_LI);
fprintf (stdout, "%s\n\n", Buffer);
ReportLogFile (Buffer);
ReportOpcom (DefaultOpcomTarget,
"Over-The-Shoulder (!AZ) !AZ mode startup\r\n\!AZ",
JpiPrcNam, JpiModeName, CommandLinePtr);
sprintf (Buffer, "%08.08X", JpiPid);
SysCreLnm (WASD_WOTSUP_PID, Buffer);
/* set up and declare the exit handler */
ExitHandler.HandlerAddress = &LookBack;
ExitHandler.ArgCount = 1;
ExitHandler.ExitStatusPtr = &ExitStatus;
if (VMSnok (status = sys$dclexh (&ExitHandler)))
ErrorExit (status, "$DCLEXH()", FI_LI);
}
MapGlobalSection ();
AccountingPtr = &HttpdGblSecPtr->Accounting;
LookAtHttp (1);
OverTheShoulder ();
}
/*****************************************************************************/
/*
Declared exit handler.
*/
int LookBack (int *ExitStatusPtr)
{
int status;
char *cptr;
$DESCRIPTOR (LogFaoDsc,
"%%%%%%%%%% WOTSUP !%D %%%%%%%%%%%\n\
Message from user !AZ on !AZ\n\
Over-The-Shoulder (!AZ) !AZ mode !AZ\0");
char Buffer [512];
$DESCRIPTOR (BufferDsc, Buffer);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "LookBack() %%X%08.08X\n", *ExitStatusPtr);
status = *ExitStatusPtr;
if (status == SS$_NORMAL)
cptr = "REQUESTED RESTART";
else
if (status == SS$_FORCEX)
cptr = "REQUESTED EXIT";
else
cptr = "ERROR EXIT";
sys$fao (&LogFaoDsc, 0, &BufferDsc,
0, JpiUserName, SyiNodeName, JpiPrcNam, JpiModeName, cptr);
fprintf (stdout, "%s\n\n", Buffer);
}
/*****************************************************************************/
/*
Loop, checking on the server, sleeping 'interval' seconds between checks.
*/
int OverTheShoulder ()
{
BOOL LookNow;
int cnt;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "OverTheShoulder()\n");
for (;;)
{
if (HttpdGblSecPtr->GblSecVersion != HTTPD_GBLSEC_VERSION_NUMBER ||
HttpdGblSecPtr->GblSecLength != sizeof(HTTPD_GBLSEC))
{
ReportSubj ("GBLSEC mismatch");
ReportLine ("Global section mismatch, rebuild WOTSUP?");
/* report it */
ReportLine (NULL);
exit (SS$_ABORT);
}
GetInstancePid ();
if (InstanceCount != PreviousInstanceCount)
{
/*
If the number of instances changed don't report it immediately.
This also has the desirable side-effect of delaying any initial
report by this interval allowing things to settle down a bit
first (whatever this means exactly).
*/
if (InstanceCountChange >= INSTANCE_INTERVAL_SECONDS)
{
if (PreviousInstanceCount)
{
ReportSubj ("INSTANCES:!UL", InstanceCount);
ReportLine ("number of instances has changed from !UL to !UL",
PreviousInstanceCount, InstanceCount);
}
InstanceCountChange = 0;
PreviousInstanceCount = InstanceCount;
LookNow = TRUE;
}
else
{
InstanceCountChange += IntervalSeconds;
LookNow = FALSE;
}
}
else
LookNow = TRUE;
if (LookNow)
{
LookAtServer ();
for (cnt = 0; cnt < INSTANCE_MAX; cnt++) LookAtProcess (cnt);
LookAtHttp (0);
/* if there is anything to report then this will do it */
ReportLine (NULL);
}
sleep (IntervalSeconds);
}
}
/*****************************************************************************/
/*
Check that the server still exists, has not exited and/or restarted.
*/
int LookAtServer ()
{
static BOOL QuietReported;
static unsigned long PrevRequestCount,
RequestSeconds;
BOOL IncludeServerList = FALSE;
int idx, status,
ReportExitType;
unsigned long CurrentSeconds,
RequestCount;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "LookAtServer()\n");
if (AccountingPtr->LastExitTime64)
{
if (PreviousLastExitTime64 &&
AccountingPtr->LastExitTime64 != PreviousLastExitTime64)
{
/* startup count has changed since the utility initialized */
ReportSubj ("EXIT:%X!8XL", AccountingPtr->LastExitStatus);
ReportLine ("server PID !8XL exit %X!8XL (!AZ)",
AccountingPtr->LastExitPid,
AccountingPtr->LastExitStatus,
SysGetMsg(AccountingPtr->LastExitStatus));
IncludeServerList = TRUE;
}
PreviousLastExitTime64 = AccountingPtr->LastExitTime64;
}
if (AccountingPtr->StartupCount &&
PreviousStartupCount != AccountingPtr->StartupCount)
{
if (PreviousStartupCount)
{
/* startup count has changed since the utility initialized */
ReportSubj ("STARTUP:!UL", AccountingPtr->StartupCount);
ReportLine ("server STARTUP (!UL)", AccountingPtr->StartupCount);
IncludeServerList = TRUE;
}
PreviousStartupCount = AccountingPtr->StartupCount;
}
if (IncludeServerList) ReportServerPidName();
if (QuietSeconds)
{
RequestCount = AccountingPtr->ProcessingTotalCount[HTTP12];
if (PrevRequestCount && RequestCount == PrevRequestCount)
{
CurrentSeconds = time(NULL);
if (CurrentSeconds - RequestSeconds > QuietSeconds)
{
if (!QuietReported)
{
ReportSubj ("QUIET");
ReportLine ("no requests processed for !UL seconds",
CurrentSeconds - RequestSeconds);
QuietReported = TRUE;
}
}
}
else
{
QuietReported = FALSE;
PrevRequestCount = RequestCount;
RequestSeconds = time(NULL);
}
}
}
/*****************************************************************************/
/*
Check that the server process still exists, and that each of the relevant
process quotas has not reached it's minimum remaining quotas. As a process is
normally on occasion in a SUSPENDED state allow for this by retrying a limited
number of times.
*/
int LookAtProcess (int InstanceIndex)
{
static BOOL AstReported [INSTANCE_MAX],
BioReported [INSTANCE_MAX],
BytReported [INSTANCE_MAX],
DioReported [INSTANCE_MAX],
EnqReported [INSTANCE_MAX],
FilReported [INSTANCE_MAX],
NonExprReported [INSTANCE_MAX],
PgReported [INSTANCE_MAX],
TqReported [INSTANCE_MAX];
static unsigned long HttpdPid [INSTANCE_MAX];
static int NonExprSeconds [INSTANCE_MAX];
static unsigned long JpiAstCnt,
JpiAstLm,
JpiBioCnt,
JpiBytLm,
JpiBytCnt,
JpiBioLm,
JpiDioCnt,
JpiDioLm,
JpiEnqCnt,
JpiEnqLm,
JpiFilCnt,
JpiFilLm,
JpiPagFilCnt,
JpiPgFlQuota,
JpiPid,
JpiPrcCnt,
JpiPrcLm,
JpiTqCnt,
JpiTqLm;
static int64 ConnectTime64,
CurrentTime64,
JpiLoginTime64;
static char JpiPrcNam [16];
static struct
{
unsigned short buf_len;
unsigned short item;
unsigned char *buf_addr;
void *ret_len;
}
JpiItems [] =
{
{ sizeof(JpiAstCnt), JPI$_ASTCNT, &JpiAstCnt, 0 },
{ sizeof(JpiAstLm), JPI$_ASTLM, &JpiAstLm, 0 },
{ sizeof(JpiBioCnt), JPI$_BIOCNT, &JpiBioCnt, 0 },
{ sizeof(JpiBioLm), JPI$_BIOLM, &JpiBioLm, 0 },
{ sizeof(JpiBytCnt), JPI$_BYTCNT, &JpiBytCnt, 0 },
{ sizeof(JpiBytLm), JPI$_BYTLM, &JpiBytLm, 0 },
{ sizeof(JpiDioCnt), JPI$_DIOCNT, &JpiDioCnt, 0 },
{ sizeof(JpiDioLm), JPI$_DIOLM, &JpiDioLm, 0 },
{ sizeof(JpiEnqCnt), JPI$_ENQCNT, &JpiEnqCnt, 0 },
{ sizeof(JpiEnqLm), JPI$_ENQLM, &JpiEnqLm, 0 },
{ sizeof(JpiFilCnt), JPI$_FILCNT, &JpiFilCnt, 0 },
{ sizeof(JpiFilLm), JPI$_FILLM, &JpiFilLm, 0 },
{ sizeof(JpiPagFilCnt), JPI$_PAGFILCNT, &JpiPagFilCnt, 0 },
{ sizeof(JpiPgFlQuota), JPI$_PGFLQUOTA, &JpiPgFlQuota, 0 },
{ sizeof(JpiPid), JPI$_PID, &JpiPid, 0 },
{ sizeof(JpiPrcNam), JPI$_PRCNAM, &JpiPrcNam, 0 },
{ sizeof(JpiTqCnt), JPI$_TQCNT, &JpiTqCnt, 0 },
{ sizeof(JpiTqLm), JPI$_TQLM, &JpiTqLm, 0 },
{0,0,0,0}
};
int attempt, idx, status,
CurrentSeconds;
unsigned short Length;
char *cptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "LookAtProcess()\n");
if (HttpdPid[InstanceIndex] != InstancePid [InstanceIndex])
{
AstReported[InstanceIndex] = BioReported[InstanceIndex] =
BytReported[InstanceIndex] = DioReported[InstanceIndex] =
EnqReported[InstanceIndex] = FilReported[InstanceIndex] =
NonExprReported[InstanceIndex] = PgReported[InstanceIndex] =
TqReported[InstanceIndex] = FALSE;
NonExprSeconds[InstanceIndex] = 0;
}
HttpdPid[InstanceIndex] = InstancePid[InstanceIndex];
/* if just reseting the PID-related info */
if (!HttpdPid[InstanceIndex]) return (SS$_NORMAL);
if (Debug) fprintf (stdout, "%08.08X\n", HttpdPid[InstanceIndex]);
/* try once per second for however many */
attempt = SUSPENDED_RETRY_SECONDS;
for (;;)
{
status = sys$getjpiw (0, &HttpdPid[InstanceIndex], 0, &JpiItems, 0, 0, 0);
if (Debug) fprintf (stdout, "sys$getjpiw() %%X%08.08X\n", status);
if (VMSok (status)) break;
if (status == SS$_SUSPENDED)
{
sleep (1);
if (attempt--) continue;
/* after retrying for SUSPENDED_RETRY_SECONDS it's still suspended */
ReportSubj ("SERVER:%X!8XL", status);
ReportLine ("server PID !8XL is %X!8XL (!AZ)",
HttpdPid[InstanceIndex], status, SysGetMsg(status));
return (SS$_NORMAL);
}
if (status == SS$_NONEXPR)
{
ReportSubj ("SERVER:%X!8XL", status);
ReportLine ("server PID !8XL is %X!8XL (!AZ)",
HttpdPid[InstanceIndex], status, SysGetMsg(status));
/* "Make it so, Number One" */
InstancePid[InstanceIndex] = 0;
return (SS$_NORMAL);
}
ErrorExit (status, "$GETJPIW()", FI_LI);
}
JpiPrcNam[15] = '\0';
for (cptr = JpiPrcNam; *cptr && *cptr != ' '; cptr++);
*cptr = '\0';
if (Debug) fprintf (stdout, "JpiPrcNam |%s|\n", JpiPrcNam);
sys$gettim (&CurrentTime64);
lib$sub_times (&CurrentTime64, &JpiLoginTime64, &ConnectTime64);
if (JpiAstLm)
{
if (JpiAstCnt * 100 / JpiAstLm <= PercentMinAst)
{
if (!AstReported[InstanceIndex])
{
ReportSubj ("QUOTA:astlm");
ReportLine ("!8XL !AZ astcnt:!UL astlm:!UL !UL% <= !UL%",
JpiPid, JpiPrcNam,
JpiAstCnt, JpiAstLm,
JpiAstCnt * 100 / JpiAstLm, PercentMinAst);
AstReported[InstanceIndex] = TRUE;
}
}
else
AstReported[InstanceIndex] = FALSE;
}
if (JpiBioLm)
{
if (JpiBioCnt * 100 / JpiBioLm <= PercentMinBio)
{
if (!BioReported[InstanceIndex])
{
ReportSubj ("QUOTA:biolm");
ReportLine ("!8XL !AZ biocnt:!UL biolm:!UL !UL% <= !UL%",
JpiPid, JpiPrcNam,
JpiBioCnt, JpiBioLm,
JpiBioCnt * 100 / JpiBioLm, PercentMinBio);
BioReported[InstanceIndex] = TRUE;
}
}
else
BioReported[InstanceIndex] = FALSE;
}
if (JpiBytLm)
{
if (JpiBytCnt * 100 / JpiBytLm <= PercentMinByt)
{
if (!BytReported[InstanceIndex])
{
ReportSubj ("QUOTA:bytlm");
ReportLine ("!8XL !AZ bytcnt:!UL bytlm:!UL !UL% <= !UL%",
JpiPid, JpiPrcNam,
JpiBytCnt, JpiBytLm,
JpiBytCnt * 100 / JpiBytLm, PercentMinByt);
BytReported[InstanceIndex] = TRUE;
}
}
else
BytReported[InstanceIndex] = FALSE;
}
if (JpiDioLm)
{
if (JpiDioCnt * 100 / JpiDioLm <= PercentMinDio)
{
if (!DioReported[InstanceIndex])
{
ReportSubj ("QUOTA:diolm");
ReportLine ("!8XL !AZ diocnt:!UL diolm:!UL !UL% <= !UL%",
JpiPid, JpiPrcNam,
JpiDioCnt, JpiDioLm,
JpiDioCnt * 100 / JpiDioLm, PercentMinDio);
DioReported[InstanceIndex] = TRUE;
}
}
else
DioReported[InstanceIndex] = FALSE;
}
if (JpiEnqLm)
{
if (JpiEnqCnt * 100 / JpiEnqLm <= PercentMinEnq)
{
if (!EnqReported[InstanceIndex])
{
ReportSubj ("QUOTA:enqlm");
ReportLine ("!8XL !AZ enqcnt:!UL enqlm:!UL !UL% <= !UL%",
JpiPid, JpiPrcNam,
JpiEnqCnt, JpiEnqLm,
JpiEnqCnt * 100 / JpiEnqLm, PercentMinEnq);
EnqReported[InstanceIndex] = TRUE;
}
}
else
EnqReported[InstanceIndex] = FALSE;
}
if (JpiFilLm)
{
if (JpiFilCnt * 100 / JpiFilLm <= PercentMinFil)
{
if (!FilReported[InstanceIndex])
{
ReportSubj ("QUOTA:fillm");
ReportLine ("!8XL !AZ filcnt:!UL fillm:!UL !UL% <= !UL%",
JpiPid, JpiPrcNam,
JpiFilCnt, JpiFilLm,
JpiFilCnt * 100 / JpiFilLm, PercentMinFil);
FilReported[InstanceIndex] = TRUE;
}
}
else
FilReported[InstanceIndex] = FALSE;
}
if (JpiTqLm)
{
if (JpiTqCnt * 100 / JpiTqLm <= PercentMinTq)
{
if (!TqReported[InstanceIndex])
{
ReportSubj ("QUOTA:tqlm");
ReportLine ("!8XL !AZ tqcnt:!UL tqlm:!UL !UL% <= !UL%",
JpiPid, JpiPrcNam,
JpiTqCnt, JpiTqLm,
JpiTqCnt * 100 / JpiTqLm, PercentMinTq);
TqReported[InstanceIndex] = TRUE;
}
}
else
TqReported[InstanceIndex] = FALSE;
}
if (JpiPgFlQuota)
{
if (JpiPagFilCnt * 100 / JpiPgFlQuota <= PercentMinPg)
{
if (!PgReported[InstanceIndex])
{
ReportSubj ("QUOTA:pgflquota");
ReportLine ("!8XL !AZ pagfilcnt:!UL pgflquota:!UL !UL% <= !UL%",
JpiPid, JpiPrcNam,
JpiPagFilCnt, JpiPgFlQuota,
JpiPagFilCnt * 100 / JpiPgFlQuota, PercentMinPg);
PgReported[InstanceIndex] = TRUE;
}
}
else
PgReported[InstanceIndex] = FALSE;
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Check the HTTP response status code counters once per minute to ascertain
whether any have increased greater than the allowed threshold. Operates in
two modes. After the initial call, with 'DoCheck' true, it is called using a
timer every sixty seconds to check the server HTTP counters against the
thresholds. If any has exceeded it has it's corresponding alert boolean set.
When called with 'DoCheck' false it checks these booleans and reports any that
are set.
*/
int LookAtHttp (BOOL DoCheck)
{
static BOOL StatusCode403Alert;
static BOOL StatusCodeCountAlert [RESPONSE_STATUS_CODE_MAX],
StatusCodeGroupAlert [1+5];
static int PrevStatusCode403Count,
StatusCode403Count;
static int PrevStatusCodeGroup [1+5],
StatusCodeGroup [1+5];
/* RESPONSE_STATUS_CODE_MAX is defined in [SRC.HTTPD]WASD.H */
static unsigned long PrevStatusCodeCount [RESPONSE_STATUS_CODE_MAX],
StatusCodeCount [RESPONSE_STATUS_CODE_MAX];
static unsigned long OneMinuteDelta [2] = { -600000000, -1 };
int idx, status;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "LookAtHttp() %d\n", DoCheck);
if (DoCheck)
{
/* check the code groups (1xx, 2xx, 3xx, 4xx, 5xx) */
for (idx = 0; idx <= 5; idx++)
{
if (idx == 1 || !CliStatusGroupDelta[idx]) continue;
StatusCodeGroup[idx] = AccountingPtr->ResponseStatusCodeGroup[idx];
if (PrevStatusCodeGroup[idx])
if (StatusCodeGroup[idx] >= PrevStatusCodeGroup[idx] +
CliStatusGroupDelta[idx])
StatusCodeGroupAlert[idx] = TRUE;
else
StatusCodeGroupAlert[idx] = FALSE;
else
{
StatusCodeGroupAlert[idx] = FALSE;
PrevStatusCodeGroup[idx] = StatusCodeGroup[idx];
}
}
/* check the individual code counts (100, 101, 200, 201 ... 505) */
for (idx = 1; idx < RESPONSE_STATUS_CODE_MAX; idx++)
{
if (!CliStatusCountDelta[idx]) continue;
StatusCodeCount[idx] = AccountingPtr->ResponseStatusCodeCount[idx];
if (PrevStatusCodeCount[idx])
if (StatusCodeCount[idx] >= PrevStatusCodeCount[idx] +
CliStatusCountDelta[idx])
StatusCodeCountAlert[idx] = TRUE;
else
StatusCodeCountAlert[idx] = FALSE;
else
{
StatusCodeCountAlert[idx] = FALSE;
PrevStatusCodeCount[idx] = StatusCodeCount[idx];
}
}
StatusCode403Count = AccountingPtr->RequestForbiddenCount;
if (CliStatusGroup403Delta && PrevStatusCode403Count)
if (StatusCode403Count > PrevStatusCode403Count +
CliStatusGroup403Delta)
StatusCode403Alert = TRUE;
else
StatusCode403Alert = FALSE;
else
{
StatusCode403Alert = FALSE;
PrevStatusCode403Count = StatusCode403Count;
}
status = sys$setimr (0, &OneMinuteDelta, &LookAtHttp, 1, 0);
if (VMSnok (status)) ErrorExit (status, "$SETIMR()", FI_LI);
}
else
{
/* report code groups */
for (idx = 0; idx <= 5; idx++)
{
if (StatusCodeGroupAlert[idx])
{
ReportSubj ("HTTP:!ULxx", idx);
ReportLine ("HTTP !ULxx curr:!UL > prev:!UL + !UL",
idx, StatusCodeGroup[idx],
PrevStatusCodeGroup[idx], CliStatusGroupDelta[idx]);
StatusCodeGroupAlert[idx] = FALSE;
PrevStatusCodeGroup[idx] = StatusCodeGroup[idx];
}
}
/* report individual codes */
for (idx = 1; idx < RESPONSE_STATUS_CODE_MAX; idx++)
{
if (StatusCodeCountAlert[idx])
{
ReportSubj ("HTTP:!UL", CliStatusCodeNumber[idx]);
ReportLine ("HTTP !UL curr:!UL > prev:!UL + !UL",
CliStatusCodeNumber[idx], StatusCodeCount[idx],
PrevStatusCodeCount[idx], CliStatusCountDelta[idx]);
StatusCodeCountAlert[idx] = FALSE;
PrevStatusCodeCount[idx] = StatusCodeCount[idx];
}
}
if (StatusCode403Alert)
{
ReportSubj ("HTTP:403");
ReportLine ("HTTP 403 curr:!UL > prev:!UL + !UL",
StatusCode403Count, PrevStatusCode403Count,
CliStatusGroup403Delta);
StatusCode403Alert = FALSE;
PrevStatusCode403Count = StatusCode403Count;
}
}
}
/*****************************************************************************/
/*
Create a report line containing the PID and process name of each process in the
InstancePid[] array.
*/
ReportServerPidName ()
{
static unsigned long JpiPid;
static char JpiPrcNam [16];
static struct
{
unsigned short buf_len;
unsigned short item;
unsigned char *buf_addr;
void *ret_len;
}
JpiItems [] =
{
{ sizeof(JpiPrcNam), JPI$_PRCNAM, &JpiPrcNam, 0 },
{0,0,0,0}
};
int cnt = 0,
idx, status;
char *cptr, *sptr;
char ListBuffer [21+(INSTANCE_MAX*28)+1];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ReportServerPidName()\n");
sptr = ListBuffer;
for (idx = 0; idx < INSTANCE_MAX; idx++)
{
if (!InstancePid[idx]) continue;
status = sys$getjpiw (0, &InstancePid[idx], 0, &JpiItems, 0, 0, 0);
if (Debug) fprintf (stdout, "sys$getjpiw() %%X%08.08X\n", status);
/* only time it continues is when the process does not exist */
if (VMSnok (status) && status == SS$_NONEXPR) continue;
if (cnt++)
sptr += sprintf( sptr, ", ");
else
sptr += sprintf (sptr, "server PID%s ",
InstanceCount > 1 ? "s are" : " is");
if (VMSok (status))
{
JpiPrcNam[15] = '\0';
for (cptr = JpiPrcNam; *cptr && *cptr != ' '; cptr++);
*cptr = '\0';
sptr += sprintf (sptr, "%08.08X (%s)", InstancePid[idx], JpiPrcNam);
}
else
sptr += sprintf (sptr, "%08.08X (%%X%08.08X)",
InstancePid[idx], status);
}
if (!cnt)
sprintf (sptr, "no server process%s found",
InstanceCount > 1 ? "es" : "");
ReportLine (ListBuffer);
}
/*****************************************************************************/
/*
See [SRC.HTTPD]CONTROL.C for other information. Uses the VMS Distributed Lock
Manager to keep track of how many servers are currently executing on the
node/cluster. NL locks indicate interest (used by this utility), CR locks
indicate a server waiting for a group directive. This function enqueues a
single NL lock, then periodically get all the locks associated with that
resource and counts up the number of CR locks - giving the number of servers!
*/
GetInstancePid ()
{
static char NodeLockName [32],
PrevInstanceString [32];
static $DESCRIPTOR (NodeLockNameDsc, NodeLockName);
static LKIDEF LkiLocks [32];
static struct lksb NodeLockLksb;
static struct
{
unsigned short TotalLength, /* bits 0..15 */
LockLength; /* bits 16..30 */
} ReturnLength;
static struct
{
unsigned short buf_len;
unsigned short item;
unsigned char *buf_addr;
void *ret_len;
}
LkiItems [] =
{
{ sizeof(LkiLocks), LKI$_LOCKS, &LkiLocks, &ReturnLength },
{0,0,0,0}
};
int cnt, idx, status,
LockCount,
LockNameMagic;
char *cptr, *sptr, *zptr;
unsigned long LockPid [INSTANCE_MAX];
IO_SB IOsb;
LKIDEF *lkiptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "GetInstancePid()\n");
if (!NodeLockName[0])
{
/************************/
/* build and queue lock */
/************************/
if (InstanceGroupNumber > INSTANCE_ENV_NUMBER_MAX)
ErrorExit (SS$_BUGCHECK, "Group number range.", FI_LI);
/* a byte comprising two 4 bit fields, version and server group number */
LockNameMagic = ((HTTPD_LOCK_VERSION & 0xf) << 4) |
(InstanceGroupNumber & 0xf);
/* build the (binary) resource name for the node lock */
zptr = (sptr = NodeLockName) + sizeof(NodeLockName)-1;
for (cptr = HTTPD_NAME; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (sptr < zptr) *sptr++ = (char)LockNameMagic;
for (cptr = SyiNodeName; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (sptr < zptr) *sptr++ = (char)0x05;
NodeLockNameDsc.dsc$w_length = sptr - NodeLockName;
/* enqueue a just-interested NL lock */
status = sys$enqw (0, LCK$K_NLMODE, &NodeLockLksb,
LCK$M_EXPEDITE | LCK$M_SYSTEM,
&NodeLockNameDsc, 0, 0, 0, 0, 0, 2, 0);
if (VMSok (status)) status = NodeLockLksb.lksb$w_status;
if (VMSnok (status)) ErrorExit (status, "$ENQW()", FI_LI);
}
/*****************************************/
/* get and count the node instance locks */
/*****************************************/
status = sys$getlkiw (0, &NodeLockLksb.lksb$l_lkid, &LkiItems, &IOsb,
0, 0, 0);
if (VMSok (status)) status = NodeLockLksb.lksb$w_status;
if (VMSnok (status)) ErrorExit (status, "$GETLKIW()", FI_LI);;
if (ReturnLength.LockLength)
{
/* if insufficient buffer space */
if (ReturnLength.LockLength & 0x8000)
ErrorExit (SS$_BADPARAM, "$GETLKIW()", FI_LI);;
LockCount = ReturnLength.TotalLength / ReturnLength.LockLength;
}
else
LockCount = 0;
if (Debug) fprintf (stdout, "%d\n", LockCount);
InstanceCount = 0;
lkiptr = &LkiLocks;
for (cnt = LockCount; cnt; cnt--)
{
if (Debug) fprintf (stdout, "lki$b_grmode: %d\n", lkiptr->lki$b_grmode);
if (lkiptr->lki$b_grmode != LCK$K_NLMODE)
{
if (Debug)
fprintf (stdout, "%d %08x\n", InstanceCount, lkiptr->lki$l_pid);
if (InstanceCount >= INSTANCE_MAX)
ErrorExit (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
LockPid[InstanceCount++] = lkiptr->lki$l_pid;
}
lkiptr++;
}
/**************************************************/
/* reorganise PID array so each element is stable */
/**************************************************/
/* correlate existing PIDs in the instance array with the lock array */
for (idx = 0; idx < INSTANCE_MAX; idx++)
{
if (!InstancePid[idx]) continue;
for (cnt = 0; cnt < InstanceCount; cnt++)
{
if (InstancePid[idx] == LockPid[cnt])
{
/* this lock PID is already in the instance array */
LockPid[cnt] = 0;
break;
}
}
}
/* now place any new PIDs from the lock to the instance array */
for (cnt = 0; cnt < InstanceCount; cnt++)
{
if (!LockPid[cnt]) continue;
/* find an empty instance array element and use it */
for (idx = 0; idx < INSTANCE_MAX; idx++)
if (!InstancePid[idx]) break;
if (idx >= INSTANCE_MAX)
ErrorExit (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
InstancePid[idx] = LockPid[cnt];
}
if (Debug)
for (idx = 0; idx < INSTANCE_MAX; idx++)
fprintf (stdout, "%d %08x\n", idx, InstancePid[idx]);
}
/*****************************************************************************/
/*
If 'FormatString' is non-NULL it is expected to contain a $FAO formatting
string and the call any required parameters. The resultant string has required
carriage-control added and is stored as a series of lines in a static buffer.
The resulting string will be used as a subject line in the alerting email.
*/
char* ReportSubj
(
char *FormatString,
...
)
{
static int BufferLength,
ItemCount;
static char Buffer [256];
static $DESCRIPTOR (BufferDsc, "");
static $DESCRIPTOR (CommaFaoDsc, ", ");
static $DESCRIPTOR (FaoDsc, "");
int status, argcnt;
unsigned short ShortLength;
unsigned long *vecptr;
unsigned long FaoVector [31+2];
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if (argcnt > 31) ErrorExit (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (Debug)
fprintf (stdout, "ReportSubj() %d |%s|\n", argcnt, FormatString);
if (FormatString)
{
if (!BufferLength)
{
/*********************/
/* prepend some info */
/*********************/
BufferDsc.dsc$a_pointer = Buffer;
BufferDsc.dsc$w_length = sizeof(Buffer)-1;
FaoDsc.dsc$a_pointer = "WOTSUP on !AZ reports ";
FaoDsc.dsc$w_length = strlen(FaoDsc.dsc$a_pointer);
vecptr = FaoVector;
*vecptr++ = SyiNodeName;
*vecptr = 0;
status = sys$faol (&FaoDsc, &ShortLength, &BufferDsc, &FaoVector);
if (VMSnok (status) || status == SS$_BUFFEROVF)
ErrorExit (status, "$FAOL()", FI_LI);
BufferLength += ShortLength;
Buffer[BufferLength] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", Buffer);
}
/*************************/
/* now append the report */
/*************************/
BufferDsc.dsc$a_pointer = Buffer + BufferLength;
BufferDsc.dsc$w_length = sizeof(Buffer)-1 - BufferLength;
if (ItemCount++)
{
status = sys$faol (&CommaFaoDsc, &ShortLength, &BufferDsc);
/* not worried about buffer overflow with the email subject line */
if (VMSnok (status)) ErrorExit (status, "$FAOL()", FI_LI);
BufferLength += ShortLength;
Buffer[BufferLength] = '\0';
}
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 1; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, unsigned long);
va_end (argptr);
*vecptr = 0;
BufferDsc.dsc$a_pointer = Buffer + BufferLength;
BufferDsc.dsc$w_length = sizeof(Buffer)-1 - BufferLength;
FaoDsc.dsc$a_pointer = FormatString;
FaoDsc.dsc$w_length = strlen(FormatString);
status = sys$faol (&FaoDsc, &ShortLength, &BufferDsc, &FaoVector);
/* not worried about buffer overflow with the email subject line */
if (VMSnok (status)) ErrorExit (status, "$FAOL()", FI_LI);
BufferLength += ShortLength;
Buffer[BufferLength] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", Buffer);
return;
}
/************************************/
/* return the built-up subject line */
/************************************/
/* if there is nothing to report then report that! */
if (!BufferLength) "BUGCHECK?";
/* reset subj line (without emptying the to-be returned string) */
BufferLength = 0;
ItemCount = 0;
return (Buffer);
}
/*****************************************************************************/
/*
If 'FormatString' is non-NULL it is expected to contain a $FAO formatting
string and the call any required parameters. The resultant string has required
carriage-control added and is stored as a series of lines in a static buffer.
When 'FormatString' is NULL the buffered text is sent to the OPCOM, Mail and/or
spawn targets. Check the logical names containing the OPCOM, Mail and spawn
targets for the most recent settings (can be changed dynamically without
restarting the utility). If these logical names do not exist fall back to
anything specified at the original command-line.
*/
int ReportLine
(
char *FormatString,
...
)
{
static int BufferLength,
ItemCount;
static char Buffer [2048];
static char *OpcomTextPtr;
static $DESCRIPTOR (BufferDsc, "");
static $DESCRIPTOR (FaoDsc, "");
int status, argcnt,
OpcomTarget;
unsigned short ShortLength;
unsigned long *vecptr;
unsigned long FaoVector [32];
char *cptr,
*MailToPtr,
*SpawnCommandPtr;
char MailTo [256],
SpawnCommand [256];
va_list argptr;
FILE *LogFilePtr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if (argcnt > 31) ErrorExit (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (Debug)
fprintf (stdout, "ReportLine() %d |%s|\n", argcnt, FormatString);
if (FormatString)
{
if (!BufferLength)
{
/****************************************/
/* prepend a leading informational line */
/****************************************/
BufferDsc.dsc$a_pointer = Buffer;
BufferDsc.dsc$w_length = sizeof(Buffer)-1;
FaoDsc.dsc$a_pointer =
"%%%%%%%%%% WOTSUP !%D %%%%%%%%%%%\r\n\
Message from user !AZ on !AZ\r\n\
Over-The-Shoulder (!AZ) reports:";
FaoDsc.dsc$w_length = strlen(FaoDsc.dsc$a_pointer);
vecptr = FaoVector;
*vecptr++ = 0;
*vecptr++ = JpiUserName;
*vecptr++ = SyiNodeName;
*vecptr++ = JpiPrcNam;
*vecptr = 0;
status = sys$faol (&FaoDsc, &ShortLength, &BufferDsc, &FaoVector);
if (VMSnok (status) || status == SS$_BUFFEROVF)
ErrorExit (status, "$FAOL()", FI_LI);
BufferLength += ShortLength;
Buffer[BufferLength] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", Buffer);
/* for OPCOM purposes find the start of the third line */
OpcomTextPtr = Buffer + BufferLength;
while (OpcomTextPtr > Buffer && *OpcomTextPtr != '\n') OpcomTextPtr--;
if (*OpcomTextPtr == '\n') OpcomTextPtr++;
}
/*******************************/
/* now append the line of text */
/*******************************/
BufferDsc.dsc$a_pointer = Buffer + BufferLength;
BufferDsc.dsc$w_length = sizeof(Buffer)-1 - BufferLength;
FaoDsc.dsc$a_pointer = "\r\n!UL. ";
FaoDsc.dsc$w_length = 7;
status = sys$fao (&FaoDsc, &ShortLength, &BufferDsc, ++ItemCount);
if (VMSnok (status) || status == SS$_BUFFEROVF)
ErrorExit (status, "$FAO()", FI_LI);
BufferLength += ShortLength;
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 1; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, unsigned long);
va_end (argptr);
*vecptr++ = 0;
BufferDsc.dsc$a_pointer = Buffer + BufferLength;
BufferDsc.dsc$w_length = sizeof(Buffer)-1 - BufferLength;
FaoDsc.dsc$a_pointer = FormatString;
FaoDsc.dsc$w_length = strlen(FormatString);
status = sys$faol (&FaoDsc, &ShortLength, &BufferDsc, &FaoVector);
if (VMSnok (status) || status == SS$_BUFFEROVF)
ErrorExit (status, "$FAOL()", FI_LI);
BufferLength += ShortLength;
Buffer[BufferLength] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", Buffer);
return;
}
/* if there is nothing to report then just return */
if (!BufferLength) return;
/**********************/
/* get latest targets */
/**********************/
if (cptr = SysTrnLnm2 (WASD_WOTSUP_OPCOM, NULL))
{
OpcomTarget = OpcomTargetOf(cptr);
if (!OpcomTarget) ErrorExit (SS$_BADPARAM, WASD_WOTSUP_OPCOM, FI_LI);
}
else
OpcomTarget = CliOpcomTarget;
if (cptr = SysTrnLnm2 (WASD_WOTSUP_MAIL, MailTo))
{
if (*cptr)
MailToPtr = MailTo;
else
ErrorExit (SS$_BADPARAM, WASD_WOTSUP_MAIL, FI_LI);
}
else
MailToPtr = CliMailToPtr;
if (cptr = SysTrnLnm2 (WASD_WOTSUP_SPAWN, SpawnCommand))
{
while (*cptr && isspace(*cptr)) cptr++;
if (!*cptr) ErrorExit (SS$_BADPARAM, WASD_WOTSUP_SPAWN, FI_LI);
SpawnCommandPtr = SpawnCommand;
}
else
SpawnCommandPtr = CliSpawnCommandPtr;
/*******************/
/* send to targets */
/*******************/
if (OpcomTarget) ReportOpcom (OpcomTarget, "!AZ", OpcomTextPtr);
if (!SysTrnLnm2 (WASD_WOTSUP_SHUSH, NULL))
{
if (MailToPtr)
MailMessage (MailPersonal, MailToPtr, ReportSubj(NULL), Buffer);
/* ensure email subject line is reset regardless of mailing message */
ReportSubj (NULL);
if (SpawnCommandPtr) ReportSpawn (SpawnCommandPtr, Buffer);
}
/* should be called last as it modifies the buffer content */
ReportLogFile (Buffer);
/****************/
/* reset buffer */
/****************/
Buffer[BufferLength=0] = '\0';
ItemCount = 0;
OpcomTextPtr = NULL;
}
/*****************************************************************************/
/*
Write the specified text to any log file. Modifies the text!
*/
int ReportLogFile (char *Buffer)
{
int status;
char *cptr, *sptr,
*LogFileNamePtr;
char LogFileName [256];
FILE *LogFilePtr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ReportLogFile()\n");
if (SysTrnLnm2 (WASD_WOTSUP_LOG, LogFileName))
LogFileNamePtr = LogFileName;
else
LogFileNamePtr = CliLogPtr;
if (!LogFileNamePtr) return;
LogFilePtr = fopen (LogFileNamePtr, "a", "shr=put");
if (LogFilePtr)
{
/* remove the <CR> from <CR><LF>s before writing to the log file */
for (cptr = sptr = Buffer; *cptr; *sptr++ = *cptr++)
if (*(unsigned short*)cptr == '\r\n') cptr++;
*sptr = '\0';
fprintf (LogFilePtr, "%s\n\n", Buffer);
fclose (LogFilePtr);
}
else
{
status = vaxc$errno;
ReportOpcom (DefaultOpcomTarget,
"Over-The-Shoulder (!AZ) reports:\r\n\
failed to open log file !AZ, %X!8XL (!AZ)",
JpiPrcNam, LogFileNamePtr, status, SysGetMsg(status));
}
}
/*****************************************************************************/
/*
Get the HTTPd server data from its global section.
Data is written by UpdateGlobalSection() in [SRC.HTTPD]SUPPORT.C module.
*/
int MapGlobalSection ()
{
/* system global section, map into first available virtual address */
static int MapFlags = SEC$M_SYSGBL | SEC$M_EXPREG;
/* it is recommended to map into any virtual address in the region (P0) */
static unsigned long InAddr [2] = { 0x200, 0x200 };
static char HttpdGblSecName [32];
static $DESCRIPTOR (HttpdGblSecNameDsc, HttpdGblSecName);
static $DESCRIPTOR (HttpdGblSecNameFaoDsc, GBLSEC_NAME_FAO);
int status,
ByteSize,
PageSize;
unsigned short ShortLength;
unsigned long RetAddr [2];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MapGlobalSection()\n");
if (HttpdGblSecPtr) return (SS$_NORMAL);
/* only need to map it the one time */
sys$fao (&HttpdGblSecNameFaoDsc, &ShortLength, &HttpdGblSecNameDsc,
HTTPD_NAME, HTTPD_GBLSEC_VERSION_NUMBER,
InstanceGroupNumber, "HTTPD");
HttpdGblSecNameDsc.dsc$w_length = ShortLength;
if (Debug) fprintf (stdout, "|%s|\n", HttpdGblSecName);
/* map the specified global section */
status = sys$mgblsc (&InAddr, &RetAddr, 0, MapFlags, &HttpdGblSecNameDsc,
0, 0);
if (Debug)
fprintf (stdout, "sys$mgblsc() %%X%08.08X begin:%d end:%d\n",
status, RetAddr[0], RetAddr[1]);
if (VMSok (status))
{
ByteSize = (RetAddr[1]+1) - RetAddr[0];
PageSize = (RetAddr[1]+1) - RetAddr[0] >> 9;
HttpdGblSecPtr = (HTTPD_GBLSEC*)RetAddr[0];
HttpdGblSecLength = ByteSize;
}
else
{
HttpdGblSecPtr = NULL;
HttpdGblSecLength = ByteSize = PageSize = 0;
if (status == SS$_NOSUCHSEC)
{
fprintf (stdout,
"%%%s-E-SERVER, no such server!\n\
-SYSTEM-E-NOSUCHSEC, no such (global) section\n",
Utility);
exit (SS$_NOSUCHSEC | STS$M_INHIB_MSG);
}
else
exit (status);
}
if (HttpdGblSecPtr->GblSecVersion != HTTPD_GBLSEC_VERSION_NUMBER ||
HttpdGblSecPtr->GblSecLength != sizeof(HTTPD_GBLSEC))
{
fprintf (stdout,
"%%%s-E-GBLSEC_MISMATCH, global section mismatch, rebuild WOTSUP?\n",
Utility);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Use the VMS callable mail interface to create and send a VMS mail message.
'To' can be a list of comma-separated addresses. 'Subject' is a
null-terminated string. 'Body' is a null-terminated string of '\n'-separated
lines of plain text. Just truncates anything longer than 255 characters (body
excluded, body records included)!
*/
int MailMessage
(
char *PersonalName,
char *To,
char *Subject,
char *Body
)
{
int status;
unsigned long SendContext = 0;
char *cptr, *sptr;
struct {
short int buf_len;
short int item;
void *buf_addr;
unsigned short *ret_len;
}
BodyPartItem [] =
{
{ 0, MAIL$_SEND_RECORD, 0, 0 },
{ 0, MAIL$_NOSIGNAL, 0, 0 },
{0,0,0,0}
},
PersonalNameItem [] =
{
{ 0, MAIL$_SEND_PERS_NAME, PersonalName, 0 },
{ 0, MAIL$_NOSIGNAL, 0, 0 },
{0,0,0,0}
},
SendUserNameItem [] =
{
{ 0, MAIL$_SEND_USERNAME, 0, 0 },
{ 0, MAIL$_NOSIGNAL, 0, 0 },
{0,0,0,0}
},
SubjectItem [] =
{
{ 0, MAIL$_SEND_SUBJECT, Subject, 0 },
{ 0, MAIL$_NOSIGNAL, 0, 0 },
{0,0,0,0}
},
NoSignalItem [] =
{
{ 0, MAIL$_NOSIGNAL, 0, 0 },
{0,0,0,0}
},
NullItem = {0,0,0,0};
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "MailMessage() |%s|\n|%s|\n|%s|\n",
PersonalName, To, Subject);
if (PersonalName != NULL && PersonalName[0])
{
PersonalNameItem[0].buf_len = strlen(PersonalName);
if (PersonalNameItem[0].buf_len > 255) PersonalNameItem[0].buf_len = 255;
status = mail$send_begin (&SendContext, &PersonalNameItem, &NullItem);
}
else
status = mail$send_begin (&SendContext, &NoSignalItem, &NullItem);
if (VMSnok (status)) ErrorExit (status, "MAIL$SEND_BEGIN", FI_LI);
/* a single, or multiple comma-separated addresses */
cptr = To;
while (*cptr)
{
if (!*cptr) break;
sptr = cptr;
while (*cptr && *cptr != ',') cptr++;
if (*cptr) *cptr++ = '\0';
SendUserNameItem[0].buf_addr = sptr;
SendUserNameItem[0].buf_len = strlen(sptr);
if (SendUserNameItem[0].buf_len > 255) SendUserNameItem[0].buf_len = 255;
if (Debug)
fprintf (stdout, "address |%s|\n",
(char*)SendUserNameItem[0].buf_addr);
status = mail$send_add_address (&SendContext, &SendUserNameItem,
&NullItem);
if (VMSnok (status)) ErrorExit (status, sptr, FI_LI);
}
SubjectItem[0].buf_len = strlen(Subject);
if (SubjectItem[0].buf_len > 255) SubjectItem[0].buf_len = 255;
status = mail$send_add_attribute (&SendContext, &SubjectItem, &NullItem);
if (VMSnok (status)) ErrorExit (status, "MAIL$SEND_ADD_ATTRIBUTE", FI_LI);
cptr = Body;
while (*cptr)
{
BodyPartItem[0].buf_addr = cptr;
while (*cptr && *cptr != '\n') cptr++;
BodyPartItem[0].buf_len = cptr - (char*)BodyPartItem[0].buf_addr;
if (BodyPartItem[0].buf_len > 255) BodyPartItem[0].buf_len = 255;
if (*cptr) cptr++;
status = mail$send_add_bodypart (&SendContext, &BodyPartItem, &NullItem);
if (VMSnok (status)) ErrorExit (status, "MAIL$SEND_ADD_BODYPART", FI_LI);
}
status = mail$send_message (&SendContext, &NoSignalItem, &NoSignalItem);
if (VMSnok (status)) ErrorExit (status, "MAIL$SEND_MESSAGE", FI_LI);
mail$send_end (&SendContext, &NullItem, &NullItem);
return (SS$_NORMAL);
}
/****************************************************************************/
/*
$FAO formatted print statement to OPCOM. A fixed-size, internal buffer of 986
bytes maximum is used and the result output as an OPCOM message.
*/
int ReportOpcom
(
int OpcomTarget,
char *FormatString,
...
)
{
static $DESCRIPTOR (FaoDsc, "");
static $DESCRIPTOR (OpcomDsc, "");
static $DESCRIPTOR (OpcomMsgDsc, "");
int status,
argcnt;
unsigned short ShortLength;
unsigned long *vecptr;
unsigned long FaoVector [31+1];
va_list argptr;
struct
{
unsigned long TargetType;
unsigned long RequestId;
char MsgText [986+1];
} OpcomMsg;
/*********/
/* begin */
/*********/
va_count (argcnt);
if (Debug)
fprintf (stdout, "ReportOpcom() |%s| %d\n", FormatString, argcnt);
if (argcnt > 31+2) exit (SS$_OVRMAXARG);
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 2; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, unsigned long);
va_end (argptr);
*vecptr = 0;
FaoDsc.dsc$a_pointer = FormatString;
FaoDsc.dsc$w_length = strlen(FormatString);
OpcomMsgDsc.dsc$a_pointer = &OpcomMsg.MsgText;
OpcomMsgDsc.dsc$w_length = sizeof(OpcomMsg.MsgText)-1;
status = sys$faol (&FaoDsc, &ShortLength, &OpcomMsgDsc, &FaoVector);
if (VMSnok (status)) ErrorExit (status, "$FAOL()", FI_LI);
OpcomMsg.MsgText[ShortLength] = '\0';
if (Debug) fprintf (stdout, "%d |%s|\n", ShortLength, OpcomMsg.MsgText);
OpcomMsg.TargetType = OPC$_RQ_RQST + ((OpcomTarget & 0xffffff) << 8);
OpcomMsg.RequestId = 0;
OpcomDsc.dsc$a_pointer = &OpcomMsg;
OpcomDsc.dsc$w_length = ShortLength + 8;
status = sys$sndopr (&OpcomDsc, 0);
if (VMSnok (status)) ErrorExit (status, "$SNDOPR()", FI_LI);
return (status);
}
/*****************************************************************************/
/*
Return an integer value representing the OPCOM target string.
Zero indicates an error.
*/
int OpcomTargetOf (char *cptr)
{
int OpcomTarget;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "OpcomTargetOf() |%s|\n", cptr);
OpcomTarget = 0;
while (*cptr)
{
while (*cptr == '(' || *cptr == ',' || *cptr == ')') cptr++;
if (!*cptr) break;
if (strsame (cptr, "ALL", 3))
OpcomTarget = 0xffffffff;
else
if (strsame (cptr, "CENTRAL", 7))
OpcomTarget |= OPC$M_OPR_CENTRAL;
else
if (strsame (cptr, "PRINTER", 7))
OpcomTarget |= OPC$M_OPR_PRINTER;
else
if (strsame (cptr, "TAPES", 5))
OpcomTarget |= OPC$M_OPR_TAPES;
else
if (strsame (cptr, "DISKS", 5))
OpcomTarget |= OPC$M_OPR_DISKS;
else
if (strsame (cptr, "DEVICES", 7))
OpcomTarget |= OPC$M_OPR_DEVICES;
else
if (strsame (cptr, "CARDS", 5))
OpcomTarget |= OPC$M_OPR_CARDS;
else
if (strsame (cptr, "NETWORK", 7))
OpcomTarget |= OPC$M_OPR_NETWORK;
else
if (strsame (cptr, "CLUSTER", 7))
OpcomTarget |= OPC$M_OPR_CLUSTER;
else
if (strsame (cptr, "SECURITY", 8))
OpcomTarget |= OPC$M_OPR_SECURITY;
else
if (strsame (cptr, "REPLY", 5))
OpcomTarget |= OPC$M_OPR_REPLY;
else
if (strsame (cptr, "SOFTWARE", 8))
OpcomTarget |= OPC$M_OPR_SOFTWARE;
else
if (strsame (cptr, "LICENSE", 7))
OpcomTarget |= OPC$M_OPR_LICENSE;
else
if (strsame (cptr, "OPER2", 5))
OpcomTarget |= OPC$M_OPR_USER2;
else
if (strsame (cptr, "OPER3", 5))
OpcomTarget |= OPC$M_OPR_USER3;
else
if (strsame (cptr, "OPER4", 5))
OpcomTarget |= OPC$M_OPR_USER4;
else
if (strsame (cptr, "OPER5", 5))
OpcomTarget |= OPC$M_OPR_USER5;
else
if (strsame (cptr, "OPER6", 5))
OpcomTarget |= OPC$M_OPR_USER6;
else
if (strsame (cptr, "OPER7", 5))
OpcomTarget |= OPC$M_OPR_USER7;
else
if (strsame (cptr, "OPER8", 5))
OpcomTarget |= OPC$M_OPR_USER8;
else
if (strsame (cptr, "OPER9", 5))
OpcomTarget |= OPC$M_OPR_USER9;
else
if (strsame (cptr, "OPER10", 6))
OpcomTarget |= OPC$M_OPR_USER10;
else
if (strsame (cptr, "OPER11", 6))
OpcomTarget |= OPC$M_OPR_USER11;
else
if (strsame (cptr, "OPER12", 6))
OpcomTarget |= OPC$M_OPR_USER12;
else
/* must be here after OPER1n for the obvious reason */
if (strsame (cptr, "OPER1", 5))
OpcomTarget |= OPC$M_OPR_USER1;
else
return (0);
while (isalnum(*cptr)) cptr++;
}
if (Debug) fprintf (stdout, "%08.08X\n", OpcomTarget);
return (OpcomTarget);
}
/*****************************************************************************/
/*
Parse and set the /QUOTA=.. qualifier from the command-line. It can be
followed by a single integer, and/or one or more keywords for ASTLM, BIOLM,
etc, followed by an integer value for the invidual quota. For example:
/QUOTA=(30,BYTLM:20,PGFLQUO:50).
*/
ProcessQuotaOf (char *cptr)
{
int status, percent;
int *QuotaPtr;
char *sptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ProcessQuotaOf() |%s|\n", cptr);
while (*cptr)
{
while (*cptr == '(' || *cptr == ',' || *cptr == ')') cptr++;
if (!*cptr) break;
if (isdigit(*cptr))
QuotaPtr = NULL;
else
if (strsame (cptr, "ASTLM:", 6))
QuotaPtr = &PercentMinAst;
else
if (strsame (cptr, "BIOLM:", 6))
QuotaPtr = &PercentMinBio;
else
if (strsame (cptr, "BYTLM:", 6))
QuotaPtr = &PercentMinByt;
else
if (strsame (cptr, "DIOLM:", 6))
QuotaPtr = &PercentMinDio;
else
if (strsame (cptr, "ENQLM:", 6))
QuotaPtr = &PercentMinEnq;
else
if (strsame (cptr, "FILLM:", 6))
QuotaPtr = &PercentMinFil;
else
if (strsame (cptr, "PGFLQUO:", 8))
QuotaPtr = &PercentMinPg;
else
if (strsame (cptr, "TQLM:", 5))
QuotaPtr = &PercentMinTq;
else
{
for (sptr = cptr; *sptr && *sptr != ',' && *sptr != ')'; sptr++);
*sptr = '\0';
fprintf (stdout, "%%%s-E-UNRKEY, \"%s\" is an unrecognised keyword\n",
Utility, cptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
while (*cptr && !isdigit(*cptr)) cptr++;
if (*cptr == ':') cptr++;
percent = atoi(cptr);
if (percent <= 0 || percent > 99)
{
for (sptr = cptr; *sptr && *sptr != ',' && *sptr != ')'; sptr++);
*sptr = '\0';
fprintf (stdout, "%%%s-E-QUOTA, \"%s\" must be >= 1 percent <= 99\n",
Utility, cptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
if (QuotaPtr)
*QuotaPtr = percent;
else
{
PercentMinAst = PercentMinBio = PercentMinByt =
PercentMinDio = PercentMinEnq = PercentMinFil =
PercentMinTq = PercentMinPg = percent;
}
while (isdigit(*cptr)) cptr++;
}
}
/*****************************************************************************/
/*
Using the CRTL system() call spawn a subprocess to perform the DCL command
provided. A double-quote delimited parameter is provided on the command-line
that supplies the report string.
*/
int ReportSpawn
(
char *DclCommand,
char *ReportText
)
{
int status;
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "ReportSpawn() |%s|%s|\n", DclCommand, ReportText);
SysCreLnm (WASD_WOTSUP_REPORT, ReportText);
status = system (DclCommand);
if (VMSnok (status)) ErrorExit (status, "system()", FI_LI);
}
/*****************************************************************************/
/*
Translate a logical name using LNM$FILE_DEV. Return a pointer to the value
string, or NULL if the name does not exist. If 'LogValue' is supplied the
logical name is translated into that (assumed to be large enough), otherwise
it's translated into an internal static buffer.
*/
char* SysTrnLnm2
(
char *LogName,
char *LogValue
)
{
static unsigned short ShortLength;
static char StaticLogValue [256];
static $DESCRIPTOR (LogNameDsc, "");
static $DESCRIPTOR (LnmFileDevDsc, "LNM$FILE_DEV");
static struct {
short int buf_len;
short int item;
void *buf_addr;
unsigned short *ret_len;
} LnmItems [] =
{
{ 255, LNM$_STRING, 0, &ShortLength },
{ 0,0,0,0 }
};
int status;
char *cptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SysTrnLnm2() |%s|\n", LogName);
LogNameDsc.dsc$a_pointer = LogName;
LogNameDsc.dsc$w_length = strlen(LogName);
if (LogValue)
cptr = LnmItems[0].buf_addr = LogValue;
else
cptr = LnmItems[0].buf_addr = StaticLogValue;
status = sys$trnlnm (0, &LnmFileDevDsc, &LogNameDsc, 0, &LnmItems);
if (Debug) fprintf (stdout, "sys$trnlnm() %%X%08.08X\n", status);
if (!(status & 1))
{
if (Debug) fprintf (stdout, "|(null)|\n");
return (NULL);
}
cptr[ShortLength] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", cptr);
return (cptr);
}
/*****************************************************************************/
/*
Create a logical name in the system table. If that name contains <CR><LF>
delimtted lines the create a translation index for each (0..127). Used to pass
multi-line values to a spawned reporting agent.
*/
SysCreLnm
(
char *LogName,
char *LogValue
)
{
#define LNM_INDEX_MAX 127
static $DESCRIPTOR (LogTableDsc, "LNM$SYSTEM");
static $DESCRIPTOR (LogNameDsc, "");
int idx, status;
char *cptr, *sptr;
struct {
short int buf_len;
short int item;
unsigned char *buf_addr;
unsigned short *ret_len;
}
CreLnmItem [LNM_INDEX_MAX+1];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SysCreLnm() |%s|\n", LogName, LogValue);
idx = 0;
cptr = LogValue;
while (*cptr && idx < LNM_INDEX_MAX)
{
for (sptr = cptr; *sptr && *(unsigned short*)sptr != '\r\n'; sptr++);
CreLnmItem[idx].item = LNM$_STRING;
CreLnmItem[idx].buf_addr = (unsigned char*)cptr;
CreLnmItem[idx++].buf_len = sptr - cptr;
if (Debug) fprintf (stdout, "|%.*s|\n", sptr-cptr, cptr);
cptr = sptr;
if (*(unsigned short*)cptr == '\r\n') cptr += 2;
}
memset (&CreLnmItem[idx], 0, sizeof(CreLnmItem[idx]));
LogNameDsc.dsc$a_pointer = LogName;
LogNameDsc.dsc$w_length = strlen(LogName);
status = sys$crelnm (0, &LogTableDsc, &LogNameDsc, 0, &CreLnmItem);
if (VMSnok (status)) ErrorExit (status, "$CRELNM()", FI_LI);
}
/*****************************************************************************/
/*
Provide some extra information (particularly source module and line) when the
image exits. Needs to be explicitly called (not an exit handler).
*/
ErrorExit
(
int StatusValue,
char *Explanation,
char *SourceCodeModule,
int SourceCodeLine
)
{
/*********/
/* begin */
/*********/
fprintf (stdout,
"%%%s-F-EXIT, %s (%%X%08.08X)\n\
-%s-I-WHERE, module:%s line:%d\n",
Utility, Explanation, StatusValue,
Utility, SourceCodeModule, SourceCodeLine);
_exit (StatusValue & 0x7fffffff);
}
/*****************************************************************************/
/*
Return a pointer to the message string corresponding to the supplied VMS status
value.
*/
char* SysGetMsg (int VmsStatus)
{
static char Message [256];
int status;
short int Length;
$DESCRIPTOR (MessageDsc, Message);
/*********/
/* begin */
/*********/
Message[0] = '\0';
if (VmsStatus)
{
/* text component only */
sys$getmsg (VmsStatus, &Length, &MessageDsc, 0xe, 0);
Message[Length] = '\0';
}
if (Message[0])
return (Message);
else
return ("(internal error)");
}
/*****************************************************************************/
/*
Get "command-line" parameters, whether from the command-line or from a
configuration logical containing the equivalent.
*/
GetParameters ()
{
static char CommandLine [256];
static unsigned long Flags = 0;
int status;
unsigned short Length;
char ch;
char *aptr, *cptr, *clptr, *sptr, *zptr;
$DESCRIPTOR (CommandLineDsc, CommandLine);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "GetParameters()\n");
if (JpiMode == JPI$K_INTERACTIVE)
clptr = NULL;
else
clptr = getenv ("WASD_WOTSUP_PARAM");
if (!clptr)
{
/* get the entire command line following the verb */
if (VMSnok (status =
lib$get_foreign (&CommandLineDsc, 0, &Length, &Flags)))
exit (status);
(clptr = CommandLine)[Length] = '\0';
}
CommandLinePtr = calloc (1, strlen(clptr)+1);
strcpy (CommandLinePtr, clptr);
aptr = NULL;
ch = *clptr;
for (;;)
{
if (aptr && *aptr == '/') *aptr = '\0';
if (!ch) break;
*clptr = ch;
if (Debug) fprintf (stdout, "clptr |%s|\n", clptr);
while (*clptr && isspace(*clptr)) *clptr++ = '\0';
aptr = clptr;
if (*clptr == '/') clptr++;
while (*clptr && !isspace (*clptr) && *clptr != '/')
{
if (*clptr != '\"')
{
clptr++;
continue;
}
cptr = clptr;
clptr++;
while (*clptr)
{
if (*clptr == '\"')
if (*(clptr+1) == '\"')
clptr++;
else
break;
*cptr++ = *clptr++;
}
*cptr = '\0';
if (*clptr) clptr++;
}
ch = *clptr;
if (*clptr) *clptr = '\0';
if (Debug) fprintf (stdout, "aptr |%s|\n", aptr);
if (!*aptr) continue;
if (strsame (aptr, "/CHECK", -1))
{
DoCheck = TRUE;
continue;
}
if (strsame (aptr, "/DBUG", -1))
{
Debug = TRUE;
continue;
}
if (strsame (aptr, "/DO=", 4))
{
unsigned long Pid;
cptr = SysTrnLnm2 (WASD_WOTSUP_PID, NULL);
if (!cptr) exit (SS$_NONEXPR);
Pid = strtoul (cptr, NULL, 16);
if (!Pid) exit (SS$_NONEXPR);
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
if (strsame (cptr, "DELETE", -1))
exit (sys$delprc (&Pid, 0));
if (strsame (cptr, "EXIT", -1))
exit (sys$forcex (&Pid, 0, SS$_FORCEX));
if (strsame (cptr, "RESTART", -1))
exit (sys$forcex (&Pid, 0, SS$_NORMAL));
fprintf (stdout, "%%%s-E-UNRKEY, \"%s\" is an unrecognised keyword\n",
Utility, cptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
continue;
}
if (strsame (aptr, "/EXIT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
SecondsAfterExit = atoi(cptr);
if (SecondsAfterExit <= 0 || SecondsAfterExit > 300)
{
fprintf (stdout, "%%%s-E-EXIT, must be >= 1 seconds <= 300\n",
Utility);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
continue;
}
if (strsame (aptr, "/HELP", 4))
{
ShowHelp ();
exit (SS$_NORMAL);
}
if (strsame (aptr, "/HTTP=", 4))
{
int CodeDelta, CodeNumber;
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
while (*cptr)
{
while (*cptr == '(' || *cptr == ',' || *cptr == ')') cptr++;
if (!*cptr) break;
CodeNumber = atoi(cptr);
while (isdigit(*cptr)) cptr++;
if (*cptr) cptr++;
CodeDelta = atoi(cptr);
if (CodeDelta < 0)
{
fprintf (stdout, "%%%s-E-HTTP, delta must be > 0\n", Utility);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
while (isdigit(*cptr)) cptr++;
if ((CodeNumber >= 0 && CodeNumber <= 5) || CodeNumber == 403)
{
/* HTTP status code group */
if (CodeNumber == 403)
CliStatusGroup403Delta = CodeDelta;
else
CliStatusGroupDelta[CodeNumber] = CodeDelta;
}
else
if (CodeNumber >= 100 && CodeNumber <= 505)
{
/* individual HTTP status code */
if (!SetHttpStatusCode (CodeNumber, CodeDelta))
{
fprintf (stdout, "%%%s-E-HTTP, code %d unknown\n",
CodeNumber, Utility);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
/* get the code group from the number and reset the group */
CodeNumber /= 100;
CliStatusGroupDelta[CodeNumber] = 0;
}
else
{
fprintf (stdout,
"%%%s-E-HTTP, must be >= 0 and <= 5 or >= 100 and <= 505\n",
Utility);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
}
continue;
}
if (strsame (aptr, "/INTERVAL=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
IntervalSeconds = atoi(cptr);
if (IntervalSeconds <= 0 || IntervalSeconds > 60)
{
fprintf (stdout, "%%%s-E-INTERVAL, must be >= 1 seconds <= 60\n",
Utility, cptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
continue;
}
if (strsame (aptr, "/LOG=", 4))
{
CliLogPtr = "SYS$OUTPUT";
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (!*cptr) continue;
cptr++;
CliLogPtr = cptr;
continue;
}
if (strsame (aptr, "/MAIL=", 4))
{
CliMailToPtr = "SYSTEM";
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (!*cptr) continue;
cptr++;
if (*cptr == '(') cptr++;
CliMailToPtr = cptr;
while (*cptr) cptr++;
if (*(cptr-1) == ')') *(cptr-1) = '\0';
continue;
}
if (strsame (aptr, "/OPCOM=", 4))
{
CliOpcomTarget = DefaultOpcomTarget;
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (!*cptr) continue;
cptr++;
CliOpcomTarget = OpcomTargetOf(cptr);
if (!CliOpcomTarget)
{
fprintf (stdout, "%%%s-E-UNRKEY, \"%s\" is an unrecognised keyword\n",
Utility, cptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
continue;
}
if (strsame (aptr, "/QUIET=", 4))
{
QuietSeconds = DEFAULT_QUIET_SECONDS;
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (!*cptr) continue;
cptr++;
QuietSeconds = atoi(cptr);
if (QuietSeconds <= 0 || QuietSeconds < IntervalSeconds)
{
fprintf (stdout, "%%%s-E-QUIET, must be >= /INTERVAL\n",
Utility, cptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
continue;
}
if (strsame (aptr, "/QUOTA=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
ProcessQuotaOf (cptr);
continue;
}
if (strsame (aptr, "/SPAWN=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
if (!*cptr)
{
fprintf (stdout, "%%%s-W-VALREQ, missing qualifier or keyword value\n \\%s\\\n",
Utility, aptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
CliSpawnCommandPtr = cptr;
continue;
}
if (*aptr != '/')
{
fprintf (stdout, "%%%s-E-MAXPARM, too many parameters\n \\%s\\\n",
Utility, aptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
else
{
fprintf (stdout, "%%%s-E-IVQUAL, unrecognized qualifier\n \\%s\\\n",
Utility, aptr+1);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
}
}
/*****************************************************************************/
/*
Set the delta against the HTTP status code number.
Based on array elements from [SRC.HTTPD]REQUEST.C RequestHttpStatusCode().
*/
BOOL SetHttpStatusCode
(
int CodeNumber,
int CodeDelta
)
{
int idx;
/*********/
/* begin */
/*********/
switch (CodeNumber)
{
case 100 : idx = 1; break;
case 101 : idx = 2; break;
case 200 : idx = 3; break;
case 201 : idx = 4; break;
case 202 : idx = 5; break;
case 203 : idx = 6; break;
case 204 : idx = 7; break;
case 205 : idx = 8; break;
case 206 : idx = 9; break;
case 300 : idx = 10; break;
case 301 : idx = 11; break;
case 302 : idx = 12; break;
case 303 : idx = 13; break;
case 304 : idx = 14; break;
case 305 : idx = 15; break;
case 306 : idx = 16; break;
case 307 : idx = 17; break;
case 400 : idx = 18; break;
case 401 : idx = 19; break;
case 402 : idx = 20; break;
case 403 : idx = 21; break;
case 404 : idx = 22; break;
case 405 : idx = 23; break;
case 406 : idx = 24; break;
case 407 : idx = 25; break;
case 408 : idx = 26; break;
case 409 : idx = 27; break;
case 410 : idx = 28; break;
case 411 : idx = 29; break;
case 412 : idx = 30; break;
case 413 : idx = 31; break;
case 414 : idx = 32; break;
case 415 : idx = 33; break;
case 416 : idx = 34; break;
case 417 : idx = 35; break;
case 500 : idx = 36; break;
case 501 : idx = 37; break;
case 502 : idx = 38; break;
case 503 : idx = 39; break;
case 504 : idx = 40; break;
case 505 : idx = 41; break;
default : return (FALSE);
}
CliStatusCodeNumber[idx] = CodeNumber;
CliStatusCountDelta[idx] = CodeDelta;
return (TRUE);
}
/****************************************************************************/
/*
*/
int ShowHelp ()
{
fprintf (stdout,
"%%%s-I-HELP, usage for the WASD Over-The-Shoulder Uptime Picket (%s)\n\
\n\
The WOTSUP utility is designed to look at WASD in a production environment,\n\
over it's shoulder so-to-speak, to alert operations staff of conditions which\n\
might cause that production to be adversely impacted. Triggers include server\n\
image exit and/or startup, percentage thresholds on process quotas, rates of\n\
HTTP status counter change, maximum period without request processing. Alert\n\
reports are delivered via OPCOM message and/or email and/or a custom DCL\n\
command executed in a spawned subprocess, and/or log file.\n\
\n\
$ WOTSUP [qualifiers..] [parameters..]\n\
\n\
/CHECK /DO=<keyword> /EXIT[=<type>] /HELP /HTTP=(<number>:<delta>[,..])\n\
/INTERVAL=<seconds> /LOG=<filename> /MAIL[=<address>(es)] /OPCOM[=<target>]\n\
/QUIET[=<seconds>] /QUOTA[=<percent>] /SPAWN=<DCL-command>\n\
\n\
Usage examples:\n\
\n\
$ WOTSUP /DO=RESTART\n\
$ WOTSUP /OPCOM=OPER12 /MAIL=OPERATOR /CHECK\n\
$ WOTSUP /QUOTA=20 /HTTP=5:20 /OPCOM /MAIL=OPERATOR /SPAWN=@SUPPORT:WOTSUP.COM\n\
\n",
Utility, SOFTWAREID);
return (SS$_NORMAL);
}
/****************************************************************************/
/*
Does a case-insensitive, character-by-character string compare and returns
true if two strings are the same, or false if not. If a maximum number of
characters are specified only those will be compared, if the entire strings
should be compared then specify the number of characters as 0.
*/
BOOL strsame
(
char *sptr1,
char *sptr2,
int count
)
{
while (*sptr1 && *sptr2)
{
if (toupper (*sptr1++) != toupper (*sptr2++)) return (FALSE);
if (count)
if (!--count) return (TRUE);
}
if (*sptr1 || *sptr2)
return (FALSE);
else
return (TRUE);
}
/*****************************************************************************/