[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
[1230]
[1231]
[1232]
[1233]
[1234]
[1235]
[1236]
[1237]
[1238]
[1239]
[1240]
[1241]
[1242]
[1243]
[1244]
[1245]
[1246]
[1247]
[1248]
[1249]
[1250]
[1251]
[1252]
[1253]
[1254]
[1255]
[1256]
[1257]
[1258]
[1259]
[1260]
[1261]
[1262]
[1263]
[1264]
[1265]
[1266]
[1267]
[1268]
[1269]
[1270]
[1271]
[1272]
[1273]
[1274]
[1275]
[1276]
[1277]
[1278]
[1279]
[1280]
[1281]
[1282]
[1283]
[1284]
[1285]
[1286]
[1287]
[1288]
[1289]
[1290]
[1291]
[1292]
[1293]
[1294]
[1295]
[1296]
[1297]
[1298]
[1299]
[1300]
[1301]
[1302]
[1303]
[1304]
[1305]
[1306]
[1307]
[1308]
[1309]
[1310]
[1311]
[1312]
[1313]
[1314]
[1315]
[1316]
[1317]
[1318]
[1319]
[1320]
[1321]
[1322]
[1323]
[1324]
[1325]
[1326]
[1327]
[1328]
[1329]
[1330]
[1331]
[1332]
[1333]
[1334]
[1335]
[1336]
[1337]
[1338]
[1339]
[1340]
[1341]
[1342]
[1343]
[1344]
[1345]
[1346]
[1347]
[1348]
[1349]
[1350]
[1351]
[1352]
[1353]
[1354]
[1355]
[1356]
[1357]
[1358]
[1359]
[1360]
[1361]
[1362]
[1363]
[1364]
[1365]
[1366]
[1367]
[1368]
[1369]
[1370]
[1371]
[1372]
[1373]
[1374]
[1375]
[1376]
[1377]
[1378]
[1379]
[1380]
[1381]
[1382]
[1383]
[1384]
[1385]
[1386]
[1387]
[1388]
[1389]
[1390]
[1391]
[1392]
[1393]
[1394]
[1395]
[1396]
[1397]
[1398]
[1399]
[1400]
[1401]
[1402]
[1403]
[1404]
[1405]
[1406]
[1407]
[1408]
[1409]
[1410]
[1411]
[1412]
[1413]
[1414]
[1415]
[1416]
[1417]
[1418]
[1419]
[1420]
[1421]
[1422]
[1423]
[1424]
[1425]
[1426]
[1427]
[1428]
[1429]
[1430]
[1431]
[1432]
[1433]
[1434]
[1435]
[1436]
[1437]
[1438]
[1439]
[1440]
[1441]
[1442]
[1443]
[1444]
[1445]
[1446]
[1447]
[1448]
[1449]
[1450]
[1451]
[1452]
[1453]
[1454]
[1455]
[1456]
[1457]
[1458]
[1459]
[1460]
[1461]
[1462]
[1463]
[1464]
[1465]
[1466]
[1467]
[1468]
[1469]
[1470]
[1471]
[1472]
[1473]
[1474]
[1475]
[1476]
[1477]
[1478]
[1479]
[1480]
[1481]
[1482]
[1483]
[1484]
[1485]
[1486]
[1487]
[1488]
[1489]
[1490]
[1491]
[1492]
[1493]
[1494]
[1495]
[1496]
[1497]
[1498]
[1499]
[1500]
[1501]
[1502]
[1503]
[1504]
[1505]
[1506]
[1507]
[1508]
[1509]
[1510]
[1511]
[1512]
[1513]
[1514]
[1515]
[1516]
[1517]
[1518]
[1519]
[1520]
[1521]
[1522]
[1523]
[1524]
[1525]
[1526]
[1527]
[1528]
[1529]
[1530]
[1531]
[1532]
[1533]
[1534]
[1535]
[1536]
[1537]
[1538]
[1539]
[1540]
[1541]
[1542]
[1543]
[1544]
[1545]
[1546]
[1547]
[1548]
[1549]
[1550]
[1551]
[1552]
[1553]
[1554]
[1555]
[1556]
[1557]
[1558]
[1559]
[1560]
[1561]
[1562]
[1563]
[1564]
[1565]
[1566]
[1567]
[1568]
[1569]
[1570]
[1571]
[1572]
[1573]
[1574]
[1575]
[1576]
[1577]
[1578]
[1579]
[1580]
[1581]
[1582]
[1583]
[1584]
[1585]
[1586]
[1587]
[1588]
[1589]
[1590]
[1591]
[1592]
[1593]
[1594]
[1595]
[1596]
[1597]
[1598]
[1599]
[1600]
[1601]
[1602]
[1603]
[1604]
[1605]
[1606]
[1607]
[1608]
[1609]
[1610]
[1611]
[1612]
[1613]
[1614]
[1615]
[1616]
[1617]
[1618]
[1619]
[1620]
[1621]
[1622]
[1623]
[1624]
[1625]
[1626]
[1627]
[1628]
[1629]
[1630]
[1631]
[1632]
[1633]
[1634]
[1635]
[1636]
[1637]
[1638]
[1639]
[1640]
[1641]
[1642]
[1643]
[1644]
[1645]
[1646]
[1647]
[1648]
[1649]
[1650]
[1651]
[1652]
[1653]
[1654]
[1655]
[1656]
[1657]
[1658]
[1659]
[1660]
[1661]
[1662]
[1663]
[1664]
[1665]
[1666]
[1667]
[1668]
[1669]
[1670]
[1671]
[1672]
[1673]
[1674]
[1675]
[1676]
[1677]
[1678]
[1679]
[1680]
[1681]
[1682]
[1683]
[1684]
[1685]
[1686]
[1687]
[1688]
[1689]
[1690]
[1691]
[1692]
[1693]
[1694]
[1695]
[1696]
[1697]
[1698]
[1699]
[1700]
[1701]
[1702]
[1703]
[1704]
[1705]
[1706]
[1707]
[1708]
[1709]
[1710]
[1711]
[1712]
[1713]
[1714]
[1715]
[1716]
[1717]
[1718]
[1719]
[1720]
[1721]
[1722]
[1723]
[1724]
[1725]
[1726]
[1727]
[1728]
[1729]
[1730]
[1731]
[1732]
[1733]
[1734]
[1735]
[1736]
[1737]
[1738]
[1739]
[1740]
[1741]
[1742]
[1743]
[1744]
[1745]
[1746]
[1747]
[1748]
[1749]
[1750]
[1751]
[1752]
[1753]
[1754]
[1755]
[1756]
[1757]
[1758]
[1759]
[1760]
[1761]
[1762]
[1763]
[1764]
[1765]
[1766]
[1767]
[1768]
[1769]
[1770]
[1771]
[1772]
[1773]
[1774]
[1775]
[1776]
[1777]
[1778]
[1779]
[1780]
[1781]
[1782]
[1783]
[1784]
[1785]
[1786]
[1787]
[1788]
[1789]
[1790]
[1791]
[1792]
[1793]
[1794]
[1795]
[1796]
[1797]
[1798]
[1799]
[1800]
[1801]
[1802]
[1803]
[1804]
[1805]
[1806]
[1807]
[1808]
[1809]
[1810]
[1811]
[1812]
[1813]
[1814]
[1815]
[1816]
[1817]
[1818]
[1819]
[1820]
[1821]
[1822]
[1823]
[1824]
[1825]
[1826]
[1827]
[1828]
[1829]
[1830]
[1831]
[1832]
[1833]
[1834]
[1835]
[1836]
[1837]
[1838]
[1839]
[1840]
[1841]
[1842]
[1843]
[1844]
[1845]
[1846]
[1847]
[1848]
[1849]
[1850]
[1851]
[1852]
[1853]
[1854]
[1855]
[1856]
[1857]
[1858]
[1859]
[1860]
[1861]
[1862]
[1863]
[1864]
[1865]
[1866]
[1867]
[1868]
[1869]
[1870]
[1871]
[1872]
[1873]
[1874]
[1875]
[1876]
[1877]
[1878]
[1879]
[1880]
[1881]
[1882]
[1883]
[1884]
[1885]
[1886]
[1887]
[1888]
[1889]
[1890]
[1891]
[1892]
[1893]
[1894]
[1895]
[1896]
[1897]
[1898]
[1899]
[1900]
[1901]
[1902]
[1903]
[1904]
[1905]
[1906]
[1907]
[1908]
[1909]
[1910]
[1911]
[1912]
[1913]
[1914]
[1915]
[1916]
[1917]
[1918]
[1919]
[1920]
[1921]
[1922]
[1923]
[1924]
[1925]
[1926]
[1927]
[1928]
[1929]
[1930]
[1931]
[1932]
[1933]
[1934]
[1935]
[1936]
[1937]
[1938]
[1939]
[1940]
[1941]
[1942]
[1943]
[1944]
[1945]
[1946]
[1947]
[1948]
[1949]
[1950]
[1951]
[1952]
[1953]
[1954]
[1955]
[1956]
[1957]
[1958]
[1959]
[1960]
[1961]
[1962]
[1963]
[1964]
[1965]
[1966]
[1967]
[1968]
[1969]
[1970]
[1971]
[1972]
[1973]
[1974]
[1975]
[1976]
[1977]
[1978]
[1979]
[1980]
[1981]
[1982]
[1983]
[1984]
[1985]
[1986]
[1987]
[1988]
[1989]
[1990]
[1991]
[1992]
[1993]
[1994]
[1995]
[1996]
[1997]
[1998]
[1999]
[2000]
[2001]
[2002]
[2003]
[2004]
[2005]
[2006]
[2007]
[2008]
[2009]
[2010]
[2011]
[2012]
[2013]
[2014]
[2015]
[2016]
[2017]
[2018]
[2019]
[2020]
[2021]
[2022]
[2023]
[2024]
[2025]
[2026]
[2027]
[2028]
[2029]
[2030]
[2031]
[2032]
[2033]
[2034]
[2035]
[2036]
[2037]
[2038]
[2039]
[2040]
[2041]
[2042]
[2043]
[2044]
[2045]
[2046]
[2047]
[2048]
[2049]
[2050]
[2051]
[2052]
[2053]
[2054]
[2055]
[2056]
[2057]
[2058]
[2059]
[2060]
[2061]
[2062]
[2063]
[2064]
[2065]
[2066]
[2067]
[2068]
[2069]
[2070]
[2071]
[2072]
[2073]
[2074]
[2075]
[2076]
[2077]
[2078]
[2079]
[2080]
[2081]
[2082]
[2083]
[2084]
[2085]
[2086]
[2087]
[2088]
[2089]
[2090]
[2091]
[2092]
[2093]
[2094]
[2095]
[2096]
[2097]
[2098]
[2099]
[2100]
[2101]
[2102]
[2103]
[2104]
[2105]
[2106]
[2107]
[2108]
[2109]
[2110]
[2111]
[2112]
[2113]
[2114]
[2115]
[2116]
[2117]
[2118]
[2119]
[2120]
[2121]
[2122]
[2123]
[2124]
[2125]
[2126]
[2127]
[2128]
[2129]
[2130]
[2131]
[2132]
[2133]
[2134]
[2135]
[2136]
[2137]
[2138]
[2139]
[2140]
[2141]
[2142]
[2143]
[2144]
[2145]
[2146]
[2147]
[2148]
[2149]
[2150]
[2151]
[2152]
[2153]
[2154]
[2155]
[2156]
[2157]
[2158]
[2159]
[2160]
[2161]
[2162]
[2163]
[2164]
[2165]
[2166]
[2167]
[2168]
[2169]
[2170]
[2171]
[2172]
[2173]
[2174]
[2175]
[2176]
[2177]
[2178]
[2179]
[2180]
[2181]
[2182]
[2183]
[2184]
[2185]
[2186]
[2187]
[2188]
[2189]
[2190]
[2191]
[2192]
[2193]
[2194]
[2195]
[2196]
[2197]
[2198]
[2199]
[2200]
[2201]
[2202]
[2203]
[2204]
[2205]
[2206]
[2207]
[2208]
[2209]
[2210]
[2211]
[2212]
[2213]
[2214]
[2215]
[2216]
[2217]
[2218]
[2219]
[2220]
[2221]
[2222]
[2223]
[2224]
[2225]
[2226]
[2227]
[2228]
[2229]
[2230]
[2231]
[2232]
[2233]
[2234]
[2235]
[2236]
[2237]
[2238]
[2239]
[2240]
[2241]
[2242]
[2243]
[2244]
[2245]
[2246]
[2247]
[2248]
[2249]
[2250]
[2251]
[2252]
[2253]
[2254]
[2255]
[2256]
[2257]
[2258]
[2259]
[2260]
[2261]
[2262]
[2263]
[2264]
[2265]
[2266]
[2267]
[2268]
[2269]
[2270]
[2271]
[2272]
[2273]
[2274]
[2275]
[2276]
[2277]
[2278]
[2279]
[2280]
[2281]
[2282]
[2283]
[2284]
[2285]
[2286]
[2287]
[2288]
[2289]
[2290]
[2291]
[2292]
[2293]
[2294]
[2295]
[2296]
[2297]
[2298]
[2299]
[2300]
[2301]
[2302]
[2303]
[2304]
[2305]
[2306]
[2307]
[2308]
[2309]
[2310]
[2311]
[2312]
[2313]
[2314]
[2315]
[2316]
[2317]
[2318]
[2319]
[2320]
[2321]
[2322]
[2323]
[2324]
[2325]
[2326]
[2327]
[2328]
[2329]
[2330]
[2331]
[2332]
[2333]
[2334]
[2335]
[2336]
[2337]
[2338]
[2339]
[2340]
[2341]
[2342]
[2343]
[2344]
[2345]
[2346]
[2347]
[2348]
[2349]
[2350]
[2351]
[2352]
[2353]
[2354]
[2355]
[2356]
[2357]
[2358]
[2359]
[2360]
[2361]
[2362]
[2363]
[2364]
[2365]
[2366]
[2367]
[2368]
[2369]
[2370]
[2371]
[2372]
[2373]
[2374]
[2375]
[2376]
[2377]
[2378]
[2379]
[2380]
[2381]
[2382]
[2383]
[2384]
[2385]
[2386]
[2387]
[2388]
[2389]
[2390]
[2391]
[2392]
[2393]
[2394]
[2395]
[2396]
[2397]
[2398]
[2399]
[2400]
[2401]
[2402]
[2403]
[2404]
[2405]
[2406]
[2407]
[2408]
[2409]
[2410]
[2411]
[2412]
[2413]
[2414]
[2415]
[2416]
[2417]
[2418]
[2419]
[2420]
[2421]
[2422]
[2423]
[2424]
[2425]
[2426]
[2427]
[2428]
[2429]
[2430]
[2431]
[2432]
[2433]
[2434]
[2435]
[2436]
[2437]
[2438]
[2439]
[2440]
[2441]
[2442]
[2443]
[2444]
[2445]
[2446]
[2447]
[2448]
[2449]
[2450]
[2451]
[2452]
[2453]
[2454]
[2455]
[2456]
[2457]
[2458]
[2459]
[2460]
[2461]
[2462]
[2463]
[2464]
[2465]
[2466]
[2467]
[2468]
[2469]
[2470]
[2471]
[2472]
[2473]
[2474]
[2475]
[2476]
[2477]
[2478]
[2479]
[2480]
[2481]
[2482]
[2483]
[2484]
[2485]
[2486]
[2487]
[2488]
[2489]
[2490]
[2491]
[2492]
[2493]
[2494]
[2495]
[2496]
[2497]
[2498]
[2499]
[2500]
[2501]
[2502]
[2503]
[2504]
[2505]
[2506]
[2507]
[2508]
[2509]
[2510]
[2511]
[2512]
[2513]
[2514]
[2515]
[2516]
[2517]
[2518]
[2519]
[2520]
[2521]
[2522]
[2523]
[2524]
[2525]
[2526]
[2527]
[2528]
[2529]
[2530]
[2531]
[2532]
[2533]
[2534]
[2535]
[2536]
[2537]
[2538]
[2539]
[2540]
[2541]
[2542]
[2543]
[2544]
[2545]
[2546]
[2547]
[2548]
[2549]
[2550]
[2551]
[2552]
[2553]
[2554]
[2555]
[2556]
[2557]
[2558]
[2559]
[2560]
[2561]
[2562]
[2563]
[2564]
[2565]
[2566]
[2567]
[2568]
[2569]
[2570]
[2571]
[2572]
[2573]
[2574]
[2575]
[2576]
[2577]
[2578]
[2579]
[2580]
[2581]
[2582]
[2583]
[2584]
[2585]
[2586]
[2587]
[2588]
[2589]
[2590]
[2591]
[2592]
[2593]
[2594]
[2595]
[2596]
[2597]
[2598]
[2599]
[2600]
[2601]
[2602]
[2603]
[2604]
[2605]
[2606]
[2607]
[2608]
[2609]
[2610]
[2611]
[2612]
[2613]
[2614]
[2615]
[2616]
[2617]
[2618]
[2619]
[2620]
[2621]
[2622]
[2623]
[2624]
[2625]
[2626]
[2627]
[2628]
[2629]
[2630]
[2631]
[2632]
[2633]
[2634]
[2635]
[2636]
[2637]
[2638]
[2639]
[2640]
[2641]
[2642]
[2643]
[2644]
[2645]
[2646]
[2647]
[2648]
[2649]
[2650]
[2651]
[2652]
[2653]
[2654]
[2655]
[2656]
[2657]
[2658]
[2659]
[2660]
[2661]
[2662]
[2663]
[2664]
[2665]
[2666]
[2667]
[2668]
[2669]
[2670]
[2671]
[2672]
[2673]
[2674]
[2675]
[2676]
[2677]
[2678]
[2679]
[2680]
[2681]
[2682]
[2683]
[2684]
[2685]
[2686]
[2687]
[2688]
[2689]
[2690]
[2691]
[2692]
[2693]
[2694]
[2695]
[2696]
[2697]
[2698]
[2699]
[2700]
[2701]
[2702]
[2703]
[2704]
[2705]
[2706]
[2707]
[2708]
[2709]
[2710]
[2711]
[2712]
[2713]
[2714]
[2715]
[2716]
[2717]
[2718]
[2719]
[2720]
[2721]
[2722]
[2723]
[2724]
[2725]
[2726]
[2727]
[2728]
[2729]
[2730]
[2731]
[2732]
[2733]
[2734]
[2735]
[2736]
[2737]
[2738]
[2739]
[2740]
[2741]
[2742]
[2743]
[2744]
[2745]
[2746]
[2747]
[2748]
[2749]
[2750]
[2751]
[2752]
[2753]
[2754]
[2755]
[2756]
[2757]
[2758]
[2759]
[2760]
[2761]
[2762]
[2763]
[2764]
[2765]
[2766]
[2767]
[2768]
[2769]
[2770]
[2771]
[2772]
[2773]
[2774]
[2775]
[2776]
[2777]
[2778]
[2779]
[2780]
[2781]
[2782]
[2783]
[2784]
[2785]
[2786]
[2787]
[2788]
[2789]
[2790]
[2791]
[2792]
[2793]
[2794]
[2795]
[2796]
[2797]
[2798]
[2799]
[2800]
[2801]
[2802]
[2803]
[2804]
[2805]
[2806]
[2807]
[2808]
[2809]
[2810]
[2811]
[2812]
[2813]
[2814]
[2815]
[2816]
[2817]
[2818]
[2819]
[2820]
[2821]
[2822]
[2823]
[2824]
[2825]
[2826]
[2827]
[2828]
[2829]
[2830]
[2831]
[2832]
[2833]
[2834]
[2835]
[2836]
[2837]
[2838]
[2839]
[2840]
[2841]
[2842]
[2843]
[2844]
[2845]
[2846]
[2847]
[2848]
[2849]
[2850]
[2851]
[2852]
[2853]
[2854]
[2855]
[2856]
[2857]
[2858]
[2859]
[2860]
[2861]
[2862]
[2863]
[2864]
[2865]
[2866]
[2867]
[2868]
[2869]
[2870]
[2871]
[2872]
[2873]
[2874]
[2875]
[2876]
[2877]
[2878]
[2879]
[2880]
[2881]
[2882]
[2883]
[2884]
[2885]
[2886]
[2887]
[2888]
[2889]
[2890]
[2891]
[2892]
[2893]
[2894]
[2895]
[2896]
[2897]
[2898]
[2899]
[2900]
[2901]
[2902]
[2903]
[2904]
[2905]
[2906]
[2907]
[2908]
[2909]
[2910]
[2911]
[2912]
[2913]
[2914]
[2915]
[2916]
[2917]
[2918]
[2919]
[2920]
[2921]
[2922]
[2923]
[2924]
[2925]
[2926]
[2927]
[2928]
[2929]
[2930]
[2931]
[2932]
[2933]
[2934]
[2935]
[2936]
[2937]
[2938]
[2939]
[2940]
[2941]
[2942]
[2943]
[2944]
[2945]
[2946]
[2947]
[2948]
[2949]
[2950]
[2951]
[2952]
[2953]
[2954]
[2955]
[2956]
[2957]
[2958]
[2959]
[2960]
[2961]
[2962]
[2963]
[2964]
[2965]
[2966]
[2967]
[2968]
[2969]
[2970]
[2971]
[2972]
[2973]
[2974]
[2975]
[2976]
[2977]
[2978]
[2979]
[2980]
[2981]
[2982]
[2983]
[2984]
[2985]
[2986]
[2987]
[2988]
[2989]
[2990]
[2991]
[2992]
[2993]
[2994]
[2995]
[2996]
[2997]
[2998]
[2999]
[3000]
[3001]
[3002]
[3003]
[3004]
[3005]
[3006]
[3007]
[3008]
[3009]
[3010]
[3011]
[3012]
[3013]
[3014]
[3015]
[3016]
[3017]
[3018]
[3019]
[3020]
[3021]
[3022]
[3023]
[3024]
[3025]
[3026]
[3027]
[3028]
[3029]
[3030]
[3031]
[3032]
[3033]
[3034]
[3035]
[3036]
[3037]
[3038]
[3039]
[3040]
[3041]
[3042]
[3043]
[3044]
[3045]
[3046]
[3047]
[3048]
[3049]
[3050]
[3051]
[3052]
[3053]
[3054]
[3055]
[3056]
[3057]
[3058]
[3059]
[3060]
[3061]
[3062]
[3063]
[3064]
[3065]
[3066]
[3067]
[3068]
[3069]
[3070]
[3071]
[3072]
[3073]
[3074]
[3075]
[3076]
[3077]
[3078]
[3079]
[3080]
[3081]
[3082]
[3083]
[3084]
[3085]
[3086]
[3087]
[3088]
[3089]
[3090]
[3091]
[3092]
[3093]
[3094]
[3095]
[3096]
[3097]
[3098]
[3099]
[3100]
[3101]
[3102]
[3103]
[3104]
[3105]
[3106]
[3107]
[3108]
[3109]
[3110]
[3111]
[3112]
[3113]
[3114]
[3115]
[3116]
[3117]
[3118]
[3119]
[3120]
[3121]
[3122]
[3123]
[3124]
[3125]
[3126]
[3127]
[3128]
[3129]
[3130]
[3131]
[3132]
[3133]
[3134]
[3135]
[3136]
[3137]
[3138]
[3139]
[3140]
[3141]
[3142]
[3143]
[3144]
[3145]
[3146]
[3147]
[3148]
[3149]
[3150]
[3151]
[3152]
[3153]
[3154]
[3155]
[3156]
[3157]
[3158]
[3159]
[3160]
[3161]
[3162]
[3163]
[3164]
[3165]
[3166]
[3167]
[3168]
[3169]
[3170]
[3171]
[3172]
[3173]
[3174]
[3175]
[3176]
[3177]
[3178]
[3179]
[3180]
[3181]
[3182]
[3183]
[3184]
[3185]
[3186]
[3187]
[3188]
[3189]
[3190]
[3191]
[3192]
[3193]
[3194]
[3195]
[3196]
[3197]
[3198]
[3199]
[3200]
[3201]
[3202]
[3203]
[3204]
[3205]
[3206]
/*****************************************************************************/
/*
HTTPdMon.c
This utility displays information about a WASD HTTPd server. The information
is derived from JPI data about the process, and read from a permanent system
global section in(to) which the server keeps the accounting and writes the
request data.
The /ALERT and /ALERT=ALL parameters ring the bell every time a new request is
reported (the connect count increases). The /ALERT=HOST rings the bell every
time the host name in the request changes. With /ALERT=PATH[=<integer>] when a
path matched by the mapping rule "SET /path* ALERT" is detected by the server
the bell is rung <integer> times (default is 10). The /LOOKUP qualifier
(default) attempts to resolve a dotted-decimal host address in the request (if
the server's [DNSlookup] configuration directive is disabled). This operation
can introduce some latency as name resolution occurs. A trailing "#" indicates
this is an address that has been resolved this way. If it cannot be resolved a
"?" is appended to the numeric address.
The "(n servers)" field keeps track of multiple servers on a node or cluster.
When there is a change in the number the previous value is displayed in
parentheses after the current and the terminal bell is rung (this can be
suppressed with "/ALERT=NOSERVERS"). Of course servers coming and going are
only detected if it happens at a frequency greater than the current display
interval.
QUALIFIERS
----------
/ALERT[=ALL|HOST|PATH[=<integer>]|[NO]SERVERS]
ring bell for all accesses or
just a change in host and/or
suppress bell if server count changes
/ALL=string set the server-group name (up to 8 characters)
/DBUG turns on all "if (Debug)" statements
/DEMO demonstration mode (matches that of the HTTPd)
/ENV=<integer> refer to this WASD environment (2..15)
/[NO]GENERAL display general HTTP serving information
/HELP display brief usage information
/IDENTIFICATION= the specific instance (server) process PID
/INTERVAL= number of seconds between display refresh
/[NO]LOOKUP resolve dotted-decimal host addresses to names
/PLUCK place selected statistics into global DCL symbols
/PORT= the IP port number of the server to monitor
/[NO]PROCESS display HTTPd process information
/[NO]PROXY display proxy serving information
/[NO]REQUEST display request information
/[NO]STATUS display instance information
/REFRESH= synonym for /INTERVAL
REQUIRED PRIVILEGES
-------------------
WORLD for access to the server process' JPI data
SYSPRV for access to the global section containing the server data
BUILD DETAILS
-------------
See BUILD_HTTPDMON.COM
COPYRIGHT
---------
Copyright (C) 1996-2021 Mark G.Daniel
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
VERSION HISTORY (update SOFTWAREVN as well!)
---------------
06-MAY-2021 MGD v3.0.0, WASD v12.n.n
so long, farewell, Auf Wiedersehen, goodnight (-VAX)
07-MAR-2020 MGD v2.8.0, re-map global section when startup detected
09-NOV-2018 MGD v2.7.0, refactor IP address handling
14-NOV-2017 MGD v2.6.0, instance status data
if |WASD_ENV| defined use that in absence /INSTANCE
12-SEP-2015 MGD v2.5.0, WASD v11 and HTTP/2
30-NOV-2014 MGD v2.4.2, accomodate per-instance "current" data
18-JUN-2010 MGD v2.4.1, add proctor, proxy tunnel and WebSocket
remove accept and reject to make way for WebSocket
31-OCT-2009 MGD v2.4.0, just for WASD v10
30-AUG-2009 MGD v2.3.9, bytes per second
09-JUL-2009 MGD v2.3.8, /ENV=
15-OCT-2008 MGD v2.3.7, add WebDAV: module item
15-OCT-2008 MGD v2.3.6, pluck server statistics
21-FEB-2008 MGD v2.3.5, add remote user and realm
add Request.BytesTxGzipPercent
PercentOf() calc percentages of unsigned longs
QuadPercentOf() calc percentages of unsigned quads
19-SEP-2006 MGD v2.3.4, Accounting.ResponseStatusCodeCount changes name to
Accounting.ResponseStatusCodeGroup
PRC: now shows remaining prclm (as do other quotas)
15-JUL-2006 MGD v2.3.3, abbreviate some stats for humungous sites (UMA :-)
add status for SUSPEND and instance PASSIVE modes
24-AUG-2005 MGD v2.3.2, only display printable request URI characters
20-JUL-2005 MGD v2.3.1, detect and report global section mismatch
28-AUG-2004 MGD v2.3.0, modifications during HTTP/1.1 support
16-APR-2004 MGD v2.2.0, modifications to support IPv6,
binary resource names for instance locks
27-JAN-2004 MGD v2.1.5, connect processing and keep-alive accounting items
23-DEC-2003 MGD v2.1.4, minor conditional mods to support IA64
22-SEP-2003 MGD v2.1.3, line overflow - if necessary suppress '(403:count)'
11-JUN-2003 MGD v2.1.2, ProxyMaintDeviceStats() inline with WASD v8.3
bugfix; ProxyMaintDeviceStats() volume count handling
26-NOV-2002 MGD v2.1.1, abbreviate proxy cache Rx/Tx prevent line overflow
30-JUN-2002 MGD v2.1.0, HTTPd v8.0, NCS, FTP, etc.,
/IDENTIFICATION= specific instance PID,
/ALERT=PATH notifies when "SET /path* ALERT" hit
17-MAR-2002 MGD v2.0.2, CommaNumber() 64 bit kludge for VAX
04-AUG-2001 MGD v2.0.1, provide 'ANSIceos' before a "STATUS:" field
07-JUL-2001 MGD v2.0.0, HTTPd v7.2, uses permanent global section for data,
additional/changed accounting and status information
15-OCT-2000 MGD v1.13.0, HTTPd v7.1, DLM server-group "aware", /ALL=,
no current process count if $creprc() detached
20-MAY-2000 MGD v1.12.0, HTTPd v7.0, (no real changes)
30-OCT-1999 MGD v1.11.0, HTTPd v6.1,
remove NETLIB support
20-JUN-1999 MGD v1.10.0, add proxy percentage based on counts,
allow for disks >9GB in space calculations
25-JAN-1999 MGD v1.9.0, HTTPd v6.0, proxy serving
27-OCT-1998 MGD v1.8.0, HTTPd v5.3, (no real changes)
27-AUG-1998 MGD v1.7.0, HTTPd v5.2, (no real changes)
21-JUN-1998 MGD v1.6.0, HTTPd v5.1, alert, and lookup host address to name
14-FEB-1998 MGD v1.5.0, HTTPd v5.0, DECnet, SSL and minor changes
15-OCT-1997 MGD v1.4.0, HTTPd v4.5, cache
21-AUG-1997 MGD v1.3.0, HTTPd v4.4, accounting structure > 255 bytes, duration
23-JUL-1997 MGD v1.2.1, HTTPd v4.3, (no real changes)
14-JUN-1997 MGD v1.2.0, HTTPd v4.2, CGIplus,
bugfix; arithmetic trap on AXP systems
01-FEB-1997 MGD v1.1.0, HTTPd v4.0, (no real changes)
01-DEC-1995 MGD v1.0.0, HTTPd v3.0, initial development
*/
/*****************************************************************************/
/* note that the layout is a different to other WASD software ID strings! */
#define SOFTWAREVN "v3.0.0"
#define SOFTWARENM "HTTPDMON"
#ifdef __ALPHA
# define SOFTWAREID SOFTWARENM " " SOFTWAREVN " AXP"
#endif
#ifdef __ia64
# define SOFTWAREID SOFTWARENM " " SOFTWAREVN " IA64"
#endif
#ifdef __x86_64
# define SOFTWAREID SOFTWARENM " " SOFTWAREVN " X86"
#endif
/* standard C header files */
#include <ctype.h>
#include <ints.h>
#include <stdlib.h>
#include <stdio.h>
/* VMS related header files */
#include <descrip.h>
#include <dvidef.h>
#include <errno.h>
#include <iodef.h>
#include <jpidef.h>
#include <lckdef.h>
#include <libclidef.h>
#include <libdtdef.h>
#include <lkidef.h>
#include <lnmdef.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 */
#ifdef THIS_WASD_H
/* when field testing and httpdmon.c is included in the server directory */
#include "./wasd.h"
#else
#include "../httpd/wasd.h"
#endif
/* Internet-related header files */
/* ensure BSD 4.4 structures */
#define _SOCKADDR_LEN
/* BUT MultiNet BG driver does not support BSD 4.4 AF_INET addresses */
#define NO_SOCKADDR_LEN_4
#include <socket.h>
#include <in.h>
#include <netdb.h>
#include <inet.h>
#define BOOL int
#define true 1
#define false 0
#define FI_LI __FILE__, __LINE__
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define DEFAULT_INTERVAL_SECONDS 2
#define PATH_ALERT_BELL_COUNT 10
char ErrorProxyMaintTooManyDevices [] = "Volume set has too many members.",
Utility [] = "HTTPDMON";
#define ControlZ '\x1a'
typedef struct STRUCT_IOSBLK
{
ushort iosb$w_status;
ushort iosb$w_bcnt;
ulong iosb$l_reserved;
}
IOSBLK;
long SysLckMask [2] = { PRV$M_SYSLCK, 0 };
BOOL ControlY,
Debug,
DemoMode,
DoAlertAll,
DoAlertHost,
DoAlertPath,
DoAlertServers = true,
DoGeneralInfo,
DoNoGeneralInfo,
DoLookupHost = true,
DoProcessInfo,
DoNoProcessInfo,
DoPluck,
DoProxyInfo,
DoNoProxyInfo,
DoRequestInfo,
DoNoRequestInfo,
DoStatusInfo,
DoNoStatusInfo,
DoShowHelp;
int CliInstancePid,
CurrentProcessCount,
InstanceCount,
InstanceEnvNumber,
InstanceStringLength,
IntervalSeconds = DEFAULT_INTERVAL_SECONDS,
NextInstancePid,
PageLength,
PathAlertBellRepetition = PATH_ALERT_BELL_COUNT,
PrevConnectCount,
ServerPort = 80;
unsigned short SyiClusterNodes,
SyiNodeLength;
unsigned long HttpdPid;
int64 NowTime64;
char CommandLine [256],
InstanceString [64],
PrevHostName [256],
Screen [16384],
ServerProcessName [16],
SyiNodeName [16];
char *ScrPtr;
$DESCRIPTOR (TcpIpDeviceDsc, "UCX$DEVICE");
int HttpdGblSecLength;
HTTPD_GBLSEC *HttpdGblSecPtr;
ACCOUNTING_STRUCT *AccountingPtr;
/* ANSI terminal control sequences */
char ANSIblink [] = "\x1b[5m",
ANSIbold [] = "\x1b[1m",
ANSIceol [] = "\x1b[0K",
ANSIceos [] = "\x1b[0J",
ANSIcls [] = "\x1b[0;0H\x1b[J",
ANSIhome [] = "\x1b[0;0H",
ANSInormal [] = "\x1b[0m",
ANSIreverse [] = "\x1b[7m",
ANSIuline [] = "\x1b[4m";
/* required prototypes */
ControlY_AST ();
char* BytesPerString (unsigned int);
int CheckHttpdPid (void);
void CommaNumber (int, void*, char*);
void AddInstanceStatus();
char* LookupHostName (ulong);
void MapGlobalSection (void);
int PercentOf (unsigned long, unsigned long);
int QuadPercentOf (unsigned long*, unsigned long*);
int SetSymbol (char*, char*, int);
void ThisLongAgo (int64*, char*);
char* TimeString ();
void TryIt (char*);
char* v10orPrev10 (char*, int);
/*****************************************************************************/
/*
*/
int main ()
{
static $DESCRIPTOR (ttDsc, "TT:");
int status,
MonitorStatus;
char *cptr;
struct
{
unsigned short buf_len;
unsigned short item;
unsigned char *buf_addr;
void *ret_len;
}
SyiItems [] =
{
{ sizeof(SyiClusterNodes), SYI$_CLUSTER_NODES, &SyiClusterNodes, 0 },
{ sizeof(SyiNodeName)-1, SYI$_NODENAME, &SyiNodeName, &SyiNodeLength },
{ 0,0,0,0 }
},
TtPageItemList [] =
{
{ sizeof(PageLength), DVI$_TT_PAGE, &PageLength, 0 },
{ 0, 0, 0, 0 }
};
IOSBLK IOsb;
/*********/
/* begin */
/*********/
GetParameters ();
if (Debug) ANSIcls[0] = ANSIhome[0] = ANSIceol[0] = ANSIceos[0] = '\0';
if (DemoMode) InstanceEnvNumber = DEMO_INSTANCE_GROUP_NUMBER;
if (!DoGeneralInfo && !DoProcessInfo && !DoRequestInfo && !DoProxyInfo)
{
if (!DoNoProcessInfo) DoProcessInfo = true;
if (!DoNoGeneralInfo) DoGeneralInfo = true;
if (!DoNoRequestInfo) DoRequestInfo = true;
}
if (DoProxyInfo)
{
if (!DoNoProcessInfo) DoProcessInfo = true;
if (!DoGeneralInfo) DoGeneralInfo = false;
if (!DoNoRequestInfo) DoRequestInfo = true;
}
if (DoShowHelp) exit (ShowHelp ());
if (VMSnok (status = OnControlY (&ControlY_AST)))
exit (status);
status = sys$getsyi (0, 0, 0, &SyiItems, &IOsb, 0, 0);
if (VMSok (status)) status = IOsb.iosb$w_status;
if (VMSnok (status)) exit (status);
SyiNodeName[SyiNodeLength] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", SyiNodeName);
status = sys$getdviw (0, 0, &ttDsc, &TtPageItemList, &IOsb, 0, 0, 0);
if (VMSok (status)) status = IOsb.iosb$w_status;
if (VMSnok (status)) exit (status);
/* if WASD_ENV defined then use this value in the absence of a CLI value */
if (!InstanceEnvNumber)
{
if (cptr = getenv("WASD_ENV"))
InstanceEnvNumber = atoi (cptr);
else
if (DemoMode)
InstanceEnvNumber = DEMO_INSTANCE_GROUP_NUMBER;
else
InstanceEnvNumber = INSTANCE_ENV_NUMBER_DEFAULT;
}
if (Debug) fprintf (stdout, "env=%d\n", InstanceEnvNumber);
MapGlobalSection ();
if (DoPluck) exit (PluckStats ());
MonitorStatus = MonitorHttpd ();
if (VMSnok (status = OnControlY (0)))
exit (status);
exit (MonitorStatus);
}
/*****************************************************************************/
/*
Assign a channel to the terminal device. Create a buffered screenful of
information about the HTTPd server and output it in one IO.
*/
int MonitorHttpd ()
{
int cnt, status,
FillLeft,
FillRight,
FillRequired,
PortLength,
InstanceInformationLength,
SoftwareIDLength,
TimeStringLength;
unsigned short TTChannel;
char ReadBuffer;
char Line [128],
Port [16];
char *TimeStringPtr;
$DESCRIPTOR (TTDsc, "TT:");
struct {
unsigned short Status;
unsigned short Offset;
unsigned short Terminator;
unsigned short TerminatorSize;
} IOsb;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MonitorHttpd()\n");
if (VMSnok (status = sys$assign (&TTDsc, &TTChannel, 0, 0, 0)))
return (status);
if (VMSnok (status =
sys$qiow (0, TTChannel, IO$_WRITELBLK, 0, 0, 0,
ANSIcls, sizeof(ANSIcls)-1, 0, 0, 0, 0)))
return (status);
sprintf (ServerProcessName, "WASD:%d", ServerPort);
PortLength = sprintf (Port, "Port: %d", ServerPort);
SoftwareIDLength = strlen(SOFTWAREID);
for (;;)
{
if (ControlY) break;
sys$gettim (&NowTime64);
GetInstanceInformation();
TimeStringPtr = TimeString ();
TimeStringLength = strlen(TimeStringPtr);
FillRequired = 65 - InstanceStringLength -
SoftwareIDLength - TimeStringLength;
FillLeft = FillRight = FillRequired / 2;
if (FillLeft + FillRight < FillRequired) FillRight++;
for (cnt = 6; cnt > SyiNodeLength; cnt--) FillRight--;
ScrPtr = Screen;
ScrPtr += sprintf (ScrPtr,
"%s %*s%s%s::%s %s %*s%s%s%s%*s %s%s%s%s\r\n",
ANSIhome, 6 - SyiNodeLength, "",
ANSIbold, SyiNodeName, ANSInormal, InstanceString,
FillLeft, "", ANSIuline, SOFTWAREID, ANSInormal, FillRight, "",
ANSIbold, TimeStringPtr, ANSInormal,
ANSIceol);
if (CheckHttpdPid() == SS$_NONEXPR) MapGlobalSection ();
if (HttpdGblSecPtr)
{
AccountingPtr = &HttpdGblSecPtr->Accounting;
if (HttpdGblSecPtr->GblSecVersion != HTTPD_GBLSEC_VERSION_NUMBER)
ScrPtr += sprintf (ScrPtr,
"%s %s GLOBAL SECTION MISMATCH! \
(HTTPDMON:%08.08X WASD:%08.08X) %s%s\x07",
ANSIceol, ANSIreverse,
HTTPD_GBLSEC_VERSION_NUMBER, HttpdGblSecPtr->GblSecVersion,
ANSInormal, ANSIceol);
if (DoProcessInfo)
if (VMSnok (status = AddProcessInfo ()))
return (status);
if (DoGeneralInfo)
if (VMSnok (status = AddGeneralInfo ()))
return (status);
if (DoProxyInfo)
if (VMSnok (status = AddProxyInfo ()))
return (status);
if (HttpdGblSecPtr->StatusMessage[0])
if (VMSnok (status = AddStatusMessage ()))
return (status);
else;
else
if (DoRequestInfo)
if (VMSnok (status = AddRequest ()))
return (status);
if (!DoNoStatusInfo) AddInstanceStatus ();
strcpy (ScrPtr, ANSIceos);
ScrPtr += sizeof(ANSIceos)-1;
if (Debug) fprintf (stdout, "%d bytes\f", ScrPtr-Screen);
if (VMSnok (status =
sys$qiow (0, TTChannel, IO$_WRITELBLK, 0, 0, 0,
Screen, ScrPtr-Screen, 0, 0, 0, 0)))
return (status);
}
status = sys$qiow (0, TTChannel, IO$_READLBLK | IO$M_TIMED,
&IOsb, 0, 0,
&ReadBuffer, 1, IntervalSeconds, 0, 0, 0);
if (status == SS$_TIMEOUT) continue;
if (VMSnok (status)) return (status);
if (IOsb.Terminator == ControlZ) return (SS$_NORMAL);
}
if (VMSnok (status =
sys$qiow (0, TTChannel, IO$_WRITELBLK, 0, 0, 0,
Screen, ScrPtr-Screen, 0, 0, 0, 0)))
return (status);
return (status);
}
/*****************************************************************************/
/*
Get the HTTPd server data from its global section.
Data is written by UpdateGlobalSection() in [SRC.HTTPD]SUPPORT.C module.
*/
void MapGlobalSection (void)
{
/* 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 unsigned long RetAddr [2];
static char HttpdGblSecName [32];
static $DESCRIPTOR (HttpdGblSecNameDsc, HttpdGblSecName);
static $DESCRIPTOR (HttpdGblSecNameFaoDsc, GBLSEC_NAME_FAO);
int status,
ByteSize,
PageSize;
unsigned short ShortLength;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MapGlobalSection() %08.08X\n", HttpdPid);
if (HttpdGblSecPtr)
{
/* delete global section virtual addresses and remap */
status = sys$deltva (&RetAddr, 0, 0);
if (VMSnok (status)) exit (status);
HttpdGblSecPtr = NULL;
}
if (!HttpdGblSecPtr)
{
sys$fao (&HttpdGblSecNameFaoDsc, &ShortLength, &HttpdGblSecNameDsc,
HTTPD_NAME, HTTPD_GBLSEC_VERSION_NUMBER,
InstanceEnvNumber, "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 monitor previously has been running then just wait */
if (HttpdPid) return;
if (status == SS$_NOSUCHSEC)
{
fprintf (stdout,
"%%%s-E-SERVER, no such server!\n\
-SYSTEM-E-NOSUCHSEC, no such (global) section\n",
Utility);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
else
exit (status);
}
}
if (HttpdGblSecPtr->GblSecVersion != HTTPD_GBLSEC_VERSION_NUMBER ||
HttpdGblSecPtr->GblSecLength != sizeof(HTTPD_GBLSEC))
{
if (Debug) fprintf (stdout, "%d %d\n",
HttpdGblSecPtr->GblSecLength, sizeof(HTTPD_GBLSEC));
if (HttpdPid) fputs ("\n", stdout);
fprintf (stdout,
"%%%s-E-GBLSEC, global section mismatch, rebuild HTTPDMON?\n",
Utility);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
HttpdPid = HttpdGblSecPtr->HttpdProcessId;
}
/*****************************************************************************/
/*
Add the HTTPd server process information to the screen buffer.
*/
int AddProcessInfo ()
{
static char JpiPrcNam [16],
JpiUserName [13],
UpTime [32];
static unsigned long JpiAstCnt,
JpiAstLm,
JpiBioCnt,
JpiBytLm,
JpiBytCnt,
JpiBioLm,
JpiCpuTime,
JpiDioCnt,
JpiDioLm,
JpiEnqCnt,
JpiEnqLm,
JpiFilCnt,
JpiFilLm,
JpiPageFlts,
JpiPagFilCnt,
JpiPgFlQuota,
JpiPid,
JpiPrcCnt,
JpiPrcLm,
JpiTqCnt,
JpiTqLm,
JpiVirtPeak,
JpiWsSize,
JpiWsPeak;
static int64 ConnectTime64,
JpiLoginTime64;
static char LastExitStatus [48] = "";
static $DESCRIPTOR (UpTimeFaoDsc, "!%D");
static $DESCRIPTOR (UpTimeDsc, UpTime);
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(JpiCpuTime), JPI$_CPUTIM, &JpiCpuTime, 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(JpiLoginTime64), JPI$_LOGINTIM, &JpiLoginTime64, 0 },
{ sizeof(JpiPageFlts), JPI$_PAGEFLTS, &JpiPageFlts, 0 },
{ sizeof(JpiPagFilCnt), JPI$_PAGFILCNT, &JpiPagFilCnt, 0 },
{ sizeof(JpiPgFlQuota), JPI$_PGFLQUOTA, &JpiPgFlQuota, 0 },
{ sizeof(JpiPid), JPI$_PID, &JpiPid, 0 },
{ sizeof(JpiPrcCnt), JPI$_PRCCNT, &JpiPrcCnt, 0 },
{ sizeof(JpiPrcLm), JPI$_PRCLM, &JpiPrcLm, 0 },
{ sizeof(JpiPrcNam), JPI$_PRCNAM, &JpiPrcNam, 0 },
{ sizeof(JpiTqCnt), JPI$_TQCNT, &JpiTqCnt, 0 },
{ sizeof(JpiTqLm), JPI$_TQLM, &JpiTqLm, 0 },
{ sizeof(JpiUserName), JPI$_USERNAME, &JpiUserName, 0 },
{ sizeof(JpiVirtPeak), JPI$_VIRTPEAK, &JpiVirtPeak, 0 },
{ sizeof(JpiWsSize), JPI$_WSSIZE, &JpiWsSize, 0 },
{ sizeof(JpiWsPeak), JPI$_WSPEAK, &JpiWsPeak, 0 },
{0,0,0,0}
};
int status,
col1, col2, col3, col4, colen,
len1, len2;
unsigned short Length;
char *cptr,
*StatePtr,
*UpTimePtr;
char str1 [32],
str2 [32],
AstString [32],
BioString [32],
BytString [32],
DioString [32],
EnqString [32],
FilString [32],
PrcString [32],
TqString [32];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "AddProcessInfo()\n");
if (!(HttpdPid = CliInstancePid))
if (!(HttpdPid = NextInstancePid))
if (!(HttpdPid = HttpdGblSecPtr->HttpdProcessId))
exit (SS$_BUGCHECK);
status = sys$getjpiw (0, &HttpdPid, 0, &JpiItems, 0, 0, 0);
if (Debug) fprintf (stdout, "sys$getjpi() %%X%08.08X\n", status);
if (VMSnok (status) || status == SS$_NONEXPR)
{
if (status == SS$_NONEXPR)
StatePtr = "NONEXPR";
else
if (status == SS$_SUSPENDED)
StatePtr = "MWAIT";
else
return (status);
}
else
StatePtr = NULL;
CurrentProcessCount = JpiPrcCnt;
JpiUserName[12] = '\0';
for (cptr = JpiUserName; *cptr && *cptr != ' '; cptr++);
*cptr = '\0';
if (Debug) fprintf (stdout, "JpiUserName |%s|\n", JpiUserName);
JpiPrcNam[15] = '\0';
for (cptr = JpiPrcNam; *cptr && *cptr != ' '; cptr++);
*cptr = '\0';
if (Debug) fprintf (stdout, "JpiPrcNam |%s|\n", JpiPrcNam);
ConnectTime64 = JpiLoginTime64 - NowTime64;
sys$fao (&UpTimeFaoDsc, &Length, &UpTimeDsc, &ConnectTime64);
UpTime[Length] = '\0';
for (UpTimePtr = UpTime; isspace(*UpTimePtr); UpTimePtr++);
if (AccountingPtr->LastExitStatus)
sprintf (LastExitStatus, " %sExit:%s %%X%08.08X",
ANSIbold, ANSInormal, AccountingPtr->LastExitStatus);
len1 = sprintf (str1, "%d", JpiAstCnt);
len2 = sprintf (str2, "%d", JpiEnqCnt);
if (len2 > len1) len1 = len2; else len2 = len1;
col1 = sprintf (AstString, "%*.*s/%d", len1, len1, str1, JpiAstLm);
colen = sprintf (EnqString, "%*.*s/%d", len2, len2, str2, JpiEnqLm);
if (colen > col1) col1 = colen;
len1 = sprintf (str1, "%d", JpiBioCnt);
len2 = sprintf (str2, "%d", JpiFilCnt);
if (len2 > len1) len1 = len2; else len2 = len1;
col2 = sprintf (BioString, "%*.*s/%d", len1, len1, str1, JpiBioLm);
colen = sprintf (FilString, "%*.*s/%d", len2, len2, str2, JpiFilLm);
if (colen > col2) col2 = colen;
len1 = sprintf (str1, "%d", JpiBytCnt);
len2 = sprintf (str2, "%d", JpiPrcLm-JpiPrcCnt);
if (len2 > len1) len1 = len2; else len2 = len1;
col3 = sprintf (BytString, "%*.*s/%d", len1, len1, str1, JpiBytLm);
colen = sprintf (PrcString, "%*.*s/%d", len2, len2, str2, JpiPrcLm);
if (colen > col3) col3 = colen;
len1 = sprintf (str1, "%d", JpiDioCnt);
len2 = sprintf (str2, "%d", JpiTqCnt);
if (len2 > len1) len1 = len2; else len2 = len1;
col4 = sprintf (DioString, "%*.*s/%d", len1, len1, str1, JpiDioLm);
colen = sprintf (TqString, "%*.*s/%d", len2, len2, str2, JpiTqLm);
if (colen > col4) col4 = colen;
ScrPtr += sprintf (ScrPtr, "%s\r\n\ %sProcess:%s ",
ANSIceol, ANSIbold, ANSInormal);
if (StatePtr)
ScrPtr += sprintf (ScrPtr, "%s %s %s", ANSIreverse, StatePtr, ANSInormal);
else
ScrPtr += sprintf (ScrPtr, "%s", JpiPrcNam);
ScrPtr += sprintf (ScrPtr,
" %sPID:%s %08.08X %sUser:%s %s %sVersion:%s %s\
%s\r\n\
%sUp:%s %s %sCPU:%s %d %02.02d:%02.02d:%02.02d.%02.02d\
%sStartup:%s %d%s\
%s\r\n\
%sPg.Flts:%s %d %sPg.Used:%s %d%% %sWsSize:%s %d %sWsPeak:%s %d\
%s\r\n\
%sAST:%s %-*s %sBIO:%s %-*s %sBYT:%s %-*s %sDIO:%s %-*s\
%s\r\n\
%sENQ:%s %-*s %sFIL:%s %-*s %sPRC:%s %-*s %sTQ:%s %-*s\
%s\r\n",
ANSIbold, ANSInormal,
HttpdPid,
ANSIbold, ANSInormal,
JpiUserName,
ANSIbold, ANSInormal,
HttpdGblSecPtr->HttpdVersion,
ANSIceol,
ANSIbold, ANSInormal,
UpTimePtr,
ANSIbold, ANSInormal,
JpiCpuTime / 8640000, /* CPU day */
(JpiCpuTime % 8640000) / 360000, /* CPU hour */
(JpiCpuTime % 360000) / 6000, /* CPU minute */
(JpiCpuTime % 6000 ) / 100, /* CPU second */
JpiCpuTime % 100, /* CPU 10mS */
ANSIbold, ANSInormal,
AccountingPtr->StartupCount,
LastExitStatus,
ANSIceol,
ANSIbold, ANSInormal,
JpiPageFlts,
ANSIbold, ANSInormal,
100-PercentOf(JpiPagFilCnt,JpiPgFlQuota),
ANSIbold, ANSInormal,
JpiWsSize,
ANSIbold, ANSInormal,
JpiWsPeak,
ANSIceol,
ANSIbold, ANSInormal,
col1, AstString,
ANSIbold, ANSInormal,
col2, BioString,
ANSIbold, ANSInormal,
col3, BytString,
ANSIbold, ANSInormal,
col4, DioString,
ANSIceol,
ANSIbold, ANSInormal,
col1, EnqString,
ANSIbold, ANSInormal,
col2, FilString,
ANSIbold, ANSInormal,
col3, PrcString,
ANSIbold, ANSInormal,
col4, TqString,
ANSIceol);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Add the HTTPd server counter information to the screen buffer from the count
logical. The information in this logical is binary data in the form of the
HTTPd count data structure. This is used to extract each field member from
the data.
*/
int AddGeneralInfo ()
{
static int ErrorsNoticedCount;
static char NCScounts [48] = "",
WebSockOrNoticed [96];
int idx, status,
CodeGroup,
ConnectTotalCount,
DigitCount,
CurrentThrottleProcessing,
CurrentThrottleQueued,
CurrentWebSockets;
char *bpsptr;
char BytesRawRx [32],
BytesRawTx [32],
CurrentProcessingString [128],
CurrentProcessCountString [16],
Four03s [16];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "AddGeneralInfo()\n");
ConnectTotalCount = AccountingPtr->ConnectIpv4Count +
AccountingPtr->ConnectIpv6Count;
if (DoAlertAll)
if (PrevConnectCount && ConnectTotalCount > PrevConnectCount)
fputs ("\x07", stdout);
PrevConnectCount = ConnectTotalCount;
/* double-up on the real estate */
if (AccountingPtr->ErrorsNoticedCount &&
AccountingPtr->ErrorsNoticedCount != ErrorsNoticedCount)
{
sprintf (WebSockOrNoticed, "%sNoticed:%s %d",
ANSIbold, ANSInormal,
AccountingPtr->ErrorsNoticedCount);
ErrorsNoticedCount = AccountingPtr->ErrorsNoticedCount;
}
else
sprintf (WebSockOrNoticed, "%sWS:%s %d/%d%% %sBusy:%s %d",
ANSIbold, ANSInormal,
AccountingPtr->DclWebSocketCount,
PercentOf(AccountingPtr->DclWebSocketCount,
AccountingPtr->ProcessingTotalCount[HTTP12]),
ANSIbold, ANSInormal,
AccountingPtr->ConnectTooBusyCount);
if (AccountingPtr->NcsConvertCount)
sprintf (NCScounts, " %sNCS:%s %d/%d",
ANSIbold, ANSInormal,
AccountingPtr->NcsCount,
AccountingPtr->NcsConvertCount);
DigitCount = 0;
for (idx = 0; idx <= 5; idx++)
{
if (idx == 1) continue;
CodeGroup = AccountingPtr->ResponseStatusCodeGroup[idx];
DigitCount++;
while (CodeGroup /= 10) DigitCount++;
}
CodeGroup = AccountingPtr->RequestForbiddenCount;
DigitCount++;
while (CodeGroup /= 10) DigitCount++;
if (DigitCount > 35)
Four03s[0] = '\0';
else
if (DigitCount > 31)
sprintf (Four03s, " (%d)", AccountingPtr->RequestForbiddenCount);
else
sprintf (Four03s, " (403:%d)", AccountingPtr->RequestForbiddenCount);
CommaNumber (64, &AccountingPtr->BytesRawRx64, BytesRawRx);
CommaNumber (64, &AccountingPtr->BytesRawTx64, BytesRawTx);
sprintf (CurrentProcessCountString, "/%d", CurrentProcessCount);
if (HttpdGblSecPtr->ConnectSuspend)
sprintf (CurrentProcessingString, " %s%s S U S P E N D %s%s",
ANSIreverse, ANSIbold, ANSInormal, ANSInormal);
else
if (HttpdGblSecPtr->InstancePassive)
sprintf (CurrentProcessingString, " %s%s P A S S I V E %s%s",
ANSIreverse, ANSIbold, ANSInormal, ANSInormal);
else
CurrentProcessingString[0] = '\0';
for (CurrentWebSockets = idx = 0;
idx <= HttpdGblSecPtr->InstanceNodeCurrent;
idx++) CurrentWebSockets += AccountingPtr->CurrentWebSockets[idx];
for (CurrentThrottleProcessing = idx = 0;
idx <= HttpdGblSecPtr->InstanceNodeCurrent;
idx++) CurrentThrottleProcessing +=
AccountingPtr->CurrentThrottleProcessing[idx];
for (CurrentThrottleQueued = idx = 0;
idx <= HttpdGblSecPtr->InstanceNodeCurrent;
idx++) CurrentThrottleQueued +=
AccountingPtr->CurrentThrottleQueued[idx];
bpsptr = BytesPerString (AccountingPtr->BytesPerSecondAve);
ScrPtr += sprintf (ScrPtr,
"%s%s\r\n\
%sRequest:%s %d %sCurrent:%s %d/%d/%d/%d \
%sThrottle:%s %d/%d/%d%% %sPeak:%s %d/%d\
%s\r\n\
%sHTTP/2:%s %d/%d%% %s/1.n:%s %d/%d%% %sSSL:%s %d/%d%% %s\
%s\r\n\
%sCONNECT:%s %d %sGET:%s %d %sHEAD:%s %d %sPOST:%s %d %sPUT:%s %d (%d)\
%s\r\n\
%sAdmin:%s %d %sCache:%s %d/%d/%d %sDECnet:%s %d/%d %sDir:%s %d%s%s\r\n\
%sDCL:%s CGI:%d CGIplus:%d/%d RTE:%d/%d Prc:%d%s Prct:%d\
%s\r\n\
%sFile:%s %d/%d %sProxy:%s %d\
%sPut:%s %d %sSSI:%s %d %sWebDAV:%s %d/%d\
%s\r\n\
%s\r\n\
%s0xx:%s %d %s2xx:%s %d %s3xx:%s %d %s4xx:%s %d%s %s5xx:%s %d\
%s\r\n\
%sRx:%s %s (%d err) %sTx:%s %s (%d err) (%s)\
%s\r\n",
CurrentProcessingString, ANSIceol,
ANSIbold, ANSInormal,
AccountingPtr->ProcessingTotalCount[HTTP12],
ANSIbold, ANSInormal,
AccountingPtr->CurrentConnected[HTTP12],
AccountingPtr->CurrentProcessing[HTTP12],
CurrentWebSockets,
HttpdGblSecPtr->ProxyAccounting.TunnelCurrent,
ANSIbold, ANSInormal,
CurrentThrottleProcessing,
CurrentThrottleQueued,
AccountingPtr->ThrottleBusyMetric,
ANSIbold, ANSInormal,
AccountingPtr->ConnectPeak[HTTP12],
AccountingPtr->ProcessingPeak[HTTP12],
ANSIceol,
ANSIbold, ANSInormal,
AccountingPtr->ProcessingTotalCount[HTTP2],
PercentOf(AccountingPtr->ProcessingTotalCount[HTTP2],
AccountingPtr->ProcessingTotalCount[HTTP12]),
ANSIbold, ANSInormal,
AccountingPtr->ProcessingTotalCount[HTTP1],
PercentOf(AccountingPtr->ProcessingTotalCount[HTTP1],
AccountingPtr->ProcessingTotalCount[HTTP12]),
ANSIbold, ANSInormal,
AccountingPtr->ConnectSSLCount,
PercentOf(AccountingPtr->ConnectSSLCount,
AccountingPtr->ConnectAcceptedCount),
WebSockOrNoticed,
ANSIceol,
ANSIbold, ANSInormal,
AccountingPtr->MethodConnectCount,
ANSIbold, ANSInormal,
AccountingPtr->MethodGetCount,
ANSIbold, ANSInormal,
AccountingPtr->MethodHeadCount,
ANSIbold, ANSInormal,
AccountingPtr->MethodPostCount,
ANSIbold, ANSInormal,
AccountingPtr->MethodPutCount,
AccountingPtr->MethodDeleteCount +
AccountingPtr->MethodExtensionCount +
AccountingPtr->MethodOptionsCount +
AccountingPtr->MethodTraceCount,
ANSIceol,
ANSIbold, ANSInormal,
AccountingPtr->DoServerAdminCount,
ANSIbold, ANSInormal,
AccountingPtr->CacheLoadCount,
AccountingPtr->CacheHitCount,
AccountingPtr->CacheHitNotModifiedCount,
ANSIbold, ANSInormal,
AccountingPtr->DoDECnetCgiCount,
AccountingPtr->DoDECnetOsuCount,
ANSIbold, ANSInormal,
AccountingPtr->DoDirectoryCount,
NCScounts,
ANSIceol,
ANSIbold, ANSInormal,
AccountingPtr->DoScriptCount,
AccountingPtr->DoCgiPlusScriptCount,
AccountingPtr->DclCgiPlusReusedCount,
AccountingPtr->DoRteScriptCount,
AccountingPtr->DclRteReusedCount,
AccountingPtr->DclCrePrcCount,
CurrentProcessCountString,
AccountingPtr->DclProctorCount,
ANSIceol,
ANSIbold, ANSInormal,
AccountingPtr->DoFileCount,
AccountingPtr->DoFileNotModifiedCount,
ANSIbold, ANSInormal,
AccountingPtr->DoProxyCount,
ANSIbold, ANSInormal,
AccountingPtr->DoPutCount,
ANSIbold, ANSInormal,
AccountingPtr->DoSsiCount,
ANSIbold, ANSInormal,
AccountingPtr->DoWebDavCount,
AccountingPtr->MethodWebDavCopyCount +
AccountingPtr->MethodWebDav_DeleteCount +
AccountingPtr->MethodWebDav_GetCount +
AccountingPtr->MethodWebDavLockCount +
AccountingPtr->MethodWebDavMkColCount +
AccountingPtr->MethodWebDavMoveCount +
AccountingPtr->MethodWebDav_OptionsCount +
AccountingPtr->MethodWebDavPropFindCount +
AccountingPtr->MethodWebDavPropPatchCount +
AccountingPtr->MethodWebDav_PutCount +
AccountingPtr->MethodWebDavUnLockCount,
ANSIceol,
ANSIceol,
ANSIbold, ANSInormal,
AccountingPtr->ResponseStatusCodeGroup[0],
ANSIbold, ANSInormal,
AccountingPtr->ResponseStatusCodeGroup[2],
ANSIbold, ANSInormal,
AccountingPtr->ResponseStatusCodeGroup[3],
ANSIbold, ANSInormal,
AccountingPtr->ResponseStatusCodeGroup[4],
Four03s,
ANSIbold, ANSInormal,
AccountingPtr->ResponseStatusCodeGroup[5],
ANSIceol,
ANSIbold, ANSInormal,
BytesRawRx,
AccountingPtr->NetReadErrorCount,
ANSIbold, ANSInormal,
BytesRawTx,
AccountingPtr->NetWriteErrorCount,
bpsptr,
ANSIceol);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Add the HTTPd server counter information to the screen buffer from the count
logical. The information in this logical is binary data in the form of the
HTTPd count data structure. This is used to extract each field member from
the data.
*/
int AddProxyInfo ()
{
static int FreeSpaceAlertCount;
int idx, status,
ConnectTotalCount,
CountNetwork,
CountTotal,
FreeBlocks,
FreeMBytes,
PercentCountNetwork,
ErrorCount,
FreePercent,
TotalMBytes,
TotalBlocks,
UsedBlocks,
UsedMBytes,
UsedPercent;
int64 BytesRaw64,
BytesTotal64;
char BytesRawRx [32],
BytesRawTx [32],
ConnectString [128];
char *cptr, *sptr,
*DevNamePtr,
*EnabledPtr,
*SpaceAvailablePtr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "AddProxyInfo()\n");
ConnectTotalCount = AccountingPtr->ConnectIpv4Count +
AccountingPtr->ConnectIpv6Count;
if (!DoGeneralInfo)
{
if (DoAlertAll)
if (PrevConnectCount && ConnectTotalCount > PrevConnectCount)
fputs ("\x07", stdout);
PrevConnectCount = ConnectTotalCount;
}
if (HttpdGblSecPtr->ProxyAccounting.ServingEnabled)
EnabledPtr = "enabled";
else
EnabledPtr = "DISABLED";
/*********/
/* bytes */
/*********/
status = lib$addx (&HttpdGblSecPtr->ProxyAccounting.BytesRawRx64,
&HttpdGblSecPtr->ProxyAccounting.BytesRawTx64,
&BytesRaw64, 0);
if (Debug) fprintf (stdout, "lib$addx() %%X%08.08X\n", status);
CommaNumber (64, &HttpdGblSecPtr->ProxyAccounting.BytesRawRx64, BytesRawRx);
CommaNumber (64, &HttpdGblSecPtr->ProxyAccounting.BytesRawTx64, BytesRawTx);
CountTotal = HttpdGblSecPtr->ProxyAccounting.ConnectIpv4Count +
HttpdGblSecPtr->ProxyAccounting.ConnectIpv6Count;
/***********/
/* display */
/***********/
if (DoGeneralInfo)
ConnectString[0] = '\0';
else
sprintf (ConnectString, " %sConnect:%s Current:%d Peak:%d",
ANSIbold, ANSInormal,
AccountingPtr->CurrentConnected[HTTP12],
AccountingPtr->ConnectPeak[HTTP12]);
ScrPtr += sprintf (ScrPtr,
"%s\r\n\
%sProxy:%s %s%s\
%s\r\n\
%sCONNECT:%s %d %sGET:%s %d %sHEAD:%s %d \
%sPOST:%s %d %sPUT:%s %d %sOther:%s %d\
%s\r\n\
%sFTP:%s Count:%d Login.Fail:%d DOS:%d VMS:%d Unix:%d ?:%d\
%s\r\n\
Dele:%d List:%d Retr:%d Stor:%d\
%s\r\n\
%sSOCKS5:%s Count:%d Success:%d Fail:%d\
%s\r\n\
%sRework:%s Count:%d No.Type:%d Search:%d Replace:%d Too.Big:%d\
%s\r\n\
%sNetwork:%s Rx:%s Tx:%s\
%s\r\n\
%sLookup:%s Literal:%d DNS:%d Cache:%d Error:%d\
%s\r\n",
ANSIceol,
ANSIbold, ANSInormal,
EnabledPtr,
ConnectString,
ANSIceol,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.MethodConnectCount,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.MethodGetCount,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.MethodHeadCount,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.MethodPostCount,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.MethodPutCount,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.MethodDeleteCount +
HttpdGblSecPtr->ProxyAccounting.MethodExtensionCount +
HttpdGblSecPtr->ProxyAccounting.MethodOptionsCount +
HttpdGblSecPtr->ProxyAccounting.MethodTraceCount,
ANSIceol,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.FtpCount,
HttpdGblSecPtr->ProxyAccounting.FtpLoginFailCount,
HttpdGblSecPtr->ProxyAccounting.FtpDosCount,
HttpdGblSecPtr->ProxyAccounting.FtpVmsCount,
HttpdGblSecPtr->ProxyAccounting.FtpUnixCount,
HttpdGblSecPtr->ProxyAccounting.FtpUnknownCount,
ANSIceol,
HttpdGblSecPtr->ProxyAccounting.FtpDeleCount,
HttpdGblSecPtr->ProxyAccounting.FtpListCount,
HttpdGblSecPtr->ProxyAccounting.FtpRetrCount,
HttpdGblSecPtr->ProxyAccounting.FtpStorCount,
ANSIceol,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.Socks5Count,
HttpdGblSecPtr->ProxyAccounting.Socks5SuccessCount,
HttpdGblSecPtr->ProxyAccounting.Socks5FailCount,
ANSIceol,
ANSIbold, ANSInormal,
HttpdGblSecPtr->ProxyAccounting.ReworkCount,
HttpdGblSecPtr->ProxyAccounting.ReworkNoType,
HttpdGblSecPtr->ProxyAccounting.ReworkReplaceSearch,
HttpdGblSecPtr->ProxyAccounting.ReworkReplaceCount,
HttpdGblSecPtr->ProxyAccounting.ReworkTooBig,
ANSIceol,
ANSIbold, ANSInormal,
BytesRawRx,
BytesRawTx,
ANSIceol,
ANSIbold, ANSInormal,
AccountingPtr->LookupLiteralCount,
AccountingPtr->LookupDnsNameCount,
AccountingPtr->LookupCacheNameCount,
AccountingPtr->LookupDnsNameErrorCount,
ANSIceol);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Add the information about the latest request to the screen buffer from the
request logical. Each plain-text string in this logical is terminated by a
null character.
*/
int AddRequest ()
{
static int PathAlertBellCount = 0,
PrevPathAlertCount = 0;
static char *LookupHostNamePtr;
BOOL IsHostName,
IsIpAddr;
int status,
BytesLength,
StringLength;
double dValue;
char *bptr, *bpsptr, *cptr, *sptr, *tptr;
char BytesRawRx [32],
BytesRawTx [32],
BytesTxGzipPercent [8];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "AddRequest()\n");
CommaNumber (64, &HttpdGblSecPtr->Request.BytesRawRx64, BytesRawRx);
CommaNumber (64, &HttpdGblSecPtr->Request.BytesRawTx64, BytesRawTx);
if (HttpdGblSecPtr->Request.BytesTxGzipPercent)
sprintf (BytesTxGzipPercent, " (%d%%)",
HttpdGblSecPtr->Request.BytesTxGzipPercent);
else
BytesTxGzipPercent[0] = '\0';
sptr = ScrPtr;
sptr += sprintf (sptr,
"%s\r\n %sTime:%s %s %sStatus:%s %03d \
%sRx:%s %s %sTx:%s %s%s %sDur:%s %s",
ANSIceol, ANSIbold, ANSInormal,
HttpdGblSecPtr->Request.Time,
ANSIbold, ANSInormal,
HttpdGblSecPtr->Request.HttpStatus,
ANSIbold, ANSInormal,
BytesRawRx,
ANSIbold, ANSInormal,
BytesRawTx, BytesTxGzipPercent,
ANSIbold, ANSInormal,
HttpdGblSecPtr->Request.Duration);
bpsptr = BytesPerString (HttpdGblSecPtr->Request.BytesPerSecond);
sptr += sprintf (sptr,
"%s\r\n\
%sService:%s %s%s%s%s",
ANSIceol, ANSIbold, ANSInormal,
HttpdGblSecPtr->Request.Service,
HttpdGblSecPtr->Request.PrcNam[0] ? " (" : "",
HttpdGblSecPtr->Request.PrcNam,
HttpdGblSecPtr->Request.PrcNam[0] ? ")" : "");
switch (HttpdGblSecPtr->Request.HttpProtocol)
{
case HTTP_VERSION_2 : cptr = " HTTP/2"; break;
case HTTP_VERSION_1_1 : cptr = "HTTP/1.1"; break;
case HTTP_VERSION_1_0 : cptr = "HTTP/1.0"; break;
case HTTP_VERSION_0_9 : cptr = "HTTP/0.9"; break;
default : cptr = "";
}
BytesLength = strlen(BytesRawRx) +
strlen(BytesRawTx) +
strlen(BytesTxGzipPercent);
StringLength = 41 + BytesLength;
StringLength -= 11;
StringLength -= strlen(HttpdGblSecPtr->Request.Service);
if (HttpdGblSecPtr->Request.PrcNam[0])
StringLength -= strlen(HttpdGblSecPtr->Request.PrcNam) + 3;
if (StringLength < 2) StringLength = 2;
while (StringLength--) *sptr++ = ' ';
sptr += sprintf (sptr, "%s (%s)", cptr, bpsptr);
sptr += sprintf (sptr,
"%s\r\n\
%sHost:%s ",
ANSIceol, ANSIbold, ANSInormal);
cptr = HttpdGblSecPtr->Request.ClientHostName;
if (strcmp (cptr, PrevHostName))
{
strcpy (PrevHostName, cptr);
LookupHostNamePtr = NULL;
if (DoAlertHost) fputs ("\x07", stdout);
}
if (DoAlertPath && HttpdGblSecPtr->Request.Alert)
{
if (AccountingPtr->PathAlertCount > PrevPathAlertCount)
{
PrevPathAlertCount = AccountingPtr->PathAlertCount;
PathAlertBellCount = PathAlertBellRepetition;
}
}
if (PathAlertBellCount)
{
fputs ("\x07", stdout);
PathAlertBellCount--;
}
/* check for IPv4 address */
tptr = cptr;
/* if an IPv6 compressed IPv4 address */
if (!strncmp (tptr, "::FFFF:", 7)) tptr += 7;
while (isdigit(*tptr) || *tptr == '.') tptr++;
if (*tptr)
{
/* nope, check for IPv6 address */
for (tptr = cptr;
isxdigit(*tptr) || *tptr == ':' ||
*tptr == '-' || *tptr == '.';
tptr++);
}
IsHostName = !(IsIpAddr = (*tptr == '\0'));
if (*(ulong*)(tptr = cptr) == '::FF') tptr += 7;
if (DoLookupHost)
if (IsIpAddr)
if (tptr = LookupHostName (tptr))
if (IsHostName = (*tptr != '?' && *tptr != '!'))
cptr = tptr;
StringLength = strlen(cptr);
StringLength += strlen (HttpdGblSecPtr->Request.ClientIpAddressString);
/* excise some middle section if it would overflow the line */
if (StringLength > 80-14)
{
while (*cptr && *cptr != '.') *sptr++ = *cptr++;
*sptr++ = '.';
*sptr++ = '.';
while (*cptr && --StringLength > 80-14) cptr++;
while (*cptr && *cptr != '.') cptr++;
}
while (*cptr) *sptr++ = *cptr++;
if (IsHostName)
{
*sptr++ = ' ';
*sptr++ = '(';
for (cptr = HttpdGblSecPtr->Request.ClientIpAddressString;
*cptr;
*sptr++ = *cptr++);
*sptr++ = ')';
}
if (HttpdGblSecPtr->Request.ReadError[0])
{
sptr += sprintf (sptr, "%s\r\n %sRx-ERR:%s ",
ANSIceol, ANSIbold, ANSInormal);
tptr = sptr + 68;
for (cptr = HttpdGblSecPtr->Request.ReadError;
*cptr && sptr < tptr;
*sptr++ = *cptr++);
}
if (HttpdGblSecPtr->Request.WriteError[0])
{
sptr += sprintf (sptr, "%s\r\n %sTx-ERR:%s ",
ANSIceol, ANSIbold, ANSInormal);
tptr = sptr + 68;
for (cptr = HttpdGblSecPtr->Request.WriteError;
*cptr && sptr < tptr;
*sptr++ = *cptr++);
}
sptr += sprintf (sptr, "%s\r\n %sRequest:%s %s",
ANSIceol, ANSIbold, ANSInormal,
HttpdGblSecPtr->Request.Alert ? ANSIbold : "");
/* limit the request string to 3 x 80 character lines minus field name */
tptr = sptr + 226;
/* allow for foregoing error reports */
if (HttpdGblSecPtr->Request.ReadError[0]) tptr -= 80;
if (HttpdGblSecPtr->Request.WriteError[0]) tptr -= 80;
if (HttpdGblSecPtr->Request.AuthUser[0])
tptr -= strlen(HttpdGblSecPtr->Request.AuthUser) + 3;
if (tptr < sptr) tptr = sptr;
for (cptr = HttpdGblSecPtr->Request.MethodName;
*cptr && sptr < tptr;
*sptr++ = *cptr++);
if (HttpdGblSecPtr->Request.Uri[0] && sptr < tptr) *sptr++ = ' ';
for (cptr = HttpdGblSecPtr->Request.Uri; *cptr && sptr < tptr; cptr++)
if ((*cptr >= 0x20 && *cptr <= 0x7e) ||
(*cptr >= 0xa0 && *cptr <= 0xfe))
*sptr++ = *cptr; else *sptr++ = '.';
if (sptr >= tptr)
sptr += sprintf (sptr, "%s...%s", ANSIbold, ANSInormal);
else
if (HttpdGblSecPtr->Request.Alert)
sptr += sprintf (sptr, "%s", ANSInormal);
if (HttpdGblSecPtr->Request.AuthUser[0])
sptr += sprintf (sptr, " (%s)", HttpdGblSecPtr->Request.AuthUser);
sptr += sprintf (sptr, "%s", ANSIceol);
ScrPtr = sptr;
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
*/
int AddStatusMessage ()
{
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "AddStatusMessage()\n");
ScrPtr += sprintf (ScrPtr, "%s\r\n %sSTATUS:%s %s%s",
ANSIceos, ANSIbold, ANSInormal,
HttpdGblSecPtr->StatusMessage, ANSIceol);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
*/
int CheckHttpdPid (void)
{
static unsigned long JpiPid;
static struct
{
unsigned short buf_len;
unsigned short item;
unsigned char *buf_addr;
void *ret_len;
}
JpiItems [] =
{
{ sizeof(JpiPid), JPI$_PID, &JpiPid, 0 },
{0,0,0,0}
};
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "CheckHttpdPid() %08.08X\n", HttpdPid);
return (sys$getjpiw (0, &HttpdPid, 0, &JpiItems, 0, 0, 0));
}
/*****************************************************************************/
/*
Calculate percentages of unsigned longs using floats to avoid integer overflow
and allowing more accurate rounding.
*/
int PercentOf
(
unsigned long arg1,
unsigned long arg2
)
{
int iperc;
float farg1, farg2, fperc;
/*********/
/* begin */
/*********/
if (arg2)
{
farg1 = (float)arg1;
farg2 = (float)arg2;
fperc = farg1 * 100.0 / farg2;
iperc = (int)fperc;
if (fperc - (float)iperc >= 0.5) iperc++;
return (iperc);
}
return (0);
}
/*****************************************************************************/
/*
Calculate percentages of quadwards using floats to avoid overflow and allowing
more accurate rounding.
*/
int QuadPercentOf
(
unsigned long *qarg1,
unsigned long *qarg2
)
{
int iqperc;
float fqarg1, fqarg2, fqperc;
/*********/
/* begin */
/*********/
if (qarg2[0] || qarg2[1])
{
fqarg1 = (float)qarg1[0] + ((float)qarg1[1] * 4294967296.0);
fqarg2 = (float)qarg2[0] + ((float)qarg2[1] * 4294967296.0);
if (fqarg2 == 0.0) return (0);
fqperc = fqarg1 * 100.0 / fqarg2;
iqperc = (int)fqperc;
if (fqperc - (float)iqperc >= 0.5) iqperc++;
return (iqperc);
}
return (0);
}
/*****************************************************************************/
/*
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!
If the number of servers varies then (by default) sound the bell!!
*/
GetInstanceInformation ()
{
static int PrevClusterCount = -1,
PrevNodeCount = -1;
static char ClusterLockName [32],
NodeLockName [32],
PrevInstanceString [32];
static $DESCRIPTOR (ClusterLockNameDsc, ClusterLockName);
static $DESCRIPTOR (NodeLockNameDsc, NodeLockName);
static LKIDEF LkiLocks [32];
static struct lksb ClusterLockLksb,
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, status,
ClusterCount,
LockCount,
LockNameMagic,
NodeCount,
NonNlLockCount;
char *cptr, *sptr, *zptr;
IOSBLK IOsb;
LKIDEF *lkiptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "GetInstanceInformation()\n");
status = sys$setprv (1, &SysLckMask, 0, 0);
if (status == SS$_NOTALLPRIV) exit (SS$_NOPRIV);
if (!ClusterLockName[0])
{
if (InstanceEnvNumber > INSTANCE_ENV_NUMBER_MAX)
{
fprintf (stdout, "%%%s-E-INSTANCE, group number range 1 to %d\n",
Utility, INSTANCE_ENV_NUMBER_MAX);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
/* a byte comprising two 4 bit fields, version and server group number */
LockNameMagic = ((HTTPD_LOCK_VERSION & 0xf) << 4) |
(InstanceEnvNumber & 0xf);
/* build the (binary) resource name for the cluster lock */
zptr = (sptr = ClusterLockName) + sizeof(ClusterLockName)-1;
for (cptr = HTTPD_NAME; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (sptr < zptr) *sptr++ = (char)LockNameMagic;
if (sptr < zptr) *sptr++ = (char)INSTANCE_CLUSTER;
ClusterLockNameDsc.dsc$w_length = sptr - ClusterLockName;
if (Debug) fprintf (stdout, "cluster: |%*.*s|\n",
ClusterLockNameDsc.dsc$w_length,
ClusterLockNameDsc.dsc$w_length,
ClusterLockNameDsc.dsc$a_pointer);
/* enqueue a just-interested NL lock */
status = sys$enqw (0, LCK$K_NLMODE, &ClusterLockLksb,
LCK$M_EXPEDITE | LCK$M_SYSTEM,
&ClusterLockNameDsc, 0, 0, 0, 0, 0, 2, 0);
if (VMSok (status)) status = ClusterLockLksb.lksb$w_status;
if (VMSnok (status)) exit (status);
/* 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)INSTANCE_NODE;
NodeLockNameDsc.dsc$w_length = sptr - NodeLockName;
if (Debug) fprintf (stdout, "node: |%*.*s|\n",
NodeLockNameDsc.dsc$w_length,
NodeLockNameDsc.dsc$w_length,
NodeLockNameDsc.dsc$a_pointer);
/* 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)) exit (status);
}
/* get and count the cluster instance locks */
status = sys$getlkiw (0, &ClusterLockLksb.lksb$l_lkid, &LkiItems, &IOsb,
0, 0, 0);
if (VMSok (status)) status = ClusterLockLksb.lksb$w_status;
if (VMSnok (status)) exit (status);
if (ReturnLength.LockLength)
{
/* if insufficient buffer space */
if (ReturnLength.LockLength & 0x8000) exit (SS$_BADPARAM);
LockCount = ReturnLength.TotalLength / ReturnLength.LockLength;
}
else
LockCount = 0;
if (Debug) fprintf (stdout, "cluster LockCount: %d\n", LockCount);
ClusterCount = 0;
lkiptr = &LkiLocks;
for (cnt = LockCount; cnt; cnt--)
{
if (Debug) fprintf (stdout, "1 lki$b_grmode: %d\n", lkiptr->lki$b_grmode);
if (lkiptr->lki$b_grmode != LCK$K_NLMODE) ClusterCount++;
lkiptr++;
}
/* 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)) exit (status);
if (ReturnLength.LockLength)
{
/* if insufficient buffer space */
if (ReturnLength.LockLength & 0x8000) exit (SS$_BADPARAM);
LockCount = ReturnLength.TotalLength / ReturnLength.LockLength;
}
else
LockCount = 0;
if (Debug) fprintf (stdout, "node LockCount: %d\n", LockCount);
NodeCount = 0;
lkiptr = &LkiLocks;
for (cnt = LockCount; cnt; cnt--)
{
if (Debug) fprintf (stdout, "2 lki$b_grmode: %d\n", lkiptr->lki$b_grmode);
if (lkiptr->lki$b_grmode != LCK$K_NLMODE) NodeCount++;
lkiptr++;
}
if (++InstanceCount > NodeCount) InstanceCount = 1;
NextInstancePid = NonNlLockCount = 0;
lkiptr = &LkiLocks;
for (cnt = LockCount; cnt; cnt--)
{
if (Debug) fprintf (stdout, "3 lki$b_grmode: %d\n", lkiptr->lki$b_grmode);
if (lkiptr->lki$b_grmode != LCK$K_NLMODE)
{
NonNlLockCount++;
if (Debug) fprintf (stdout, "%d %d\n", InstanceCount, NonNlLockCount);
if (InstanceCount == NonNlLockCount)
{
if (Debug) fprintf (stdout, "lki$l_pid: %08x\n", lkiptr->lki$l_pid);
NextInstancePid = lkiptr->lki$l_pid;
break;
}
}
lkiptr++;
}
sys$setprv (0, &SysLckMask, 0, 0);
/* build the string */
if (PrevClusterCount < 0)
{
/* initialize */
PrevClusterCount = ClusterCount;
PrevNodeCount = NodeCount;
}
if (NodeCount != PrevNodeCount || ClusterCount != PrevClusterCount)
{
sptr = PrevInstanceString;
*sptr++ = '(';
for (cptr = InstanceString + sizeof(ANSIbold)-1;
isdigit(*cptr) || *cptr == '/';
*sptr++ = *cptr++);
*sptr++ = ')';
*sptr = '\0';
}
sptr = InstanceString;
sprintf (sptr, "%s%d", ANSIbold, NodeCount);
while (*sptr) sptr++;
if (SyiClusterNodes > 1)
{
sprintf (sptr, "/%d", ClusterCount);
while (*sptr) sptr++;
}
strcpy (sptr, ANSInormal);
while (*sptr) sptr++;
if (PrevInstanceString[0])
{
for (cptr = PrevInstanceString; *cptr; *sptr++ = *cptr++);
*sptr = '\0';
}
/* determine the length before adding the non-displaying bells!! */
InstanceStringLength = sptr - InstanceString;
InstanceStringLength -= sizeof(ANSIbold)-1 + sizeof(ANSInormal)-1;
if (NodeCount != PrevNodeCount || ClusterCount != PrevClusterCount)
{
PrevClusterCount = ClusterCount;
PrevNodeCount = NodeCount;
for (cptr = "\x07\x07\x07"; *cptr; *sptr++ = *cptr++);
*sptr = '\0';
}
if (Debug) fprintf (stdout, "InstanceString: |%s|\n", InstanceString);
}
/*****************************************************************************/
/*
See [SRC.HTTPD]INSTANCE.C InstanceCliReport().
*/
void AddInstanceStatus ()
{
static ulong LibDeltaMins = LIB$K_DELTA_MINUTES;
BOOL stale;
int idx, len, maxtab, maxlen, status, total;
ulong MinsAgo;
char *cptr;
char ExitAgoBuf [16],
ExitStatusBuf [16],
LineBuffer [256],
StartAgoBuf [16],
TmpAgoBuf [16],
UpdateAgoBuf [16];
INSTANCE_STATUS *istptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "AddInstanceStatus() %d\n", PageLength);
maxtab = AccountingPtr->InstanceStatusTableCount;
if (maxtab == 1 && !DoStatusInfo) return;
if (!DoStatusInfo)
{
if (PageLength <= 24) return;
if (PageLength < 24 + maxtab + 2) return;
}
for (idx = maxlen = 0; idx < maxtab; idx++)
{
istptr = &AccountingPtr->InstanceStatusTable[idx];
if ((len = strlen(istptr->InstanceName)) > maxlen) maxlen = len;
}
if (maxlen < 8) maxlen = 8;
ScrPtr += sprintf (ScrPtr,
"\r\n%s\r\n\
%s%-*s%s %s%4.4s%s %s%4.4s%s %s%5.5s%s %s%4.4s%s \
%s%-10s%s %s%7.7s%s %s%4.4s%s %s%6.6s%s\r\n",
ANSIceos,
ANSIbold, maxlen, "Instance", ANSInormal,
ANSIbold, " Ago", ANSInormal,
ANSIbold, " Up", ANSInormal,
ANSIbold, "Count", ANSInormal,
ANSIbold, "Exit", ANSInormal,
ANSIbold, "Status", ANSInormal,
ANSIbold, "Version", ANSInormal,
ANSIbold, "/Min", ANSInormal,
ANSIbold, " /Hour", ANSInormal);
for (idx = total = 0; idx < maxtab; idx++)
{
istptr = &AccountingPtr->InstanceStatusTable[idx];
/* if a purged entry */
if (!istptr->UpdateTime64) continue;
/* right justify each of these */
ThisLongAgo (&istptr->ExitTime64, TmpAgoBuf);
sprintf (ExitAgoBuf, "%4s", TmpAgoBuf);
ThisLongAgo (&istptr->StartTime64, TmpAgoBuf);
sprintf (StartAgoBuf, "%4s", TmpAgoBuf);
ThisLongAgo (&istptr->UpdateTime64, TmpAgoBuf);
sprintf (UpdateAgoBuf, "%4s", TmpAgoBuf);
if (istptr->ExitStatus)
sprintf (ExitStatusBuf, "%%X%08.08X", istptr->ExitStatus);
else
ExitStatusBuf[0] = '\0';
MinsAgo = (NowTime64 - istptr->UpdateTime64) / TIME64_ONE_MIN;
if (MinsAgo > INSTANCE_STATUS_STALE_MINS)
stale = true;
else
{
stale = false;
total++;
}
sprintf (LineBuffer,
"%s%-*s %4.4s %4.4s %5u %4.4s %10.10s %7.7s %4u %6u%s\r\n",
stale ? " -" : " ",
maxlen, istptr->InstanceName, UpdateAgoBuf,
StartAgoBuf, istptr->StartupCount,
ExitAgoBuf, ExitStatusBuf,
istptr->HttpdVersion,
istptr->MinuteCount,
istptr->HourCount,
stale ? "-" : "");
if (stale)
for (cptr = LineBuffer + 2; *cptr; cptr++)
if (*cptr == ' ') *cptr = '-';
ScrPtr += sprintf (ScrPtr, "%s", LineBuffer);
}
if (!total)
ScrPtr += sprintf (ScrPtr, " %s 0%s reset?\r\n", ANSIbold, ANSInormal);
ScrPtr -= 2;
*ScrPtr++ = ' ';
*ScrPtr++ = ' ';
*ScrPtr = '\0';
}
/*****************************************************************************/
/*
Format a string containing how many seconds, minutes, hours, days ago from the
current time. For example; "15s", "10m", "17h", "152d". Return VMS status.
|AgoBuf| should be at least 16 chars.
*/
void ThisLongAgo
(
int64 *Time64Ptr,
char *AgoBuf
)
{
static ulong LibDeltaSecs = LIB$K_DELTA_SECONDS;
static $DESCRIPTOR (AgoFaoDsc, "!UL!AZ\0");
static $DESCRIPTOR (AgoBufDsc, "");
int status;
ulong SecsAgo;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ThisLongAgo()\n");
AgoBuf[0] = '\0';
if (!*Time64Ptr) return (SS$_NORMAL);
SecsAgo = (NowTime64 - *Time64Ptr) / TIME64_ONE_SEC;
AgoBufDsc.dsc$a_pointer = AgoBuf;
AgoBufDsc.dsc$w_length = 16;
if (SecsAgo >= (60*60*24))
status = sys$fao (&AgoFaoDsc, 0, &AgoBufDsc, SecsAgo / (60*60*24), "d");
else
if (SecsAgo >= (60*60))
status = sys$fao (&AgoFaoDsc, 0, &AgoBufDsc, SecsAgo / (60*60), "h");
else
if (SecsAgo >= 60)
status = sys$fao (&AgoFaoDsc, 0, &AgoBufDsc, SecsAgo / 60, "m");
else
if (SecsAgo > 1)
status = sys$fao (&AgoFaoDsc, 0, &AgoBufDsc, SecsAgo, "s");
else
strcpy (AgoBuf, "now");
}
/*****************************************************************************/
/*
Development only.
*/
#define TCPIP_LOOKUP_HOST_NAME_RETRY 3
int AcpControl;
char* LookupHostName (ulong arg1)
{
char *sptr;
if (AcpControl)
sptr = LookupHostName2 (arg1);
else
{
sptr = TcpIpLookup (NULL, (char*)arg1, NULL, NULL);
if (*sptr == '[') return ("!");
}
return (sptr);
}
/*****************************************************************************/
/*
If |Name| is non-NULL lookup the IP address using the host name.
If |Address| is non-NULL lookup the host name using the address.
If the Ip4AddtrPtr and/or Ip6AddrPtr are non-NULL populate them.
Return either a pointer to the resolved host name or IP address string or an
error message between square brackets.
*/
char* TcpIpLookup
(
char *Name,
char *Address,
uchar *Ip4Addr,
uchar *Ip6Addr
)
{
#define CACHE_MAX 16
static aCacheIdx, nCacheIdx;
static char abuf [CACHE_MAX][256],
ares [CACHE_MAX][256],
nbuf [CACHE_MAX][256],
nres [CACHE_MAX][256];
int idx, retry, retval;
void *addptr;
struct sockaddr_in addr4;
struct sockaddr_in6 addr6;
struct addrinfo hints;
struct addrinfo *aiptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "TcpIpLookup() |%s|%s| %d %d\n",
Name, Address, Ip4Addr, Ip6Addr);
if (Ip4Addr) memset (Ip4Addr, 0, 4);
if (Ip6Addr) memset (Ip6Addr, 0, 16);
if (Name)
{
for (idx = 0; idx < CACHE_MAX; idx++)
if (!strcmp (nbuf[idx], Name))
return (nres[idx]);
idx = nCacheIdx++ % CACHE_MAX;
strcpy (nbuf[idx], Name);
aiptr = NULL;
memset (&hints, 0, sizeof(hints));
hints.ai_flags |= AI_CANONNAME;
retval = 0;
for (retry = TCPIP_LOOKUP_HOST_NAME_RETRY; retry; retry--)
{
retval = getaddrinfo (Name, NULL, &hints, &aiptr);
if (retval != EINTR && retval != EAI_AGAIN) break;
sleep (1);
}
if (retval)
{
if (retval == EAI_NONAME)
sprintf (nres[idx], "[unknown]");
else
if (retval == EAI_FAIL || retval == EAI_AGAIN)
sprintf (nres[idx], "[failed]");
else
sprintf (nres[idx], "[%s]", gai_strerror(retval));
return (nres[idx]);
}
else
{
if (aiptr->ai_family == AF_INET)
{
/* IPv4 */
addptr = &((struct sockaddr_in *)aiptr->ai_addr)->sin_addr;
if (Ip4Addr) memcpy (Ip4Addr, addptr, 4);
}
else
{
/* must be IPv6 */
addptr = &((struct sockaddr_in6 *)aiptr->ai_addr)->sin6_addr;
if (Ip6Addr) memcpy (Ip6Addr, addptr, 16);
}
if (!inet_ntop (aiptr->ai_family, addptr, nres[idx], sizeof(nres[0])))
sprintf (nres[idx], "[%s]", strerror(errno));
}
/* free the addrinfo */
freeaddrinfo(aiptr);
return (nres[idx]);
}
if (Address)
{
for (idx = 0; idx < CACHE_MAX; idx++)
if (!strcmp (abuf[idx], Address))
return (ares[idx]);
idx = aCacheIdx++ % CACHE_MAX;
strcpy (abuf[idx], Address);
retval = 0;
memset (&addr4, 0, sizeof(addr4));
if (inet_pton (AF_INET, Address, &addr4.sin_addr) > 0)
{
/* MultiNet does not support BSD 4.4 AF_INET addresses */
#ifdef NO_SOCKADDR_LEN_4
/* this kludge seems to work for both! */
*(USHORTPTR)&addr4 = AF_INET;
#else
addr4.sin_len = sizeof(struct sockaddr_in);
addr4.sin_family = AF_INET;
#endif
if (Ip4Addr)
memcpy (Ip4Addr, &addr4.sin_addr, sizeof(addr4.sin_addr));
for (retry = TCPIP_LOOKUP_HOST_NAME_RETRY; retry; retry--)
{
retval = getnameinfo ((struct sockaddr*)&addr4, sizeof(addr4),
ares[idx], sizeof(ares[0]),
NULL, 0, NI_NAMEREQD);
if (retval != EINTR && retval != EAI_AGAIN) break;
sleep (1);
}
if (retval)
{
if (retval == EAI_NONAME)
sprintf (ares[idx], "[unknown]");
else
if (retval == EAI_FAIL || retval == EAI_AGAIN)
sprintf (ares[idx], "[failed]");
else
sprintf (ares[idx], "[%s]", gai_strerror(retval));
}
return (ares[idx]);
}
else
{
memset (&addr6, 0, sizeof(addr6));
if (inet_pton (AF_INET6, Address, &addr6.sin6_addr) > 0)
{
addr6.sin6_len = sizeof(struct sockaddr_in6);
addr6.sin6_family = AF_INET6;
if (Ip6Addr)
memcpy (Ip6Addr, &addr6.sin6_addr, sizeof(addr6.sin6_addr));
for (retry = TCPIP_LOOKUP_HOST_NAME_RETRY; retry; retry--)
{
retval = getnameinfo ((struct sockaddr*)&addr6, addr6.sin6_len,
ares[idx], sizeof(ares[0]),
NULL, 0, NI_NAMEREQD);
if (retval != EINTR && retval != EAI_AGAIN) break;
sleep (1);
}
if (retval)
{
if (retval == EAI_NONAME)
sprintf (ares[idx], "[unknown]");
else
if (retval == EAI_FAIL || retval == EAI_AGAIN)
sprintf (ares[idx], "[failed]");
else
sprintf (ares[idx], "[%s]", gai_strerror(retval));
}
}
else
sprintf (ares[aCacheIdx], "[%s]", strerror(errno));
return (ares[idx]);
}
}
return ("[bugcheck]");
}
/*****************************************************************************/
/*
Get the IP name using asynchronous address-to-name lookup. Despite the implied
IPv6 functionality TCP/IP Services lookup only supports IPv4 (sigh, one day
perhaps).
Returns /%X00000014 %SYSTEM-F-BADPARAM, bad parameter value/ when fed an IPv6
address string.
There will always be a delay in the lookup because this function is
called during AST delivery, so buffer the IP addresses and host names. Returns
a pointer to the host name, to '?' during lookup, or '!' if not resolvable.
*/
char* LookupHostName2 (ulong arg1)
{
#define CACHE_MAX 128 /* absolute max is 1024 */
#define EXPIRE_SECONDS 300
#define RETRY_ATTEMPTS 5
#define RETRY_SECONDS 60
#define INETACP$C_TRANS 2
#define INETACP$C_HOSTENT_OFFSET 5
#define INETACP_FUNC$C_GETHOSTBYNAME 1
#define INETACP_FUNC$C_GETHOSTBYADDR 2
#define HOSTENT_SIZE 1024
struct LookupCacheStruct
{
int RetryCount;
ushort HostNameLength;
ulong ExpiresStamp;
uchar Ip4Address [4];
uchar Ip6Address [16];
char HostName [127+1],
IpAddrStr [31+1];
char *HostEntPtr;
struct dsc$descriptor HostEntDsc;
struct dsc$descriptor HostAddrDsc;
IOSBLK LookupIOsb;
};
static struct LookupCacheStruct LookupCache [CACHE_MAX];
static $DESCRIPTOR (TcpIpDeviceDsc, "UCX$DEVICE");
static unsigned char ControlSubFunction [4] =
{ INETACP_FUNC$C_GETHOSTBYADDR, INETACP$C_HOSTENT_OFFSET, 0, 0 };
static struct dsc$descriptor ControlSubFunctionDsc =
{ 4, DSC$K_DTYPE_T, DSC$K_CLASS_S, (char*)&ControlSubFunction };
static int CacheUsed;
static unsigned short LookupChannel;
int idx, status;
ulong ThisTimeStamp;
ulong ThisBinTime [2];
char *cptr, *sptr, *zptr;
struct LookupCacheStruct *lcptr;
struct hostent *heptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "LookupHostName() %d\n", arg1);
if (!LookupChannel)
{
/* assign a channel to the internet template device */
status = sys$assign (&TcpIpDeviceDsc, &LookupChannel, 0, 0);
if (VMSnok (status)) exit (status);
/* initialise the descriptors */
for (idx = 0; idx < CACHE_MAX; idx++)
{
lcptr = &LookupCache[idx];
lcptr->HostAddrDsc.dsc$b_class = DSC$K_CLASS_S;
lcptr->HostAddrDsc.dsc$b_dtype = DSC$K_DTYPE_T;
lcptr->HostEntDsc.dsc$b_class = DSC$K_CLASS_S;
lcptr->HostEntDsc.dsc$b_dtype = DSC$K_DTYPE_T;
}
}
if (arg1 > 1023)
{
/**************************/
/* lookup this IP address */
/**************************/
sys$gettim (&ThisBinTime);
ThisTimeStamp = decc$fix_time (&ThisBinTime);
cptr = (char*)arg1;
if (Debug) fprintf (stdout, "->|%s|\n", cptr);
/* search the cache */
for (idx = 0; idx < CacheUsed; idx++)
{
lcptr = &LookupCache[idx];
if (!MATCH8 (cptr, lcptr->IpAddrStr)) continue;
if (strcmp (cptr, lcptr->IpAddrStr)) continue;
if (Debug) fprintf (stdout, "|%s|->\n", lcptr->HostName);
return (lcptr->HostName);
}
/* look for an unused or expired entry */
for (idx = 0; idx < CACHE_MAX; idx++)
{
lcptr = &LookupCache[idx];
if (!lcptr->IpAddrStr[0]) break;
if (ThisTimeStamp >= lcptr->ExpiresStamp) break;
}
/* otherwise look for an unresolveable entry */
if (idx >= CACHE_MAX)
for (idx = 0; idx < CACHE_MAX; idx++)
if (LookupCache[idx].IpAddrStr[0] == '!') break;
/* otherwise just cycle through the cache array entries */
if (idx >= CACHE_MAX) idx = 0;
if (idx > CacheUsed) CacheUsed = idx;
if (Debug) fprintf (stdout, "idx %d %d\n", idx, CacheUsed);
lcptr = &LookupCache[idx];
lcptr->IpAddrStr[0] = lcptr->HostName[1] = '\0';
if (strchr (cptr, ':'))
{
if (inet_pton (AF_INET6, cptr, &lcptr->Ip6Address) != 1)
{
*(ulong*)lcptr->HostName = '!\0\0\0';
lcptr->ExpiresStamp = ThisTimeStamp + RETRY_SECONDS;
return (lcptr->HostName);
}
if (Debug) fprintf (stdout, "IPv6\n");
}
else
{
if (inet_pton (AF_INET, cptr, &lcptr->Ip4Address) != 1)
{
*(ulong*)lcptr->HostName = '!\0\0\0';
lcptr->ExpiresStamp = ThisTimeStamp + RETRY_SECONDS;
return (lcptr->HostName);
}
if (Debug) fprintf (stdout, "IPv4\n");
}
lcptr->HostName[0] = '?';
lcptr->ExpiresStamp = ThisTimeStamp + EXPIRE_SECONDS;
zptr = (sptr = lcptr->IpAddrStr) + sizeof(lcptr->IpAddrStr)-1;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
lcptr->HostAddrDsc.dsc$w_length = sptr - lcptr->IpAddrStr;
lcptr->HostAddrDsc.dsc$a_pointer = lcptr->IpAddrStr;
lcptr->HostEntPtr = calloc (1, HOSTENT_SIZE);
if (!lcptr->HostEntPtr)
{
*(ulong*)lcptr->HostName = '!\0\0\0';
return (lcptr->HostName);
}
lcptr->HostEntDsc.dsc$w_length = HOSTENT_SIZE;
lcptr->HostEntDsc.dsc$a_pointer = lcptr->HostEntPtr;
lcptr->RetryCount = RETRY_ATTEMPTS;
}
else
{
/**************/
/* lookup AST */
/**************/
lcptr = &LookupCache[idx = arg1];
status = lcptr->LookupIOsb.iosb$w_status;
if (Debug) fprintf (stdout, "sys$qio() %%X%08.08X\n", status);
if (VMSok (status))
{
/************/
/* resolved */
/************/
heptr = (struct hostent *)lcptr->HostEntPtr;
heptr->h_name += (unsigned int)heptr;
zptr = (sptr = lcptr->HostName) + sizeof(lcptr->HostName)-1;
for (cptr = heptr->h_name; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
if (Debug) fprintf (stdout, "|%s|\n", lcptr->HostName);
if (!lcptr->HostName[0]) *(ulong*)lcptr->HostName = '!\0\0\0';
free (lcptr->HostEntPtr);
lcptr->HostEntPtr = NULL;
return (lcptr->HostName);
}
if (status == SS$_ENDOFFILE || !lcptr->RetryCount)
{
sys$gettim (&ThisBinTime);
ThisTimeStamp = decc$fix_time (&ThisBinTime);
lcptr->ExpiresStamp = ThisTimeStamp + RETRY_SECONDS;
*(ulong*)lcptr->HostName = '!\0\0\0';
free (lcptr->HostEntPtr);
lcptr->HostEntPtr = NULL;
return (lcptr->HostName);
}
lcptr->RetryCount--;
}
status = sys$qio (0, LookupChannel,
IO$_ACPCONTROL | IO$M_EXTEND /* IPv6 */,
&lcptr->LookupIOsb,
LookupHostName, idx,
&ControlSubFunctionDsc,
&lcptr->HostAddrDsc,
&lcptr->HostEntDsc.dsc$w_length,
&lcptr->HostEntDsc, 0, 0);
if (Debug) fprintf (stdout, "[%d] sys$qio() %%X%08.08X\n", idx, status);
if (VMSnok(status)) lcptr->IpAddrStr[0] = '\0';
return (lcptr->HostName);
}
/*****************************************************************************/
/*
*/
int OnControlY (void *FunctionAddress)
{
static BOOL Disabled = false;
static unsigned long Mask = LIB$M_CLI_CTRLY,
OldMask;
static unsigned short TTChannel = 0;
int status;
$DESCRIPTOR (TTDsc, "TT:");
/*********/
/* begin */
/*********/
if (FunctionAddress)
{
if (!TTChannel)
if (VMSnok (status = sys$assign (&TTDsc, &TTChannel, 0, 0, 0)))
return (status);
if (VMSnok (status =
sys$qiow (0, TTChannel, IO$_SETMODE | IO$M_CTRLYAST, 0, 0, 0,
FunctionAddress, 0, PSL$C_USER, 0, 0, 0)))
return (status);
if (VMSnok (status =
sys$qiow (0, TTChannel, IO$_SETMODE | IO$M_CTRLCAST, 0, 0, 0,
FunctionAddress, 0, PSL$C_USER, 0, 0, 0)))
return (status);
if (!Disabled)
{
Disabled = true;
return (lib$disable_ctrl (&Mask, &OldMask));
}
else
return (status);
}
else
{
sys$cancel (TTChannel);
return (lib$enable_ctrl (&OldMask, 0));
}
}
/*****************************************************************************/
/*
*/
ControlY_AST ()
{
ControlY = true;
sys$wake (0, 0);
}
/*****************************************************************************/
/*
Place the values of selected server statistics into global CLI symbols. This
allows a process to periodically pooll these values and do whatever it likes
with the provided values. Exits immediately. (A Swoose special :-)
*/
int PluckStats ()
{
int idx, status;
char LastExitStatus [16];
/*********/
/* begin */
/*********/
MapGlobalSection ();
AccountingPtr = &HttpdGblSecPtr->Accounting;
sprintf (LastExitStatus, "%%X%08.08X", AccountingPtr->LastExitStatus);
SetSymbol ("HTTPDMON_VERSION", HttpdGblSecPtr->HttpdVersion, 0);
SetSymbol ("HTTPDMON_LASTEXIT", LastExitStatus, 0);
SetSymbol ("HTTPDMON_CONNECT_CURRENT", NULL,
AccountingPtr->CurrentConnected[HTTP12]);
SetSymbol ("HTTPDMON_CONNECT_PEAK", NULL,
AccountingPtr->ConnectPeak[HTTP12]);
SetSymbol ("HTTPDMON_REQUEST_CURRENT", NULL,
AccountingPtr->CurrentProcessing[HTTP12]);
SetSymbol ("HTTPDMON_REQUEST_PEAK", NULL,
AccountingPtr->ProcessingPeak[HTTP12]);
return (SS$_NORMAL);
}
/****************************************************************************/
/*
Assign a global symbol. If the string pointer is null the numeric value is
used. Symbol lengths are fixed to a maxim,um of 255.
*/
SetSymbol
(
char *Name,
char *String,
int Value
)
{
static int CliSymbolType = LIB$K_CLI_GLOBAL_SYM;
static char ValueString [32];
static $DESCRIPTOR (NameDsc, "");
static $DESCRIPTOR (ValueDsc, "");
static $DESCRIPTOR (ValueFaoDsc, "!UL");
static $DESCRIPTOR (ValueStringDsc, ValueString);
int status;
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "SetSymbol() |%s|%s| %d\n", Name, String, Value);
NameDsc.dsc$a_pointer = Name;
NameDsc.dsc$w_length = strlen(Name);
if (!String)
{
ValueDsc.dsc$a_pointer = ValueString;
sys$fao (&ValueFaoDsc, &ValueDsc.dsc$w_length, &ValueStringDsc, Value);
ValueString[ValueDsc.dsc$w_length] = '\0';
}
else
{
ValueDsc.dsc$a_pointer = String;
if ((ValueDsc.dsc$w_length = strlen(String)) > 255)
ValueDsc.dsc$w_length = 255;
}
if (Debug) fprintf (stdout, "|%s| %d\n", Name, ValueDsc.dsc$w_length);
if (VMSnok (status = lib$set_symbol (&NameDsc, &ValueDsc, &CliSymbolType)))
exit (status);
}
/*****************************************************************************/
/*
*/
char* TimeString ()
{
static int LibDayOfWeek = LIB$K_DAY_OF_WEEK;
static char *WeekDays [] =
{"","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
static char TimeString [35];
static $DESCRIPTOR (DayDateTimeDsc, "!AZ, !%D");
static $DESCRIPTOR (TimeStringDsc, TimeString);
int status,
DayOfWeek;
unsigned short Length;
/*********/
/* begin */
/*********/
lib$cvt_from_internal_time (&LibDayOfWeek, &DayOfWeek, &NowTime64);
sys$fao (&DayDateTimeDsc, &Length, &TimeStringDsc,
WeekDays[DayOfWeek], &NowTime64);
TimeString[Length-3] = '\0';
return (TimeString);
}
/*****************************************************************************/
/*
Return a pointer to a string containing a representative bytes-per-second.
*/
char* BytesPerString (unsigned int BytesPerSecond)
{
static char BytesPerString [32];
/*********/
/* begin */
/*********/
/*
Prevent "%CC-E-INTCONST, Ill-formed integer constant" under
Compaq C V6.4-005 on OpenVMS VAX V7.2 (at least).
*/
if (BytesPerSecond >= (10000000 * 1000))
sprintf (BytesPerString, "%.1fGB/s", (float)BytesPerSecond/1000000000.0);
else
if (BytesPerSecond >= 100000000)
sprintf (BytesPerString, "%dMB/s", BytesPerSecond/1000000);
else
if (BytesPerSecond >= 1000000)
sprintf (BytesPerString, "%.1fMB/s", (float)BytesPerSecond/1000000.0);
else
if (BytesPerSecond >= 100000)
sprintf (BytesPerString, "%dkB/s", BytesPerSecond/1000);
else
if (BytesPerSecond >= 1000)
sprintf (BytesPerString, "%.1fkB/s", (float)BytesPerSecond/1000.0);
else
sprintf (BytesPerString, "%dB/s", BytesPerSecond);
return (BytesPerString);
}
/*****************************************************************************/
/*
Convert the 32/64 bit integer (depending on architecture) pointed to into an
ASCII number string containing commas. The destination string should contain
capacity of a minimum 16 characters for 32 bits, or 32 characters for 64 bits.
*/
void CommaNumber
(
int Bits,
void *vptr,
char *String
)
{
static $DESCRIPTOR (Value32FaoDsc, "!UL");
static $DESCRIPTOR (Value64FaoDsc, "!@SQ");
int cnt, status;
unsigned short Length;
double dValue;
char *cptr, *sptr;
char Scratch [32];
$DESCRIPTOR (ScratchDsc, Scratch);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "CommaNumber()\n");
if (Bits > 32)
status = sys$fao (&Value64FaoDsc, &Length, &ScratchDsc, vptr);
else
status = sys$fao (&Value32FaoDsc, &Length, &ScratchDsc, *(ulong*)vptr);
if (VMSnok (status))
{
strcpy (String, "*ERROR*");
return;
}
Scratch[Length] = '\0';
if (((Length-1) / 3) < 1)
{
strcpy (String, Scratch);
return;
}
else
if (!(cnt = Length % 3))
cnt = 3;
cptr = Scratch;
sptr = String;
while (*cptr)
{
if (!cnt--)
{
*sptr++ = ',';
cnt = 2;
}
*sptr++ = *cptr++;
}
*sptr = '\0';
}
/*****************************************************************************/
/*
From [SRC.HTTPD]SUPPORT.C
Support version 10 and pre-version-10 logical and file naming conventions.
Look for one of multiple (usually just two but can be more) possible logical
names. When one is successfully translated return a pointer to it's null
terminated name. Otherwise test for a subsequent and return a pointer to it if
found. If none is found then return NoneFound if zero or positive, return the
LogicalName if minus one. The constants should be #defined in the manner of
"?WASD_CONFIG_GLOBAL\0HTTPD$CONFIG\0".
*/
char* v10orPrev10
(
char *LogicalName,
int NoneFound
)
{
static unsigned short Length;
static char ValueString [128];
static $DESCRIPTOR (LogicalNameDsc, "");
static $DESCRIPTOR (LnmFileDevDsc, "LNM$FILE_DEV");
static struct
{
unsigned short buf_len;
unsigned short item;
void *buf_addr;
void *ret_len;
} LnmItems [] =
{
{ sizeof(ValueString)-1, LNM$_STRING, ValueString, &Length },
{ 0,0,0,0 }
};
int status;
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (!LogicalName || LogicalName[0] != '?') return (LogicalName);
/* stop at any logical name delimiting colon (perhaps of a file name) */
for (sptr = cptr = LogicalName+1; *sptr && *sptr != ':'; sptr++);
while (*cptr)
{
LogicalNameDsc.dsc$a_pointer = cptr;
LogicalNameDsc.dsc$w_length = sptr - cptr;
status = sys$trnlnm (0, &LnmFileDevDsc, &LogicalNameDsc, 0, &LnmItems);
if (VMSok (status)) return (cptr);
/* scan past any logical-delimiting colon */
while (*sptr) sptr++;
/* stop at any logical name delimiting colon (perhaps of a file name) */
for (cptr = (sptr += 1); *sptr && *sptr != ':'; sptr++);
}
if (NoneFound != -1) return ((char*)NoneFound);
return (LogicalName+1);
}
/*****************************************************************************/
/*
Development purposes only.
*/
void TryIt (char* string)
{
int count;
char *cptr;
/*********/
/* begin */
/*********/
if (strsame (string, "lookup=", 7))
{
for (count = 5; count; count--)
if (cptr = LookupHostName (string + 7))
{
if (*cptr != '?') break;
sleep (1);
}
fprintf (stdout, "%d |%s|\n", count, cptr);
}
}
/*****************************************************************************/
/*
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 (!(clptr = getenv ("HTTPDMON$PARAM")))
{
/* get the entire command line following the verb */
if (VMSnok (status =
lib$get_foreign (&CommandLineDsc, 0, &Length, &Flags)))
exit (status);
(clptr = CommandLine)[Length] = '\0';
}
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, "/ACPCONTROL", 4))
{
/* development only */
AcpControl = true;
continue;
}
if (strsame (aptr, "/ALERT=", 4))
{
sptr = aptr;
while (*aptr && *aptr != '=') aptr++;
if (*aptr) aptr++;
while (*aptr)
{
if (!*aptr || strsame (aptr, "ALL", 3))
{
DoAlertAll = true;
DoAlertHost = false;
}
else
if (strsame (aptr, "HOST", 4))
{
DoAlertAll = false;
DoAlertHost = true;
}
else
if (strsame (aptr, "PATH", 4))
{
DoAlertAll = false;
DoAlertPath = true;
while (*aptr && *aptr != '=') aptr++;
if (*aptr)
{
aptr++;
PathAlertBellRepetition = atoi(aptr);
}
}
else
if (strsame (aptr, "NOSERVERS", 9))
DoAlertServers = false;
else
if (strsame (aptr, "SERVERS", 7))
DoAlertServers = true;
else
{
fprintf (stdout, "%%%s-E-INVPARM, invalid parameter\n \\%s\\\n",
Utility, sptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
while (*aptr && *aptr != ',') aptr++;
if (*aptr) aptr++;
}
continue;
}
if (strsame (aptr, "/ALL=", 4))
{
sptr = aptr;
while (*aptr && *aptr != '=') aptr++;
if (*aptr) aptr++;
if (!isdigit(*aptr))
{
fprintf (stdout, "%%%s-E-INVPARM, invalid parameter\n \\%s\\\n",
Utility, sptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
InstanceEnvNumber = atoi(aptr);
continue;
}
if (strsame (aptr, "/DBUG", -1))
{
Debug = true;
continue;
}
if (strsame (aptr, "/DEMO", -1))
{
DemoMode = true;
continue;
}
if (strsame (aptr, "/ENV=", 4))
{
sptr = aptr;
while (*aptr && *aptr != '=') aptr++;
if (*aptr) aptr++;
if (!isdigit(*aptr))
{
fprintf (stdout, "%%%s-E-INVPARM, invalid parameter\n \\%s\\\n",
Utility, sptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
InstanceEnvNumber = atoi(aptr);
continue;
}
if (strsame (aptr, "/GENERAL", 4))
{
DoGeneralInfo = true;
DoNoGeneralInfo = false;
continue;
}
if (strsame (aptr, "/NOGENERAL", 6))
{
DoGeneralInfo = false;
DoNoGeneralInfo = true;
continue;
}
if (strsame (aptr, "/HELP", 4))
{
DoShowHelp = true;
continue;
}
if (strsame (aptr, "/IDENTIFICATION=", 3))
{
sptr = aptr;
while (*aptr && *aptr != '=') aptr++;
if (*aptr) aptr++;
if (!isxdigit(*aptr))
{
fprintf (stdout, "%%%s-E-INVPARM, invalid parameter\n \\%s\\\n",
Utility, sptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
sscanf (aptr, "%x", &CliInstancePid);
continue;
}
if (strsame (aptr, "/INTERVAL=", 4) ||
strsame (aptr, "/REFRESH=", 4))
{
sptr = aptr;
while (*aptr && *aptr != '=') aptr++;
if (*aptr) aptr++;
if (!isdigit(*aptr))
{
fprintf (stdout, "%%%s-E-INVPARM, invalid parameter\n \\%s\\\n",
Utility, sptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
IntervalSeconds = atoi(aptr);
continue;
}
if (strsame (aptr, "/LOOKUP", 4))
{
DoLookupHost = true;
continue;
}
if (strsame (aptr, "/NOLOOKUP", 6))
{
DoLookupHost = false;
continue;
}
if (strsame (aptr, "/PLUCK", 5))
{
DoPluck = true;
continue;
}
if (strsame (aptr, "/PORT=", 4))
{
sptr = aptr;
while (*aptr && *aptr != '=') aptr++;
if (*aptr) aptr++;
if (!isdigit(*aptr))
{
fprintf (stdout, "%%%s-E-INVPARM, invalid parameter\n \\%s\\\n",
Utility, sptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
ServerPort = atoi(aptr);
continue;
}
if (strsame (aptr, "/PROCESS", 5))
{
DoProcessInfo = true;
DoNoProcessInfo = false;
continue;
}
if (strsame (aptr, "/NOPROCESS", 7))
{
DoProcessInfo = false;
DoNoProcessInfo = true;
continue;
}
if (strsame (aptr, "/PROXY", 5))
{
DoProxyInfo = true;
DoNoProxyInfo = false;
continue;
}
if (strsame (aptr, "/NOPROXY", 7))
{
DoProxyInfo = false;
DoNoProxyInfo = true;
continue;
}
if (strsame (aptr, "/REQUEST", 4))
{
DoRequestInfo = true;
DoNoRequestInfo = false;
continue;
}
if (strsame (aptr, "/NOREQUEST", 6))
{
DoRequestInfo = false;
DoNoRequestInfo = true;
continue;
}
if (strsame (aptr, "/STATUS", 4))
{
DoStatusInfo = true;
DoNoStatusInfo = false;
continue;
}
if (strsame (aptr, "/NOSTATUS", 6))
{
DoStatusInfo = false;
DoNoStatusInfo = true;
continue;
}
if (strsame (aptr, "/TRY=", 4))
{
/* development purposes only */
sptr = aptr;
while (*aptr && *aptr != '=') aptr++;
if (*aptr) aptr++;
TryIt (aptr);
exit (SS$_NORMAL);
}
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);
}
}
}
/****************************************************************************/
/*
*/
int ShowHelp ()
{
fprintf (stdout,
"%%%s-I-HELP, usage for the WASD HTTPd Monitor (%s)\n\
\n\
Continuously displays the status of an HTTPd process (must be executed on the\n\
system that has the process running on it, defaulting to port 80). Provides\n\
process information, server counters, latest request information, with proxy\n\
processing statistics optionally available. By default attempts to resolve\n\
request dotted-decimal host address to host name. The alert qualifier\n\
activates the terminal bell for an increase in server connect count (=ALL)\n\
or change in requesting host (=HOST), or mapped alert path hit (=PATH).\n\
\n\
$ HTTPDMON [qualifiers...]\n\
\n\
/ALERT[=ALL|HOST|PATH[=<integer>]] /DEMO /ENV=<integer> /[NO]GENERAL /HELP\n\
/INTERVAL=<integer> /[NO]LOOKUP /PLUCK /PRCNAM=prcnam /PORT=<integer>\n\
/[NO]PROCESS /[NO]PROXY /REFRESH=integer /[NO]REQUEST /[NO]STATUS\n\
\n\
Usage examples:\n\
\n\
$ HTTPDMON\n\
$ HTTPDMON /INTERVAL=15 /PROXY\n\
$ HTTPDMON /PORT=8080 /ALERT\n\
$ HTTPDMON /NOLOOKUP\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);
}
/*****************************************************************************/