[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]
/*****************************************************************************/
/*
Logging.c
Logging functions for the WASD VMS HTTPd. By default, produces a Web "common"
format log suitable for analysis by tools capable of processing that format.
Secretes four pseudo-requests logging the BEGINing, OPENing, CLOSEing and
ENDing of logging activities. These shouldn't introduce problems for analysis
tools as they look like legitimate POST entries for user "HTTPd"!
The [LogFormat] directive generates logs in the "common+server", "combined" and
a user-defined format. If a user-defined format contains an error the server
will exit the first time a request is logged. Caveat emptor!
Log file name must be supplied via [LogFile] or the logical name WASD_CONFIG_LOG
(process, job, or system level). An error is reporting if logging is enabled
without either of these being supplied. If the log file name specified is
"SYS$OUTPUT" log entries are written to SYS$OUTPUT. This is useful for
checking user-defined log entries before committing files to that format.
The [LogNaming] format can be any of "NAME" (default) which names the log file
using the first period-delimited component of the IP host name, "HOST" which
uses as much of the IP host name as can be accomodated within the maximum 39
character filename limitation (of ODS-2), or "ADDRESS" which uses the full IP
host address in the name. Both HOST and ADDRESS have hyphens substituted for
periods in the string. If these are specified then by default the service port
follows the host name component. This may be suppressed using the
[LogPerServiceHostOnly] directive, allowing a minimum extra 3 characters in the
name, and combining entries for all ports associated with the host name.
The log file can have a [LogPeriod] associated with it. This period determines
when a new log file is created. The periods are hourly, daily, weekly and
monthly. An hourly period is indicated by HOURLY, a daily period by DAILY, a
weekly period by MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY and
SUNDAY (the day of the week on which, at midnight or the first request
thereafter, the log is recreated), and finally a monthly recreation by MONTHLY.
The WASD_CONFIG_LOG logical is then used merely for the directory component and the
file name is fixed at
HOST_YYYYMMDD_ACCESS.LOG
where host is the first dot-separated component of the primary IP host name and
YYYY, MM, DD is the year, month and day the log was created, or if hourly
period has been specified
HOST_YYYYMMDDHH_ACCESS.LOG
where the additional HH represents the hour the log was created.
When multiple instances, either on the one node or across a cluster, are
writing to the same log file (multi-stream), then RMS insists on automatically
flushing each log record write (considering the issues with maintaining 'dirty'
buffers, perhaps cluster-wide, this is not unreasonable). This does increase
the physical disk I/O significantly though, and of course reduces server
performance equally (or more so) as a result. The simple (and effective)
solution to this is to have only one stream writing to a log file at the one
time. This is enabled using the [LogPerInstance] configuration directive.
With this active each log file has the node name and then the instance process
name appended to the .LOG file type resulting in names similar to (for a two
instance single node)
10-168-0-3_80_20020527_ACCESS.LOG_KLAATU_HTTPD-80
10-168-0-3_80_20020527_ACCESS.LOG_KLAATU_HTTPE-80
10-168-0-3_443_20020527_ACCESS.LOG_KLAATU_HTTPD-80
10-168-0-3_443_20020527_ACCESS.LOG_KLAATU_HTTPE-80
Of course these need to be integrated at some stage, either using one of the
many log file analysis tools, or a specific utility such as WASD's CALOG.C
(Consolidate Access LOGs, pronounced as with the breakfast cereals).
COMMON FORMAT
-------------
(NCSA, CERN, etc.)
'client rfc1413 auth-user date/time request status bytes'
COMBINED FORMAT
---------------
(NCSA)
'client rfc1413 auth-user date/time request status bytes referer user-agent'
COMMON FORMAT plus server name
-------------
(NCSA, CERN, etc.)
'client rfc1413 auth-user date/time request status bytes server'
USER-DEFINED FORMAT
-------------------
Must begin with a character that is used as a substitute when a particular
field is empty (use "\0" for no substitute, as in the "windows log format"
example below). Two different "escape" characters introduce the following
parameters of characters.
A '!' followed by ...
'AR' : authentication realm - none
'AU' : authenticated user name - Apache %u
'BB' : longword bytes in body (excluding response header) - Apache %b
'BQ' : quadword bytes transmitted to the client - none
'BY' : longword bytes transmitted to the client - none
'CA' : client numeric address - Apache %a
'CC' : X509 client certificate authorization distinguishing name - none
'CI' : SSL cipher name (e.g. "AES128-SHA", "AES128-GCM-SHA256") - none
'CL' : content-length value from request header ('-' if no content-length)
'CN' : client host name (or address if DNS lookup disabled) - Apache %h
'CP' : client port
'DI' : insert value of dictionary entry (should be quoted \q!DI:"<key>"\q)
'EM' : request elapsed time in milliseconds - none
'ES' : request elapsed time in fractional seconds
'ET' : request elapsed time in seconds - Apache %T
'EU' : request elapsed time in microseconds - none
'HO' : "Host:" request header
'ID' : session track ID - none
'II' : server image information (file name, version, link date-time)
'ME' : request method - none
'NP' : insert notepad value (should be quoted \q!NP\q if likely to break log)
'PA' : request path (NOTE: not the full request path! See 'R') - none
'PL' : payload - number of body bytes received (i.e. POST or PUT)
'PP' : outgoing proxy connection local port
'PR' : HTTP protocol (e.g. "HTTP/2", "HTTP/1.1") - none
'QS' : request query string - none
'RF' : referer - Apache %{referer}i
'RH' : the specified request header (e.g. "RH:cache-control:")
'RP' : request protocol (e.g. HTTP/2, HTTP1.1)
'RQ' : FULL request path (script and any query string) - Apache %r
'RS' : response status code - none
'SC' : script name - none
'SM' : request scheme name (i.e. "http:" or "https:") - none
'SN' : server host name (virtual) - Apache %v
'SP' : server port - Apache %p
'SR' : SSL session reused (cached) - none
'SV' : SSL version (e.g. "SSLv3", "TLSv1") - none
'TC' : request time (common log format) - Apache %t
'TI' : request time (local in ISO 8601 extended format) - none
'TS' : (sortable) request time (UTC in ISO 8601 basic format) - none
'TV' : request time (VMS format) - none
'TU' : request time (UTC) - none
'UA' : user agent - Apache %{user-agent}i
'VS' : virtual service (actual service host:port used by the request)
'XX' : custom, usually site/client-specific, logging item (see below)
A '\' followed by ...
'0' : a null character (used to define the empty field character)
'!' : insert an '!'
'\' : insert a '\'
'n' : insert a newline
'q' : insert a quote (so that in the DCL the quotes won't need escaping!)
't' : insert a TAB
Any other character is directly inserted into the log entry.
PRE-DEFINED PLUS USER-DEFINED
-----------------------------
It is possible to use one of the pre-defined keywords with additional
user-defined directive appended. The appended directives must include ALL
additional literal characters and directives required in the log entry. The
syntax is <pre-defined keyword>+<appended format> as in "COMMON+ !EM".
XX CUSTOM ITEMS
---------------
Sometimes a site will need some specific datum that cannot otherwise easily be
derived. The !XX<string> format item calls LoggingCustom() to generate this
and insert into the user-defined access log. Current items are:
o XX:blb insert a blank line on server startup
o XX:conc-auth returns count of current requests using same authorisation
o XX:quotas return data on server process quotas used and limits
o XX:timeout returns string describing type of timeout
EXAMPLES
--------
The equivalent of the common log format is:
"-!CN !ID !AU [!TC] \q!RQ\q !RS !BY"
The combined log format:
"-!CN !ID !AU [!TC] \q!RQ\q !RS !BY \q!RF\q \q!UA\q"
The WebSite "windows log format" would be created by:
"\0!TC\t!CA\t!SN\t!AR\t!AU\t!ME\t!PA\t!RQ\t!EM\t!UA\t!RS\t!BB\t"
To get the common log format plus append request duration in seconds:
"-!CN !ID !AU [!TC] \q!RQ\q !RS !BY !ES"
To include the SSL protocol version and cipher with the combined format:
"COMBINED+ !SV !CI"
VERSION HISTORY
---------------
04-JAN-2021 MGD 'XX:blb' insert visual aid
17-MAY-2020 MGD protocol "HTTP/2" also reported in standard log formats
16-MAY-2018 MGD 'XX:quotas" server process quotas (trouble-shooting only)
23-DEC-2017 MGD 'TI' local request time in ISO 8601 format
'TS' (sortable) UTC request time in ISO 8601 extended format
(provide a sortable time string when merging logs)
'TU' UTC request time ('TG' is now a synonym)
16-DEC-2017 MGD 'BY' and 'BQ' now synonymous for non-VAX (both quads)
bugfix; 'BB' header length "lost" during HTTP/2 mods
20-OCT-2017 MGD 'II' image information (file name, version, link date-time)
stamp (note) events when common/combined with/without plus
09-JUN-2017 MGD bugfix; LoggingDo() 'SR' silliness from v11.0 rework
13-DEC-2016 MGD 'CL' content-length and 'PL' payload (bytes)
13-APR-2016 MGD 'RP' request protocol (a la CGI REQUEST_PROTOCOL)
"XX:timeout" logging extension
ensure timed-out requests are logged as 408/500
12-MAR-2016 MGD 'DI' insert specified dictionary item value
'NP' insert notepad value
'XX' custom logging items
bugfix; LoggingDo() elapsed time items
05-OCT-2015 MGD bugfix; LoggingDo() 'VS' |->ServicePtr| dereference
04-OCT-2015 MGD bugfix; LoggingDo() 'CC' do not reuse pointers!
30-SEP-2015 MGD LoggingDo() MAX_FAO_VECTOR from 64 to 128
10-MAR-2015 MGD add WASD_LOGS "convenience" logical name after WASD_LOG
12-NOV-2014 MGD 'CI, 'SR', 'SV' for SSL cipher, session reused and version
COMMON+, COMMON_SERVER+, COMBINED+ composite log formats
29-JAN-2014 MGD access log buffer extended from [4096] to [16384] (UMA SAML)
LoggingQuoted() explicitly encode some fields where a raw
quotation mark (URI forbidden) can break a log entry
09-APR-2011 MGD 'PP' outgoing proxy connection local port
04-FEB-2010 MGD 'HO' request "Host:" field
'RH' any request header (e.g. "RH:cache-control:")
'VS' virtual service used by the host
bugfix; LoggingDo() sys$flush(&RAB) not (&FAB)
01-FEB-2010 MGD bugfix; LoggingDo() initialise (zero) &DummyRequest
15-NOV-2009 MGD bugfix; whatever happened to 'CN'?
13-OCT-2009 MGD allow for []-delimited IPv6 addresses as service names
26-MAY-2009 MGD 'CP' for client port
per-service user-defined log format
04-NOV-2006 MGD bugfix; LoggingDo() changes for daily period test
to support hourly logging (thanks again JPP)
LOGGING_SHUT to a close log file (without disabling logging)
30-SEP-2006 MGD add HOURLY period
remove file name length constraint for logs created on an
ODS-5 volume (allows full host name components, etc.)
26-JAN-2006 MGD bugfix; 'RQ' include method and protocol (Apache "%r")
bugfix; 'EM', 'ES' and 'UE' arithmetic ('doh'!?)
'ET' (equivalent of Apache "%T")
12-OCT-2004 MGD configurable service unavailable 503 when log write fails
04-SEP-2004 MGD 'BQ' for quadword bytes tx
04-AUG-2004 MGD refine end-of-period log file handling
04-MAR-2004 MGD timestamp entry, server account username
28-JAN-2004 MGD LoggingReport(),
add HTTP protocol to timestamp and pseudo entries
28-JUN-2003 MGD bugfix; add HTTP protocol to combined/common format URL
'PR' same datum with user format (jf.pieronne@laposte.fr)
08-APR-2003 MGD timestamp and pseudo entry formats, make bytes numeric and
leading slash before server POST paths (e.g. "/KLAATU::..")
(Analog could complain about both of these),
add the server software ID as the user-agent field
26-MAY-2002 MGD logging per-instance
21-DEC-2001 MGD bugfix; 07-NOV-2001 for ALL services :^}
07-NOV-2001 MGD bugfix; close current log file if period changes
25-OCT-2001 MGD timestamp log file(s) every hour,
FAB$M_TEF to deallocate unused file space
04-AUG-2001 MGD support module WATCHing
04-MAY-2001 MGD increased LoggingDo() 'String' size from 2048 TO 4096
20-MAR-2001 MGD added FAB$M_DFW, w_deq=nnn, b_mbc=127,
improves log performance by 500%!! (jfp@altavista.net)
15-DEC-2000 MGD client certificate authorization (as rfc1413 & 'CC')
15-OCT-2000 MGD correct time string TZ (GMT format)
07-MAY-2000 MGD session track ID
16-FEB-2000 MGD "[LogNaming] HOST", [LogPerServiceHostOnly] processing
12-JUN-1999 MGD modify WATCH log entry format
22-MAR-1999 MGD increased LoggingDo() 'String' size from 1024 to 2048
07-NOV-1998 MGD WATCH facility
27-AUG-1998 MGD exclude specified hosts from being logged
17-MAY-1998 MGD add per-service logging
23-NOV-1997 MGD signal failed log file create/put (e.g. disk quota :^)
25-OCT-1997 MGD log file period new for v4.5,
log file now opened for sharing GET, PUT and UPD
added 'CI' (cache-involvement) user-format directive
bugfix; user format from configuration file
25-SEP-1997 MGD bugfix; ACCVIO if request structure exists but empty
(assumed if it existed all the pointers were valid - WRONG!)
06-SEP-1997 MGD added "common+server", "combined", "user-defined" log formats
10-JUL-1997 MGD minor modification for server-admin logging on/off/flush
10-JUL-1996 MGD RequestUriPtr instead of ScriptPtr/PathInfoPtr/QueryStringPtr
01-DEC-1995 MGD HTTPd version 3, "common" log format
27-SEP-1995 MGD use time values in request thread structure
16-JUN-1995 MGD added node name, changed logging fields to be space-separated
07-APR-1995 MGD initial development for addition to multi-threaded daemon
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
/* VMS related header files */
#include <descrip.h>
#include <iodef.h>
#include <jpidef.h>
#include <lnmdef.h>
#include <rms.h>
#include <ssdef.h>
#include <stsdef.h>
/* application header files */
#include "wasd.h"
#include "httpd.h"
#include "error.h"
#include "logging.h"
#define WASD_MODULE "LOGGING"
#define LOGGING_NAMING_NAME 1
#define LOGGING_NAMING_HOST 2
#define LOGGING_NAMING_ADDRESS 3
/******************/
/* global storage */
/******************/
char ErrorLoggingFormatLength [] = "log format too long";
int LoggingDayWeekBegins;
BOOL LoggingEnabled,
LoggingNaming,
LoggingPerPeriod,
LoggingPerService,
LoggingPeriodHourly,
LoggingPeriodDaily,
LoggingPeriodWeekly,
LoggingPeriodMonthly,
LoggingProxyLocalPort,
LoggingSysOutput,
LoggingFileError;
int LoggingFileNameLength,
LoggingNaming,
LoggingTimeStampCount;
char LoggingFileName [256],
LoggingFormatUser [256],
LoggingPeriodName [128];
/********************/
/* external storage */
/********************/
extern BOOL CliLoggingDisabled,
CliLoggingEnabled;
extern int EfnWait,
ExitStatus,
HttpdDayOfWeek,
HttpdTickSecond,
ServerPort;
extern int64 HttpdTime64;
extern int ToLowerCase[],
ToUpperCase[];
extern ushort HttpdTime7[];
extern ulong SysPrvMask[];
extern char CliLoggingPeriod[],
ErrorSanityCheck[],
ServerHostName[],
SoftwareID[],
TimeGmtString[];
extern CONFIG_STRUCT Config;
extern HTTPD_PROCESS HttpdProcess;
extern LIST_HEAD RequestList;
extern META_CONFIG *MetaGlobalServicePtr;
extern LIST_HEAD ServiceList;
extern SYS_INFO SysInfo;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Parameter 'Function' can be:
LOGGING_BEGIN server startup
LOGGING_OPEN open server logging, other than server startup
LOGGING_CLOSE close server logging, other than server shutdown
LOGGING_END server shutdown
LOGGING_ENTRY log a request
LOGGING_SHUT shut (close) the log files
LOGGING_TIMESTAMP put a timestamp pseudo-entry into the log file
LOGGING_FLUSH close the log file, flushing the contents
With per-service logging most of these functions must be performed on each
service's log, logging a request entry occurs for the service involved only.
*/
int Logging
(
REQUEST_STRUCT *rqptr,
int Function
)
{
BOOL PrevLoggingEnabled,
WatchThisOne;
int status;
char *cptr, *sptr;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "Logging() !UL", Function);
if (!rqptr && WATCH_CATEGORY(WATCH_LOG))
WatchThisOne = true;
else
if (rqptr)
{
if (WATCHING (rqptr, WATCH_LOG))
WatchThisOne = true;
else
WatchThisOne = false;
}
else
WatchThisOne = false;
switch (Function)
{
case LOGGING_ENTRY :
if (!LoggingEnabled) return (STS$K_ERROR);
/* if the request path has been mapping-rule set NOlog then don't! */
if (rqptr && rqptr->rqPathSet.NoLog)
{
if (WATCH_CAT && WatchThisOne)
{
cptr = rqptr->rqHeader.RequestUriPtr;
if (!cptr || !*cptr) cptr = "(none)";
WatchThis (WATCHITM(rqptr), WATCH_LOG, "NOLOG !AZ", cptr);
}
return (SS$_NORMAL);
}
if (rqptr && Config.cfLog.ExcludeHostsPtr)
{
sptr = Config.cfLog.ExcludeHostsPtr;
while (*sptr)
{
if (isdigit(*sptr))
cptr = &rqptr->ClientPtr->IpAddressString;
else
cptr = rqptr->ClientPtr->Lookup.HostName;
while (*cptr)
{
if (*sptr == STRING_LIST_CHAR) break;
if (*sptr == '*')
{
while (*sptr && *sptr == '*' &&
*sptr != STRING_LIST_CHAR) sptr++;
while (*cptr && *cptr != *sptr) cptr++;
}
if (TOLO(*cptr) != TOLO(*sptr)) break;
if (*cptr) cptr++;
if (*sptr) sptr++;
}
if (!*cptr && (!*sptr || *sptr == STRING_LIST_CHAR)) break;
while (*sptr && *sptr != STRING_LIST_CHAR) sptr++;
if (*sptr) sptr++;
}
/* if it was found then return without logging the request */
if (!*cptr && (!*sptr || *sptr == STRING_LIST_CHAR))
{
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG,
"EXCLUDE !AZ", rqptr->ClientPtr->Lookup.HostName);
return (SS$_NORMAL);
}
}
if (rqptr && rqptr->ServicePtr->NoLog)
{
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG,
"NOLOG for !AZ//!AZ",
rqptr->ServicePtr->RequestSchemeNamePtr,
rqptr->ServicePtr->ServerHostPort);
return (STS$K_ERROR);
}
if (rqptr && LoggingPerService)
status = LoggingDo (rqptr, rqptr->ServicePtr,
Function, WatchThisOne);
else
status = LoggingDo (rqptr, LIST_GET_HEAD(&ServiceList),
Function, WatchThisOne);
return (status);
case LOGGING_BEGIN :
case LOGGING_CLOSE :
case LOGGING_END :
case LOGGING_FLUSH :
case LOGGING_OPEN :
case LOGGING_SHUT :
case LOGGING_TIMESTAMP :
switch (Function)
{
case LOGGING_BEGIN :
if (Config.cfLog.Enabled || CliLoggingEnabled)
LoggingEnabled = true;
if (CliLoggingDisabled) LoggingEnabled = false;
LoggingPerService = Config.cfLog.PerService ||
Config.cfLog.PerServiceHostOnly;
/* in log using host part of file name, name or address? */
LoggingNaming = LOGGING_NAMING_NAME;
if (Config.cfLog.Naming[0])
{
if (strsame (Config.cfLog.Naming, "NAME", -1))
LoggingNaming = LOGGING_NAMING_NAME;
else
if (strsame (Config.cfLog.Naming, "HOST", -1))
LoggingNaming = LOGGING_NAMING_HOST;
else
if (strsame (Config.cfLog.Naming, "ADDRESS", -1))
LoggingNaming = LOGGING_NAMING_ADDRESS;
else
FaoToStdout ("%HTTPD-W-LOG, naming unknown\n \\!AZ\\\n",
Config.cfLog.Naming);
}
break;
case LOGGING_OPEN :
if (LoggingEnabled) return (STS$K_ERROR);
break;
default :
if (!LoggingEnabled) return (STS$K_ERROR);
break;
}
PrevLoggingEnabled = LoggingEnabled;
if (Function == LOGGING_TIMESTAMP) LoggingTimeStampCount++;
if (LoggingPerService)
{
LIST_ITERATE (svptr, &ServiceList)
{
status = LoggingDo (rqptr, svptr, Function, WatchThisOne);
if (VMSnok (status)) break;
}
}
else
status = LoggingDo (rqptr, LIST_GET_HEAD(&ServiceList), Function,
WatchThisOne);
switch (Function)
{
case LOGGING_BEGIN :
if (VMSnok (status)) LoggingEnabled = false;
break;
case LOGGING_OPEN :
if (VMSok (status))
LoggingEnabled = true;
else
LoggingEnabled = PrevLoggingEnabled;
break;
case LOGGING_CLOSE :
case LOGGING_END :
if (VMSok (status))
LoggingEnabled = LoggingFileError = false;
else
LoggingEnabled = PrevLoggingEnabled;
}
return (status);
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
}
/*****************************************************************************/
/*
What an incomprehensibly long function this has grown to be! :^(
The 'svptr' parameter points to the service structure associated with the log.
If per-service logging is enabled this will be the appropriate one of however
many services are created. If per-service logging is not enabled this will
always be the first service created (i.e. the "primary" service). Where
service information is required for user-format logging it is accessed from the
request structure's service pointer.
*/
int LoggingDo
(
REQUEST_STRUCT *rqptr,
SERVICE_STRUCT *svptr,
int Function,
BOOL WatchThisOne
)
{
# define MAX_FAO_VECTOR 128
static char *MonthName [] =
{ "", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
static $DESCRIPTOR (PeriodFileNameFaoDsc,
"!#AZ!AZ!AZ_!UL!2ZL!2ZL!AZ_ACCESS.LOG!AZ!AZ!AZ!AZ");
static $DESCRIPTOR (ServiceFileNameFaoDsc,
"!#AZ!AZ!AZ_ACCESS.LOG!AZ!AZ!AZ!AZ");
static $DESCRIPTOR (ClientPortFaoDsc, "!UL\0");
static $DESCRIPTOR (ElapsedResponseDurationDsc, "!UL\0");
static $DESCRIPTOR (ElapsedSecondsDsc, "!UL.!3ZL\0");
static $DESCRIPTOR (HourlyFaoDsc, "!2ZL\0");
static $DESCRIPTOR (LocalPortFaoDsc, "!UL\0");
static $DESCRIPTOR (NumberFaoDsc, "!UL\0");
static $DESCRIPTOR (Number64FaoDsc, "!@SQ\0");
static $DESCRIPTOR (StatusFaoDsc, "!UL\0");
static $DESCRIPTOR (VmsTimeFaoDsc, "!%D\0");
static $DESCRIPTOR (LogFileTimeFaoDsc,
"!2ZL/!3AZ/!4ZL:!2ZL:!2ZL:!2ZL !3AZ!2AZ");
/* server-host - - [date/time] \"what-status\" 200 0 */
static $DESCRIPTOR (LogFilePseudoFaoDsc,
"!AZ !AZ !AZ [!AZ] \"POST /!AZ::!AZ-!AZ-!8XL HTTP/1.1\" 200 0!AZ!AZ!AZ");
/* server-host - - [date/time] \"TIMESTAMP-count\" 200 0 */
static $DESCRIPTOR (LogFileTimeStampFaoDsc,
"!AZ !AZ !AZ [!AZ] \"POST /!AZ::!AZ-!AZ-!8ZL HTTP/1.1\" 200 0!AZ!AZ!AZ");
/* host r-ident user [date/time] \"request\" status bytes */
static char CommonFormat [] =
"-!CN !ID !AU [!TC] \\q!RQ\\q !RS !BY";
static $DESCRIPTOR (LogFileCommonFaoDsc,
"!AZ !AZ !AZ [!AZ] \"!AZ !AZ!AZ\" !UL !AZ");
/* as for "common" above, plus ' server'*/
static char CommonServerFormat [] =
"-!CN !ID !AU [!TC] \\q!RQ\\q !RS !BY !SN";
static $DESCRIPTOR (LogFileCommonServerFaoDsc,
"!AZ !AZ !AZ [!AZ] \"!AZ !AZ!AZ\" !UL !AZ !AZ");
/* as for "common" above, plus ' referer user-agent'*/
static char CombinedFormat [] =
"-!CN !ID !AU [!TC] \\q!RQ\\q !RS !BY \\q!RF\\q \\q!UA\\q";
static $DESCRIPTOR (LogFileCombinedFaoDsc,
"!AZ !AZ !AZ [!AZ] \"!AZ !AZ!AZ\" !UL !AZ \"!AZ\" \"!AZ\"");
/* user-defined log-file format */
static $DESCRIPTOR (LogFileUserFaoDsc, "!#(AZ)");
static int ExtendBlocks = LOGGING_DEFAULT_EXTEND_BLOCKS;
static ushort WeeklyTime7 [7];
static char ClientPort [16],
Elapsed [32],
HourlyString [3],
IsoTimeString [32],
LengthString [32],
PayloadString [32],
ProcessName [16],
SortableTimeString [32],
StatusString [16],
String [16384],
TimeString [32],
VmsTimeString [32];
static $DESCRIPTOR (ClientPortDsc, ClientPort);
static $DESCRIPTOR (ElapsedDsc, Elapsed);
static $DESCRIPTOR (HourlyStringDsc, HourlyString);
static $DESCRIPTOR (LengthStringDsc, LengthString);
static $DESCRIPTOR (PayloadStringDsc, PayloadString);
static $DESCRIPTOR (StatusStringDsc, StatusString);
static $DESCRIPTOR (StringDsc, String);
static $DESCRIPTOR (TimeStringDsc, TimeString);
static $DESCRIPTOR (VmsTimeStringDsc, VmsTimeString);
static struct FAB LogFileFab;
static struct RAB LogFileRab;
/* for when testing the log format */
static CLIENT_STRUCT DummyClient;
static NETIO_STRUCT DummyNetIo;
static REQUEST_STRUCT DummyRequest;
static SERVICE_STRUCT DummyService;
BOOL PeriodChanged;
int len, status,
SetimrStatus;
ushort slen;
ulong *vecptr,
*Time64Ptr;
ushort *Time7Ptr;
ulong FaoVector [MAX_FAO_VECTOR];
char *aptr, *cptr, *sptr, *zptr,
*FunctionNamePtr;
char MiscChars [MAX_FAO_VECTOR * 2],
ClientCertSubject [512];
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER,
"LoggingDo() !UL !&X !&X", Function, rqptr, svptr);
/* logging to SYS$OUTPUT does not do many of the things that set 'status' */
status = SS$_NORMAL;
if (Function == LOGGING_BEGIN)
{
/*****************/
/* begin logging */
/*****************/
/* if no logging file name from command line then use any config one */
if (!LoggingFileName[0] && Config.cfLog.FileName[0])
strcpy (LoggingFileName, Config.cfLog.FileName);
if (!LoggingFileName[0])
{
if (!(cptr = SysTrnLnm (WASD_LOG)))
if (!(cptr = SysTrnLnm (WASD_LOGS)))
if (!(cptr = SysTrnLnm (HTTPD$LOG)))
return (SS$_NOLOGNAM);
strncpy (LoggingFileName, cptr, sizeof(LoggingFileName)-2);
}
if (!LoggingFileNameLength)
LoggingFileNameLength = strlen(LoggingFileName);
if (strsame (LoggingFileName, "SYS$OUTPUT", -1))
LoggingSysOutput = true;
else
LoggingSysOutput = false;
if (Config.cfLog.ExtendBlocks) ExtendBlocks = Config.cfLog.ExtendBlocks;
if (ExtendBlocks < 0)
ExtendBlocks = 0;
else
if (ExtendBlocks > 65535)
ExtendBlocks = 65535;
/************************/
/* determine log format */
/************************/
svptr->LogFormatProblem = false;
if (LoggingFormatUser[0])
svptr->LogFormatPtr = LoggingFormatUser;
else
if (svptr->LogFormat[0])
svptr->LogFormatPtr = svptr->LogFormat;
else
if (Config.cfLog.Format[0])
svptr->LogFormatPtr = Config.cfLog.Format;
else
svptr->LogFormatPtr = NULL;
if (svptr->LogFormatPtr)
{
if (strsame (svptr->LogFormatPtr, "COMMON", -1))
{
svptr->LogFormatCommonServer = svptr->LogFormatCombined = false;
svptr->LogFormatCommon = svptr->LogFormatStamp = true;
svptr->LogFormatPtr = NULL;
}
else
if (strsame (svptr->LogFormatPtr, "COMMON+", 7))
{
svptr->LogFormatCommon = svptr->LogFormatCommonServer =
svptr->LogFormatCombined = false;
svptr->LogFormatStamp = true;
len = strlen(CommonFormat) + strlen(svptr->LogFormatPtr+7);
aptr = VmGet (len+1);
strcpy (aptr, CommonFormat);
strcat (aptr, svptr->LogFormatPtr+7);
svptr->LogFormatPtr = aptr;
}
else
if (strsame (svptr->LogFormatPtr, "COMMON_SERVER", -1))
{
svptr->LogFormatCommon = svptr->LogFormatCombined = false;
svptr->LogFormatCommonServer = svptr->LogFormatStamp = true;
svptr->LogFormatPtr = NULL;
}
else
if (strsame (svptr->LogFormatPtr, "COMMON_SERVER+", 14))
{
svptr->LogFormatCommon = svptr->LogFormatCommonServer =
svptr->LogFormatCombined = false;
svptr->LogFormatStamp = true;
len = strlen(CommonServerFormat) + strlen(svptr->LogFormatPtr+14);
aptr = VmGet (len+1);
strcpy (aptr, CommonServerFormat);
strcat (aptr, svptr->LogFormatPtr+14);
svptr->LogFormatPtr = aptr;
}
else
if (strsame (svptr->LogFormatPtr, "COMBINED", -1))
{
svptr->LogFormatCommon = svptr->LogFormatCommonServer = false;
svptr->LogFormatCombined = svptr->LogFormatStamp = true;
svptr->LogFormatPtr = NULL;
}
else
if (strsame (svptr->LogFormatPtr, "COMBINED+", 9))
{
svptr->LogFormatCommon = svptr->LogFormatCommonServer =
svptr->LogFormatCombined = false;
svptr->LogFormatStamp = true;
len = strlen(CombinedFormat) + strlen(svptr->LogFormatPtr+9);
aptr = VmGet (len+1);
strcpy (aptr, CombinedFormat);
strcat (aptr, svptr->LogFormatPtr+9);
svptr->LogFormatPtr = aptr;
}
else
svptr->LogFormatCommon = svptr->LogFormatCommonServer =
svptr->LogFormatCombined = false;
if (svptr->LogFormatPtr)
if (strstr (svptr->LogFormatPtr, "!PP"))
LoggingProxyLocalPort = true;
}
else
svptr->LogFormatCommon = true;
/****************************/
/* determine logging period */
/****************************/
LoggingPerPeriod = LoggingPeriodHourly = LoggingPeriodDaily =
LoggingPeriodWeekly = LoggingPeriodMonthly = false;
if (!LoggingPeriodName[0] && Config.cfLog.Period[0])
strcpy (LoggingPeriodName, Config.cfLog.Period);
if (LoggingPeriodName[0])
{
svptr->LogDayNumber =
svptr->LogMonthNumber =
svptr->LogYearNumber = 0;
if (strsame (LoggingPeriodName, "HOURLY", 3))
LoggingPerPeriod = LoggingPeriodHourly = true;
else
if (strsame (LoggingPeriodName, "DAILY", 3))
LoggingPerPeriod = LoggingPeriodDaily = true;
else
if (strsame (LoggingPeriodName, "SUNDAY", 3))
{
LoggingPerPeriod = LoggingPeriodWeekly = true;
LoggingDayWeekBegins = 7;
}
else
if (strsame (LoggingPeriodName, "WEEKLY", 3) ||
strsame (LoggingPeriodName, "MONDAY", 4))
{
LoggingPerPeriod = LoggingPeriodWeekly = true;
LoggingDayWeekBegins = 1;
}
else
if (strsame (LoggingPeriodName, "TUESDAY", 3))
{
LoggingPerPeriod = LoggingPeriodWeekly = true;
LoggingDayWeekBegins = 2;
}
else
if (strsame (LoggingPeriodName, "WEDNESDAY", 3))
{
LoggingPerPeriod = LoggingPeriodWeekly = true;
LoggingDayWeekBegins = 3;
}
else
if (strsame (LoggingPeriodName, "THURSDAY", 3))
{
LoggingPerPeriod = LoggingPeriodWeekly = true;
LoggingDayWeekBegins = 4;
}
else
if (strsame (LoggingPeriodName, "FRIDAY", 3))
{
LoggingPerPeriod = LoggingPeriodWeekly = true;
LoggingDayWeekBegins = 5;
}
else
if (strsame (LoggingPeriodName, "SATURDAY", 3))
{
LoggingPerPeriod = LoggingPeriodWeekly = true;
LoggingDayWeekBegins = 6;
}
else
if (strsame (LoggingPeriodName, "MONTH", 4))
LoggingPerPeriod = LoggingPeriodMonthly = true;
else
{
FaoToStdout ("%HTTPD-W-LOG, period unknown\n \\!AZ\\\n",
LoggingPeriodName);
LoggingPerPeriod = false;
}
}
/*************************/
/* get logging host name */
/*************************/
zptr = (sptr = svptr->LogHostName) + sizeof(svptr->LogHostName)-1;
if (LoggingNaming == LOGGING_NAMING_ADDRESS)
{
/* as much of the IP address as possible */
for (cptr = svptr->ServerIpAddressString;
*cptr && sptr < zptr;
cptr++)
{
if (*cptr == '[' || *cptr == ']') continue;
if (*cptr == '.' || *cptr == ':')
*sptr++ = '-';
else
*sptr++ = *cptr;
}
}
else
if (LoggingNaming == LOGGING_NAMING_HOST)
{
/* as much of the IP host name as possible */
for (cptr = svptr->ServerHostName;
*cptr && sptr < zptr;
cptr++)
{
if (*cptr == '[' || *cptr == ']') continue;
if (*cptr == '.' || *cptr == ':')
*sptr++ = '-';
else
*sptr++ = *cptr;
}
}
else
{
/* default, LOGGING_NAMING_NAME */
if (svptr->ServerHostName[0] == '[')
for (cptr = svptr->ServerHostName;
*cptr && (*cptr == '[' || *cptr == ']' ||
*cptr == ':' || isxdigit(*cptr));
cptr++);
else
for (cptr = svptr->ServerHostName;
*cptr && (*cptr == '.' || isdigit(*cptr));
cptr++);
if (*cptr)
{
/* the first part of the host name */
for (cptr = svptr->ServerHostName;
*cptr && *cptr != '.' && sptr < zptr;
*sptr++ = TOUP(*cptr++));
}
else
{
/* all numeric/IPv6 service name */
for (cptr = svptr->ServerHostName;
*cptr && sptr < zptr;
cptr++)
{
if (*cptr == '[' || *cptr == ']') continue;
if (*cptr == '.' || *cptr == ':')
*sptr++ = '-';
else
*sptr++ = *cptr;
}
}
}
*sptr = '\0';
zptr = (sptr = ProcessName) + sizeof(ProcessName)-1;
for (cptr = HttpdProcess.PrcNam; *cptr && sptr < zptr; cptr++)
if (!isalnum(*cptr)) *sptr++ = '-'; else *sptr++ = TOUP(*cptr);
*sptr = '\0';
if (!LoggingEnabled) return (SS$_NORMAL);
}
if (Function == LOGGING_FLUSH)
{
/******************/
/* flush log file */
/******************/
if (LoggingSysOutput) return (SS$_NORMAL);
if (!svptr->LogFileOpen) return (SS$_NORMAL);
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG, "FLUSH !AZ", svptr->LogFileName);
sys$flush (&svptr->LogFileRab, 0, 0);
return (SS$_NORMAL);
}
if (Function == LOGGING_SHUT)
{
/*****************/
/* shut log file */
/*****************/
if (LoggingSysOutput) return (SS$_NORMAL);
if (!svptr->LogFileOpen) return (SS$_NORMAL);
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG, "SHUT !AZ", svptr->LogFileName);
sys$close (&svptr->LogFileFab, 0, 0);
svptr->LogFileOpen = false;
return (SS$_NORMAL);
}
/*************************/
/* log file name change? */
/*************************/
if (rqptr)
{
/* use the request's times */
Time64Ptr = &rqptr->rqTime.BeginTime64;
Time7Ptr = &rqptr->rqTime.BeginTime7;
}
else
{
/* use the server's times */
Time64Ptr = &HttpdTime64;
Time7Ptr = &HttpdTime7;
}
if (LoggingPerPeriod &&
(Time7Ptr[3] != svptr->LogHourNumber ||
Time7Ptr[2] != svptr->LogDayNumber ||
Time7Ptr[1] != svptr->LogMonthNumber ||
Time7Ptr[0] != svptr->LogYearNumber))
{
PeriodChanged = false;
if (LoggingPeriodHourly)
{
PeriodChanged = true;
svptr->LogYearNumber = Time7Ptr[0];
svptr->LogMonthNumber = Time7Ptr[1];
svptr->LogDayNumber = Time7Ptr[2];
svptr->LogHourNumber = Time7Ptr[3];
}
else
if (LoggingPeriodDaily)
{
if (Time7Ptr[2] != svptr->LogDayNumber ||
Time7Ptr[1] != svptr->LogMonthNumber)
{
PeriodChanged = true;
svptr->LogYearNumber = Time7Ptr[0];
svptr->LogMonthNumber = Time7Ptr[1];
svptr->LogDayNumber = Time7Ptr[2];
svptr->LogHourNumber = Time7Ptr[3];
}
}
else
if (LoggingPeriodWeekly)
{
LoggingWeek (Time64Ptr, Time7Ptr, &WeeklyTime7);
if (WeeklyTime7[0] != svptr->LogYearNumber ||
WeeklyTime7[1] != svptr->LogMonthNumber ||
WeeklyTime7[2] != svptr->LogDayNumber)
{
PeriodChanged = true;
svptr->LogYearNumber = WeeklyTime7[0];
svptr->LogMonthNumber = WeeklyTime7[1];
svptr->LogDayNumber = WeeklyTime7[2];
svptr->LogHourNumber = WeeklyTime7[3];
}
}
else
if (LoggingPeriodMonthly)
{
if (Time7Ptr[1] != svptr->LogMonthNumber)
{
PeriodChanged = true;
svptr->LogYearNumber = Time7Ptr[0];
svptr->LogMonthNumber = Time7Ptr[1];
svptr->LogDayNumber = Time7Ptr[2];
svptr->LogHourNumber = Time7Ptr[3];
}
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (PeriodChanged)
{
if (svptr->LogFileOpen)
{
sys$close (&svptr->LogFileFab, 0, 0);
svptr->LogFileOpen = false;
}
svptr->LogFileNameLength = 0;
svptr->LogFileName[0] = '\0';
}
}
if (!svptr->LogFileOpen &&
!LoggingSysOutput)
{
/*********************/
/* open the log file */
/*********************/
/* initialize the FAB before setting up the file name! */
svptr->LogFileFab = cc$rms_fab;
if (LoggingPerPeriod)
{
/*************************************************/
/* per-period logging (with/without per-service) */
/*************************************************/
if (!svptr->LogFileNameLength)
{
vecptr = FaoVector;
len = strlen(svptr->LogHostName);
/* basically no constraint on ODS-5 */
if (OdsVolumeStructure (LoggingFileName) != 5)
{
/* host name component can be from 17 to 20, or 23 chars max */
if (Config.cfLog.PerServiceHostOnly) {
if (len > 23) len = 23;
}
else {
if (len + strlen(svptr->ServerPortString) > 22)
len = 22 - strlen(svptr->ServerPortString);
}
if (LoggingPeriodHourly) len -= 2;
}
*vecptr++ = len;
*vecptr++ = svptr->LogHostName;
if (Config.cfLog.PerServiceHostOnly)
{
*vecptr++ = "";
*vecptr++ = "";
}
else
{
*vecptr++ = "_";
*vecptr++ = svptr->ServerPortString;
}
if (LoggingPeriodWeekly)
{
*vecptr++ = WeeklyTime7[0];
*vecptr++ = WeeklyTime7[1];
*vecptr++ = WeeklyTime7[2];
}
else
{
*vecptr++ = Time7Ptr[0];
*vecptr++ = Time7Ptr[1];
if (LoggingPeriodMonthly)
*vecptr++ = 1;
else
*vecptr++ = Time7Ptr[2];
}
if (LoggingPeriodHourly)
{
sys$fao (&HourlyFaoDsc, 0, &HourlyStringDsc, Time7Ptr[3]);
*vecptr++ = HourlyString;
}
else
*vecptr++ = "";
if (Config.cfLog.PerInstance)
{
*vecptr++ = "_";
*vecptr++ = SysInfo.NodeName;
*vecptr++ = "_";
*vecptr++ = ProcessName;
}
else
{
*vecptr++ = "";
*vecptr++ = "";
*vecptr++ = "";
*vecptr++ = "";
}
svptr->LogFileNameDsc.dsc$a_pointer = svptr->LogFileName;
svptr->LogFileNameDsc.dsc$w_length = sizeof(svptr->LogFileName)-1;
status = sys$faol (&PeriodFileNameFaoDsc,
&svptr->LogFileNameLength,
&svptr->LogFileNameDsc,
&FaoVector);
if (VMSnok (status))
ErrorExitVmsStatus (status, NULL, FI_LI);
svptr->LogFileName[svptr->LogFileNameLength] = '\0';
}
/* logging file name is used for the directory component only */
svptr->LogFileFab.fab$l_dna = LoggingFileName;
svptr->LogFileFab.fab$b_dns = LoggingFileNameLength;
svptr->LogFileFab.fab$l_fna = svptr->LogFileName;
svptr->LogFileFab.fab$b_fns = svptr->LogFileNameLength;
}
else
if (LoggingNaming)
{
/***************************************/
/* per-service logging (no per-period) */
/***************************************/
if (!svptr->LogFileNameLength)
{
vecptr = FaoVector;
len = strlen(svptr->LogHostName);
/* basically no constraint on ODS-5 */
if (OdsVolumeStructure (LoggingFileName) != 5)
{
/* host name component can be from 26 to 29, or 32 chars max */
if (Config.cfLog.PerServiceHostOnly) {
if (len > 32) len = 32;
}
else {
if (len + strlen(svptr->ServerPortString) > 31)
len = 31 - strlen(svptr->ServerPortString);
}
}
*vecptr++ = len;
*vecptr++ = svptr->LogHostName;
if (Config.cfLog.PerServiceHostOnly)
{
*vecptr++ = "";
*vecptr++ = "";
}
else
{
*vecptr++ = "_";
*vecptr++ = svptr->ServerPortString;
}
if (Config.cfLog.PerInstance)
{
*vecptr++ = "_";
*vecptr++ = SysInfo.NodeName;
*vecptr++ = "_";
*vecptr++ = ProcessName;
}
else
{
*vecptr++ = "";
*vecptr++ = "";
*vecptr++ = "";
*vecptr++ = "";
}
svptr->LogFileNameDsc.dsc$a_pointer = svptr->LogFileName;
svptr->LogFileNameDsc.dsc$w_length = sizeof(svptr->LogFileName)-1;
status = sys$faol (&ServiceFileNameFaoDsc,
&svptr->LogFileNameLength,
&svptr->LogFileNameDsc,
&FaoVector);
if (VMSnok (status))
ErrorExitVmsStatus (status, NULL, FI_LI);
svptr->LogFileName[svptr->LogFileNameLength] = '\0';
}
/* logging file name is used for the directory component only */
svptr->LogFileFab.fab$l_dna = LoggingFileName;
svptr->LogFileFab.fab$b_dns = LoggingFileNameLength;
svptr->LogFileFab.fab$l_fna = svptr->LogFileName;
svptr->LogFileFab.fab$b_fns = svptr->LogFileNameLength;
}
else
{
/******************/
/* fixed log file */
/******************/
/* the logging file name must be complete */
svptr->LogFileFab.fab$l_fna = LoggingFileName;
svptr->LogFileFab.fab$b_fns = LoggingFileNameLength;
}
/************************/
/* create/open log file */
/************************/
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG,
"OPEN !AZ", svptr->LogFileName);
svptr->LogFileFab.fab$l_fop = FAB$M_CIF | FAB$M_DFW |
FAB$M_SQO | FAB$M_TEF;
svptr->LogFileFab.fab$w_deq = ExtendBlocks;
svptr->LogFileFab.fab$b_fac = FAB$M_PUT;
svptr->LogFileFab.fab$b_rfm = FAB$C_STMLF;
svptr->LogFileFab.fab$b_shr = FAB$M_SHRGET | FAB$M_SHRPUT | FAB$M_SHRUPD;
svptr->LogFileFab.fab$b_org = FAB$C_SEQ;
svptr->LogFileFab.fab$b_rat = FAB$M_CR;
/* turn on SYSPRV to allow access to the logging file */
sys$setprv (1, &SysPrvMask, 0, 0);
status = sys$create (&svptr->LogFileFab, 0, 0);
sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSnok (status))
{
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG,
"CREATE !AZ !&S", svptr->LogFileName, status);
if (!svptr->LogFileError)
{
svptr->LogFileError = LoggingFileError = true;
FaoToStdout ("%HTTPD-W-LOG, file create error\n-!&M\n \\!AZ\\\n",
status, svptr->LogFileName);
if (Config.cfLog.WriteFail503) LoggingFileError = true;
}
return (status);
}
svptr->LogFileError = LoggingFileError = false;
svptr->LogFileRab = cc$rms_rab;
svptr->LogFileRab.rab$l_fab = &svptr->LogFileFab;
svptr->LogFileRab.rab$b_mbc = 127;
svptr->LogFileRab.rab$b_mbf = 4;
svptr->LogFileRab.rab$l_rop = RAB$M_EOF | RAB$M_WBH;
if (VMSnok (status = sys$connect (&svptr->LogFileRab, 0, 0)))
{
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG,
"CREATE !AZ !&S", svptr->LogFileName, status);
sys$close (&svptr->LogFileFab, 0, 0);
return (status);
}
svptr->LogFileOpen = true;
}
/***********************/
/* act on the log file */
/***********************/
status = sys$fao (&LogFileTimeFaoDsc, &slen, &TimeStringDsc,
Time7Ptr[2],
MonthName[Time7Ptr[1]],
Time7Ptr[0],
Time7Ptr[3],
Time7Ptr[4],
Time7Ptr[5],
TimeGmtString, TimeGmtString+4);
TimeString[slen] = '\0';
if (Function == LOGGING_BEGIN ||
Function == LOGGING_CLOSE ||
Function == LOGGING_END ||
Function == LOGGING_OPEN ||
Function == LOGGING_SHUT ||
Function == LOGGING_TIMESTAMP)
{
switch (Function)
{
case LOGGING_BEGIN :
LoggingBlankLine (svptr);
FunctionNamePtr = "BEGIN"; break;
case LOGGING_CLOSE :
FunctionNamePtr = "CLOSE"; break;
case LOGGING_END :
FunctionNamePtr = "END"; break;
case LOGGING_OPEN :
FunctionNamePtr = "OPEN"; break;
case LOGGING_SHUT :
FunctionNamePtr = "SHUT"; break;
case LOGGING_TIMESTAMP :
FunctionNamePtr = "TIMESTAMP"; break;
default :
FunctionNamePtr = "*ERROR*";
}
if (svptr->LogFormatStamp)
{
/* nore (stamp) the event in the log file */
vecptr = FaoVector;
*vecptr++ = ServerHostName;
*vecptr++ = "-";
*vecptr++ = HttpdProcess.UserName;
*vecptr++ = TimeString;
*vecptr++ = SysInfo.NodeName;
*vecptr++ = HttpdProcess.PrcNam;
*vecptr++ = FunctionNamePtr;
if (Function == LOGGING_TIMESTAMP)
*vecptr++ = LoggingTimeStampCount;
else
*vecptr++ = ExitStatus;
if (svptr->LogFormatCommonServer)
{
*vecptr++ = " \"-\" \"-\"";
*vecptr++ = "";
*vecptr++ = "";
}
else
if (svptr->LogFormatCombined)
{
*vecptr++ = " \"-\" \"";
*vecptr++ = SoftwareID;
*vecptr++ = "\"";
}
else
{
*vecptr++ = "";
*vecptr++ = "";
*vecptr++ = "";
}
if (Function == LOGGING_TIMESTAMP)
status = sys$faol (&LogFileTimeStampFaoDsc, &slen, &StringDsc,
&FaoVector);
else
status = sys$faol (&LogFilePseudoFaoDsc, &slen, &StringDsc,
&FaoVector);
if (VMSnok (status) || status == SS$_BUFFEROVF)
ErrorExitVmsStatus (status, NULL, FI_LI);
String[slen] = '\0';
if (WATCH_CAT && WatchThisOne)
{
WatchThis (WATCHITM(rqptr), WATCH_LOG,
"ENTRY !UL bytes", slen);
WatchData (String, slen);
}
if (LoggingSysOutput)
fprintf (stdout, "%s\n", String);
else
{
svptr->LogFileRab.rab$l_rbf = String;
svptr->LogFileRab.rab$w_rsz = slen;
if (VMSnok (status = sys$put (&svptr->LogFileRab, 0, 0)))
{
if (!svptr->LogFileError)
{
svptr->LogFileError = LoggingFileError = true;
FaoToStdout ("%HTTPD-W-LOG, \
file write error\n-!&M\n \\!AZ\\\n",
status, svptr->LogFileName);
}
}
else
svptr->LogFileError = LoggingFileError = false;
}
}
if (Function == LOGGING_END ||
Function == LOGGING_CLOSE)
{
/******************/
/* close log file */
/******************/
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG,
"CLOSE !AZ", svptr->LogFileName);
if (LoggingSysOutput) return (SS$_NORMAL);
if (Function == LOGGING_END) LoggingBlankLine (svptr);
sys$close (&svptr->LogFileFab, 0, 0);
svptr->LogFileOpen = false;
}
if (Function != LOGGING_BEGIN) return (SS$_NORMAL);
/***********************/
/* test logging format */
/***********************/
DummyRequest.ClientPtr = &DummyClient;
DummyRequest.NetIoPtr = &DummyNetIo;
DummyRequest.ServicePtr = &DummyService;
rqptr = &DummyRequest;
}
if (!rqptr) return (SS$_NORMAL);
/*************************/
/* format request record */
/*************************/
/* may be too late for the response but ensure it's logged this way */
if (!rqptr->rqHeader.HttpVersion)
rqptr->rqResponse.HttpStatus = 408;
else
if (rqptr->rqTmr.TimeoutType)
rqptr->rqResponse.HttpStatus = 500;
if (svptr->LogFormatPtr)
{
/***********************/
/* user-defined format */
/***********************/
int cnt;
char *cptr, *sptr, *AbsentPtr;
if (svptr->LogFormatProblem) return (SS$_NORMAL);
cnt = 0;
sptr = MiscChars;
AbsentPtr = "";
cptr = svptr->LogFormatPtr;
vecptr = FaoVector;
while (*cptr)
{
if (cnt > MAX_FAO_VECTOR)
ErrorExitVmsStatus (0, ErrorLoggingFormatLength, FI_LI);
if (cnt == 1) AbsentPtr = FaoVector[0];
switch (*cptr)
{
case '!' :
{
cptr++;
switch (*(USHORTPTR)cptr)
{
case 'AR' :
if (!rqptr->rqAuth.RealmPtr)
*vecptr++ = AbsentPtr;
else
if (!rqptr->rqAuth.RealmPtr[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->rqAuth.RealmPtr;
cnt++;
cptr += 2;
continue;
case 'AU' :
if (!rqptr->RemoteUser[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->RemoteUser;
cnt++;
cptr += 2;
continue;
case 'BB' :
if (rqptr->NetIoPtr->BytesRawTx64)
{
static char BytesString [32];
static $DESCRIPTOR (BytesStringDsc, BytesString);
int64 num64;
int length;
DICT_ENTRY_STRUCT *denptr;
if (denptr = ResponseDictHeader (rqptr))
length = DICT_GET_VALUE_LEN(denptr);
else
length = 0;
num64 = rqptr->NetIoPtr->BytesRawTx64;
num64 -= length;
sys$fao (&Number64FaoDsc, 0, &BytesStringDsc, &length);
*vecptr++ = BytesString;
}
else
*vecptr++ = "0";
cnt++;
cptr += 2;
continue;
case 'BQ' :
case 'BY' :
if (rqptr->NetIoPtr->BytesRawTx64)
{
static char BytesString [32];
static $DESCRIPTOR (BytesStringDsc, BytesString);
sys$fao (&Number64FaoDsc, 0, &BytesStringDsc,
&rqptr->NetIoPtr->BytesRawTx64);
*vecptr++ = BytesString;
}
else
*vecptr++ = "0";
cnt++;
cptr += 2;
continue;
case 'CA' :
*vecptr++ = &rqptr->ClientPtr->IpAddressString;
cnt++;
cptr += 2;
continue;
case 'CC' :
/* replace all spaces with underscores */
if (rqptr->rqAuth.ClientCertSubjectPtr &&
rqptr->rqAuth.ClientCertSubjectPtr[0])
{
char *cptr, *sptr, *zptr;
zptr = (sptr = ClientCertSubject) +
sizeof(ClientCertSubject)-1;
for (cptr = rqptr->rqAuth.ClientCertSubjectPtr;
*cptr && sptr < zptr;
cptr++)
{
if (isspace(*cptr))
*sptr++ = '_';
else
*sptr++ = *cptr;
}
*sptr = '\0';
*vecptr++ = ClientCertSubject;
}
else
*vecptr++ = AbsentPtr;
cnt++;
cptr += 2;
continue;
case 'CI' :
/* SSL cipher name added 11-NOV-2014 */
/* cache involvement removed 03-APR-2002 */
if (rqptr->NetIoPtr->SesolaPtr)
*vecptr++ = SesolaRequestCipher (
rqptr->NetIoPtr->SesolaPtr);
else
*vecptr++ = AbsentPtr;
cnt++;
cptr += 2;
continue;
case 'CL' :
/* request content-length value */
if (rqptr->rqHeader.ContentLength64)
{
sys$fao (&Number64FaoDsc, 0, &LengthStringDsc,
&rqptr->rqHeader.ContentLength64);
*vecptr++ = LengthString;
}
else
if (rqptr->rqDictPtr &&
DictLookup (rqptr->rqDictPtr, DICT_TYPE_REQUEST,
"content-length", 14))
*vecptr++ = "0";
else
*vecptr++ = AbsentPtr;
cnt++;
cptr += 2;
continue;
case 'CN' :
*vecptr++ = rqptr->ClientPtr->Lookup.HostName;
cnt++;
cptr += 2;
continue;
case 'CP' :
sys$fao (&ClientPortFaoDsc, 0, &ClientPortDsc,
rqptr->ClientPtr->IpPort);
*vecptr++ = ClientPort;
cnt++;
cptr += 2;
continue;
case 'DI' :
{
int klen;
char key [256];
DICT_ENTRY_STRUCT *denptr;
cptr += 2;
if (*cptr == ':')
{
aptr = cptr + 1;
klen = StringParseOnlyValue (&aptr, key, sizeof(key));
if (klen > 0)
if (denptr = DictLookup (rqptr->rqDictPtr,
DICT_TYPE_CONFIG,
key, klen))
*vecptr++ = DICT_GET_VALUE(denptr);
else
*vecptr++ = AbsentPtr;
else
*vecptr++ = AbsentPtr;
cptr = aptr;
}
else
*vecptr++ = AbsentPtr;
cnt++;
continue;
}
case 'EM' :
{
static char str [32];
double dsecs;
dsecs = -(float)rqptr->rqResponse.Duration64;
sprintf (str, "%u", (ulong)(dsecs / 10000.0));
*vecptr++ = str;
cnt++;
cptr += 2;
continue;
}
case 'ES' :
{
static char str [32];
double dsecs;
dsecs = -(float)rqptr->rqResponse.Duration64;
sprintf (str, "%.6f", dsecs / 10000000.0);
*vecptr++ = str;
cnt++;
cptr += 2;
continue;
}
case 'ET' :
{
static char str [32];
double dsecs;
dsecs = -(float)rqptr->rqResponse.Duration64;
sprintf (str, "%u", (ulong)(dsecs / 10000000.0));
*vecptr++ = str;
cnt++;
cptr += 2;
continue;
}
case 'EU' :
{
static char str [32];
double dsecs;
dsecs = -(float)rqptr->rqResponse.Duration64;
sprintf (str, "%u", (ulong)(dsecs / 10.0));
*vecptr++ = str;
cnt++;
cptr += 2;
continue;
}
case 'HO' :
if (!rqptr->rqHeader.HostPtr)
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->rqHeader.HostPtr;
cnt++;
cptr += 2;
continue;
case 'ID' :
/* obsoleted with WASD v11.0 */
*vecptr++ = AbsentPtr;
cnt++;
cptr += 2;
continue;
case 'II' :
*vecptr++ = LoggingQuoted (rqptr, HttpdProcess.ImageInfo);
cnt++;
cptr += 2;
continue;
case 'ME' :
*vecptr++ = rqptr->rqHeader.MethodName;
cnt++;
cptr += 2;
continue;
case 'NP' :
if (rqptr->NotePadPtr)
*vecptr++ = rqptr->NotePadPtr;
else
*vecptr++ = AbsentPtr;
cnt++;
cptr += 2;
continue;
case 'PA' :
if (!rqptr->rqHeader.PathInfoPtr)
*vecptr++ = AbsentPtr;
else
if (!rqptr->rqHeader.PathInfoPtr[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->rqHeader.PathInfoPtr;
cnt++;
cptr += 2;
continue;
case 'PL' :
/* payload - i.e. number of bytes read in PUT or POST */
sys$fao (&Number64FaoDsc, 0, &PayloadStringDsc,
rqptr->rqBody.ContentCount64);
*vecptr++ = PayloadString;
cnt++;
cptr += 2;
continue;
case 'PP' :
{
static char str [16];
sprintf (str, "%d", rqptr->ProxyLocalPort);
*vecptr++ = str;
cnt++;
cptr += 2;
continue;
}
case 'PR' :
if (rqptr->Http2Stream.Http2Ptr != NULL)
*vecptr++ = " HTTP/2";
else
switch (rqptr->rqHeader.HttpVersion)
{
case HTTP_VERSION_1_1 : *vecptr++ = " HTTP/1.1"; break;
case HTTP_VERSION_1_0 : *vecptr++ = " HTTP/1.0"; break;
case HTTP_VERSION_0_9 : *vecptr++ = " HTTP/0.9"; break;
default : *vecptr++ = AbsentPtr;
}
cnt++;
cptr += 2;
continue;
case 'QS' :
if (!rqptr->rqHeader.QueryStringLength)
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->rqHeader.QueryStringPtr;
cnt++;
cptr += 2;
continue;
case 'RF' :
if (!rqptr->rqHeader.RefererPtr)
*vecptr++ = AbsentPtr;
else
if (!rqptr->rqHeader.RefererPtr[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = LoggingQuoted (rqptr,
rqptr->rqHeader.RefererPtr);
cnt++;
cptr += 2;
continue;
case 'RH' :
if (aptr = LoggingRequestHeader (rqptr, cptr))
{
if (*aptr)
*vecptr++ = aptr;
else
*vecptr++ = AbsentPtr;
cnt++;
/* "RH:field-name:" (it's already been validated!) */
for (cptr += 3; *cptr && *cptr != ':'; cptr++);
if (*cptr) cptr++;
}
else
{
svptr->LogFormatProblem = true;
while (*cptr) cptr++;
}
continue;
case 'RP' :
if (HTTP2_REQUEST(rqptr))
*vecptr++ = "HTTP/2";
else
if (rqptr->rqHeader.HttpVersion == HTTP_VERSION_1_1)
*vecptr++ = "HTTP/1.1";
else
if (rqptr->rqHeader.HttpVersion == HTTP_VERSION_1_0)
*vecptr++ = "HTTP/1.0";
else
if (rqptr->rqHeader.HttpVersion == HTTP_VERSION_0_9)
*vecptr++ = "HTTP/0.9";
else
*vecptr++ = AbsentPtr;
cnt++;
cptr += 2;
continue;
case 'RQ' :
if (!rqptr->rqHeader.MethodName[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->rqHeader.MethodName;
cnt++;
*vecptr++ = " ";
cnt++;
if (!rqptr->rqHeader.RequestUriPtr ||
!rqptr->rqHeader.RequestUriPtr[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = LoggingQuoted (rqptr,
rqptr->rqHeader.RequestUriPtr);
cnt++;
if (rqptr->Http2Stream.Http2Ptr != NULL)
{ *vecptr++ = " HTTP/2"; cnt++; }
else
switch (rqptr->rqHeader.HttpVersion)
{
case HTTP_VERSION_1_0 :
*vecptr++ = " HTTP/1.0"; cnt++; break;
case HTTP_VERSION_1_1 :
*vecptr++ = " HTTP/1.1"; cnt++; break;
default : *vecptr++ = ""; cnt++;
}
cptr += 2;
continue;
case 'RS' :
sys$fao (&StatusFaoDsc, 0, &StatusStringDsc,
rqptr->rqResponse.HttpStatus);
*vecptr++ = StatusString;
cnt++;
cptr += 2;
continue;
case 'SC' :
if (!rqptr->ScriptName[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->ScriptName;
cnt++;
cptr += 2;
continue;
case 'SM' :
/* must come from request's service pointer */
if (!rqptr->ServicePtr->RequestSchemeNamePtr)
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->ServicePtr->RequestSchemeNamePtr;
cnt++;
cptr += 2;
continue;
case 'SN' :
/* must come from request's service pointer */
if (!rqptr->ServicePtr->ServerHostName[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->ServicePtr->ServerHostName;
cnt++;
cptr += 2;
continue;
case 'SP' :
/* must come from request's service pointer */
if (!rqptr->ServicePtr->ServerPortString[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->ServicePtr->ServerPortString;
cnt++;
cptr += 2;
continue;
case 'SR' :
if (rqptr->NetIoPtr->SesolaPtr)
if (SesolaRequestSessionReused (rqptr->NetIoPtr->SesolaPtr))
*vecptr++ = "yes";
else
*vecptr++ = "no";
else
*vecptr++ = AbsentPtr;
cnt++;
cptr += 2;
continue;
case 'SV' :
if (rqptr->NetIoPtr->SesolaPtr)
*vecptr++ = SesolaRequestVersion (
rqptr->NetIoPtr->SesolaPtr);
else
*vecptr++ = AbsentPtr;
cnt++;
cptr += 2;
continue;
case 'TC' :
*vecptr++ = TimeString;
cnt++;
cptr += 2;
continue;
case 'TI' :
HttpIsoTimeString (true, IsoTimeString,
&rqptr->rqTime.BeginTime64);
*vecptr++ = IsoTimeString;
cnt++;
cptr += 2;
continue;
case 'TS' :
HttpIsoTimeString (false, SortableTimeString,
&rqptr->rqTime.BeginTime64);
*vecptr++ = SortableTimeString;
cnt++;
cptr += 2;
continue;
case 'TU' :
case 'TG' : /* backward compatibility */
if (!rqptr->rqTime.GmDateTime[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = rqptr->rqTime.GmDateTime;
cnt++;
cptr += 2;
continue;
case 'TV' :
sys$fao (&VmsTimeFaoDsc, 0, &VmsTimeStringDsc,
&rqptr->rqTime.BeginTime64);
*vecptr++ = VmsTimeString;
cnt++;
cptr += 2;
continue;
case 'UA' :
if (!rqptr->rqHeader.UserAgentPtr)
*vecptr++ = AbsentPtr;
else
if (!rqptr->rqHeader.UserAgentPtr[0])
*vecptr++ = AbsentPtr;
else
*vecptr++ = LoggingQuoted (rqptr,
rqptr->rqHeader.UserAgentPtr);
cnt++;
cptr += 2;
continue;
case 'VS' :
*vecptr++ = rqptr->ServicePtr->ServerHostPort;
cnt++;
cptr += 2;
continue;
case 'XX' :
aptr = cptr;
if (*vecptr = LoggingCustom (rqptr, &aptr))
vecptr++;
else
*vecptr++ = AbsentPtr;
cnt++;
cptr = aptr;
continue;
default :
svptr->LogFormatProblem = true;
while (*cptr) cptr++;
continue;
}
}
case '\\' :
{
cptr++;
switch (*cptr)
{
case '0' :
*vecptr++ = "";
cnt++;
cptr++;
continue;
case 'n' :
*vecptr++ = "\n";
cnt++;
cptr++;
continue;
case 'q' :
*vecptr++ = "\"";
cnt++;
cptr++;
continue;
case 't' :
*vecptr++ = "\t";
cnt++;
cptr++;
continue;
case '!' :
*vecptr++ = "!";
cnt++;
cptr++;
continue;
case '\\' :
*vecptr++ = "\\";
cnt++;
cptr++;
continue;
default :
svptr->LogFormatProblem = true;
while (*cptr) cptr++;
continue;
}
}
default :
{
*sptr = *cptr++;
*vecptr++ = sptr++;
*sptr++ = '\0';
cnt++;
continue;
}
}
}
FaoCheck (sizeof(FaoVector), &FaoVector, vecptr, FI_LI);
/* now set [0] to the repeat count */
FaoVector[0] = cnt - 1;
if (cnt <= 1) svptr->LogFormatProblem = true;
if (svptr->LogFormatProblem)
{
MetaConReport (MetaGlobalServicePtr, METACON_REPORT_ERROR,
"Log format problem with !AZ!AZ\n\\!AZ\\",
svptr->RequestSchemeNamePtr,
svptr->ServerHostPort,
svptr->LogFormatPtr);
FaoToStdout ("%HTTPD-W-LOG, format problem\n \\!AZ\\\n",
svptr->LogFormatPtr);
/* fall-back to providing a common-format log */
svptr->LogFormatCommon = true;
svptr->LogFormatPtr = NULL;
FaoToStdout ("-HTTPD-I-LOG, fall-back to COMMON log format\n");
}
}
if (svptr->LogFormatCommon ||
svptr->LogFormatCommonServer ||
svptr->LogFormatCombined)
{
/*******************/
/* common/combined */
/*******************/
vecptr = FaoVector;
*vecptr++ = rqptr->ClientPtr->Lookup.HostName;
/* X509 client cert auth (replace all spaces with underscores) */
if (rqptr->rqAuth.ClientCertSubjectPtr &&
rqptr->rqAuth.ClientCertSubjectPtr[0])
{
zptr = (sptr = ClientCertSubject) + sizeof(ClientCertSubject)-1;
for (cptr = rqptr->rqAuth.ClientCertSubjectPtr;
*cptr && sptr < zptr;
cptr++)
{
if (isspace(*cptr))
*sptr++ = '_';
else
*sptr++ = *cptr;
}
*sptr = '\0';
*vecptr++ = ClientCertSubject;
}
else
/* track ID obsoleted with WASD v11.0 */
*vecptr++ = "-";
/* if authentication has not been supplied "place-mark" remote user */
if (rqptr->RemoteUser[0])
*vecptr++ = rqptr->RemoteUser;
else
*vecptr++ = "-";
*vecptr++ = TimeString;
if (rqptr->rqHeader.MethodName[0])
*vecptr++ = rqptr->rqHeader.MethodName;
else
*vecptr++ = "-";
if (!rqptr->rqHeader.RequestUriPtr ||
!rqptr->rqHeader.RequestUriPtr[0])
*vecptr++ = "-";
else
*vecptr++ = LoggingQuoted (rqptr, rqptr->rqHeader.RequestUriPtr);
if (rqptr->Http2Stream.Http2Ptr != NULL)
*vecptr++ = " HTTP/2";
else
switch (rqptr->rqHeader.HttpVersion)
{
case HTTP_VERSION_1_0 : *vecptr++ = " HTTP/1.0"; break;
case HTTP_VERSION_1_1 : *vecptr++ = " HTTP/1.1"; break;
default : *vecptr++ = "";
}
*vecptr++ = rqptr->rqResponse.HttpStatus;
if (rqptr->NetIoPtr->BytesRawTx64)
{
static char BytesString [32];
static $DESCRIPTOR (BytesStringDsc, BytesString);
sys$fao (&Number64FaoDsc, 0, &BytesStringDsc,
&rqptr->NetIoPtr->BytesRawTx64);
*vecptr++ = BytesString;
}
else
*vecptr++ = "0";
if (svptr->LogFormatCommonServer)
*vecptr++ = rqptr->ServicePtr->ServerHostName;
else
if (svptr->LogFormatCombined)
{
if (!rqptr->rqHeader.RefererPtr ||
!rqptr->rqHeader.RefererPtr[0])
*vecptr++ = "-";
else
*vecptr++ = LoggingQuoted (rqptr, rqptr->rqHeader.RefererPtr);
if (!rqptr->rqHeader.UserAgentPtr ||
!rqptr->rqHeader.UserAgentPtr[0])
*vecptr++ = "-";
else
*vecptr++ = LoggingQuoted (rqptr, rqptr->rqHeader.UserAgentPtr);
}
}
else
if (!svptr->LogFormatPtr)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
/*************/
/* sys$fao() */
/*************/
if (svptr->LogFormatCommon)
status = sys$faol (&LogFileCommonFaoDsc, &slen, &StringDsc,
&FaoVector);
else
if (svptr->LogFormatCombined)
status = sys$faol (&LogFileCombinedFaoDsc, &slen, &StringDsc,
&FaoVector);
else
if (svptr->LogFormatCommonServer)
status = sys$faol (&LogFileCommonServerFaoDsc, &slen, &StringDsc,
&FaoVector);
else
if (svptr->LogFormatPtr)
status = sys$faol (&LogFileUserFaoDsc, &slen, &StringDsc,
&FaoVector);
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
if (VMSnok (status) || status == SS$_BUFFEROVF)
ErrorNoticed (rqptr, status, NULL, FI_LI);
String[slen] = '\0';
/**********************************/
/* if only testing the log format */
/**********************************/
if (rqptr == &DummyRequest) return (SS$_NORMAL);
/********************/
/* write the record */
/********************/
if (WATCH_CAT && WatchThisOne)
{
if (LoggingPerService)
{
WatchThis (WATCHITM(rqptr), WATCH_LOG, "ENTRY !AZ !UL bytes",
svptr->LogFileName, slen);
WatchData (String, slen);
}
else
{
WatchThis (WATCHITM(rqptr), WATCH_LOG, "ENTRY !UL bytes", slen);
WatchData (String, slen);
}
}
if (LoggingSysOutput)
{
fprintf (stdout, "%s\n", String);
status = SS$_NORMAL;
}
else
{
svptr->LogFileRab.rab$l_rbf = String;
svptr->LogFileRab.rab$w_rsz = slen;
if (VMSnok (status = sys$put (&svptr->LogFileRab, 0, 0)))
{
if (WATCH_CAT && WatchThisOne)
WatchThis (WATCHITM(rqptr), WATCH_LOG,
"PUT !AZ !&S", svptr->LogFileName, status);
if (!svptr->LogFileError)
{
svptr->LogFileError = LoggingFileError = true;
FaoToStdout ("%HTTPD-W-LOG, file write error\n-!&M\n \\!AZ\\\n",
status, svptr->LogFileName);
}
}
else
svptr->LogFileError = LoggingFileError = false;
}
return (status);
}
/*****************************************************************************/
/*
Specialised access log user-defined items usually for particular sites/clients.
They may or may not have any broader application. The 'XX' item results in a
call to this function where the required function is further decoded and
implemented. The result is a pointer to string to be included in the access
log (so \q<string>\q may be necessary) or a NULL. The format pointer is
adjusted to the first white-space character following the custom item.
*/
char* LoggingCustom
(
REQUEST_STRUCT *rqptr,
char **FormatPtrPtr
)
{
int incr;
char *fptr, *rptr;
/*********/
/* begin */
/*********/
fptr = *FormatPtrPtr;
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (NULL, FI_LI, WATCH_MOD__OTHER, "LoggingCustom() !AZ", fptr);
rptr = NULL;
if (strsame (fptr, "XX:conc-auth", incr = 12))
rptr = LoggingCustomConcAuth (rqptr);
else
if (strsame (fptr, "XX:blb", incr = 6))
rptr = "";
else
if (strsame (fptr, "XX:timeout", incr = 10))
rptr = LoggingCustomTimeout (rqptr);
else
if (strsame (fptr, "XX:quotas", incr = 9))
rptr = LoggingCustomQuotas (rqptr);
else
incr = 2;
*FormatPtrPtr = fptr + incr;
return (rptr);
}
/*****************************************************************************/
/*
Return the concurrent number of requests using the same authorisation.
There can be zero (when no authorisation) and a minimum of one (itself).
(compinia.de)
*/
char* LoggingCustomConcAuth (REQUEST_STRUCT *rqptr)
{
static char buf [16];
int cnt;
LIST_ENTRY *leptr;
REQUEST_STRUCT *rqeptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (NULL, FI_LI, WATCH_MOD__OTHER, "LoggingCustomConcAuth()");
if (!rqptr->rqAuth.RealmPtr || !rqptr->RemoteUser[0]) return ("0");
cnt = 1;
for (leptr = RequestList.HeadPtr; leptr; leptr = leptr->NextPtr)
{
rqeptr = (REQUEST_STRUCT*)leptr;
if (rqeptr == rqptr) continue;
if (!rqeptr->rqAuth.RealmPtr) continue;
if (!strsame (rqeptr->rqAuth.RealmPtr, rqptr->rqAuth.RealmPtr, -1))
continue;
if (!rqeptr->RemoteUser[0]) continue;
if (!strsame (rqeptr->RemoteUser, rqptr->RemoteUser, -1)) continue;
cnt++;
}
sprintf (buf, "%d", cnt);
return (buf);
}
/*****************************************************************************/
/*
Return data on server process quotas used and limits.
Trouble-shooting only.
*/
char* LoggingCustomQuotas (REQUEST_STRUCT *rqptr)
{
static ulong JpiAstCnt,
JpiAstLm,
JpiBioCnt,
JpiBytLm,
JpiBytCnt,
JpiBioLm,
JpiCpuTime,
JpiDioCnt,
JpiDioLm,
JpiEnqCnt,
JpiEnqLm,
JpiFilCnt,
JpiFilLm,
JpiPageFlts,
JpiPagFilCnt,
JpiPgFlQuota,
JpiPrcCnt,
JpiPrcLm,
JpiTqCnt,
JpiTqLm,
JpiVirtPeak,
JpiWsSize,
JpiWsPeak;
static VMS_ITEM_LIST3 JpiItems [] =
{
{ sizeof(JpiAstCnt), JPI$_ASTCNT, &JpiAstCnt, 0 },
{ sizeof(JpiAstLm), JPI$_ASTLM, &JpiAstLm, 0 },
{ sizeof(JpiBioCnt), JPI$_BIOCNT, &JpiBioCnt, 0 },
{ sizeof(JpiBioLm), JPI$_BIOLM, &JpiBioLm, 0 },
{ sizeof(JpiBytCnt), JPI$_BYTCNT, &JpiBytCnt, 0 },
{ sizeof(JpiBytLm), JPI$_BYTLM, &JpiBytLm, 0 },
{ sizeof(JpiDioCnt), JPI$_DIOCNT, &JpiDioCnt, 0 },
{ sizeof(JpiDioLm), JPI$_DIOLM, &JpiDioLm, 0 },
{ sizeof(JpiEnqCnt), JPI$_ENQCNT, &JpiEnqCnt, 0 },
{ sizeof(JpiEnqLm), JPI$_ENQLM, &JpiEnqLm, 0 },
{ sizeof(JpiFilCnt), JPI$_FILCNT, &JpiFilCnt, 0 },
{ sizeof(JpiFilLm), JPI$_FILLM, &JpiFilLm, 0 },
{ sizeof(JpiPageFlts), JPI$_PAGEFLTS, &JpiPageFlts, 0 },
{ sizeof(JpiPagFilCnt), JPI$_PAGFILCNT, &JpiPagFilCnt, 0 },
{ sizeof(JpiPgFlQuota), JPI$_PGFLQUOTA, &JpiPgFlQuota, 0 },
{ sizeof(JpiPrcCnt), JPI$_PRCCNT, &JpiPrcCnt, 0 },
{ sizeof(JpiPrcLm), JPI$_PRCLM, &JpiPrcLm, 0 },
{ sizeof(JpiTqCnt), JPI$_TQCNT, &JpiTqCnt, 0 },
{ sizeof(JpiTqLm), JPI$_TQLM, &JpiTqLm, 0 },
{ sizeof(JpiVirtPeak), JPI$_VIRTPEAK, &JpiVirtPeak, 0 },
{ sizeof(JpiWsSize), JPI$_WSSIZE, &JpiWsSize, 0 },
{ sizeof(JpiWsPeak), JPI$_WSPEAK, &JpiWsPeak, 0 },
{0,0,0,0}
};
static char JpiString [256];
static $DESCRIPTOR (JpiStringDsc, JpiString);
static $DESCRIPTOR (StatusFaoDsc, "%X!8XL\0");
static $DESCRIPTOR (JpiFaoDsc, "!UL/!UL,!UL/!UL,!UL/!UL,!UL/!UL,\
!UL/!UL,!UL/!UL,!UL/!UL/!UL,!UL/!UL,!UL/!UL,!UL/!UL/!UL\0");
int status, pid;
ulong *vecptr;
ulong FaoVector [24];
IO_SB IOsb;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (NULL, FI_LI, WATCH_MOD__OTHER, "LoggingCustomMemory()");
pid = 0;
status = sys$getjpiw (EfnWait, &pid, 0, &JpiItems, &IOsb, 0, 0);
if (VMSok (status)) status = IOsb.Status;
if (VMSok (status))
{
vecptr = FaoVector;
*vecptr++ = JpiAstCnt;
*vecptr++ = JpiAstLm;
*vecptr++ = JpiBioCnt;
*vecptr++ = JpiBioLm;
*vecptr++ = JpiBytCnt;
*vecptr++ = JpiBytLm;
*vecptr++ = JpiDioCnt;
*vecptr++ = JpiDioLm;
*vecptr++ = JpiEnqCnt;
*vecptr++ = JpiEnqLm;
*vecptr++ = JpiFilCnt;
*vecptr++ = JpiFilLm;
*vecptr++ = JpiPageFlts;
*vecptr++ = JpiPagFilCnt;
*vecptr++ = JpiPgFlQuota;
*vecptr++ = JpiPrcCnt;
*vecptr++ = JpiPrcLm;
*vecptr++ = JpiTqCnt;
*vecptr++ = JpiTqLm;
*vecptr++ = JpiVirtPeak;
*vecptr++ = JpiWsSize;
*vecptr++ = JpiWsPeak;
status = sys$faol (&JpiFaoDsc, 0, &JpiStringDsc, &FaoVector);
}
if (VMSnok (status))
sys$fao (&StatusFaoDsc, 0, &JpiStringDsc, status);
return (JpiString);
}
/*****************************************************************************/
/*
Return the type of timeout (compinia.de).
*/
char* LoggingCustomTimeout (REQUEST_STRUCT *rqptr)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (NULL, FI_LI, WATCH_MOD__OTHER, "LoggingCustomTimeout()");
rqptr->ServicePtr->LogTimeoutEvents = true;
switch (rqptr->rqTmr.TimeoutType)
{
case TIMEOUT_INPUT : return ("input");
case TIMEOUT_NONE : return (NULL);
case TIMEOUT_NOPROGRESS : return ("no-progress");
case TIMEOUT_OUTPUT : return ("output");
case TIMEOUT_PERSISTENT : return ("persistent");
case TIMEOUT_THROTTLE : return ("throttle");
default : return ("bugcheck");
}
}
/*****************************************************************************/
/*
Insert an empty line into the server access log (visual aid).
*/
void LoggingBlankLine (SERVICE_STRUCT *svptr)
{
int status;
/*********/
/* begin */
/*********/
if (!LoggingEnabled) return;
if (svptr->LogFormatPtr && strstr(svptr->LogFormatPtr,"XX:blb"))
{
svptr->LogFileRab.rab$l_rbf = "\n";
svptr->LogFileRab.rab$w_rsz = 1;
if (VMSnok (status = sys$put (&svptr->LogFileRab, 0, 0)))
ErrorNoticed (NULL, status, NULL, FI_LI);
}
}
/*****************************************************************************/
/*
Some log entry fields are quoted. Ensure any raw quotes in the data to be put
inside those quotes are URI-encoded. If no raw quotes then return a poointer
to the original string. If to be encoded allocate dynamic storage, do the
encoding into that, and return a pointer to that storage.
*/
char* LoggingQuoted
(
REQUEST_STRUCT *rqptr,
char *StringPtr
)
{
int qcnt;
char *aptr, *cptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "LoggingQuoted()");
for (cptr = StringPtr; *cptr && *cptr != '\"'; cptr++);
/* the overwhelming majority will return from here */
if (!*cptr) return (StringPtr);
qcnt = 1;
for (cptr++; *cptr; cptr++) if (*cptr == '\"') qcnt++;
aptr = sptr = VmGetHeap (rqptr, (cptr - StringPtr) + (qcnt * 2));
for (cptr = StringPtr; *cptr; cptr++)
{
if (*cptr == '\"')
{
*sptr++ = '%';
*sptr++ = '2';
*sptr++ = '2';
}
else
*sptr++ = *cptr;
}
return (aptr);
}
/*****************************************************************************/
/*
"RH:field-name:" returns a pointer to the start of the specified field name
value, or pointer to an empty string if not found, or NULL if a directive
format error was detected. This is a reasonably expensive search and logging
directive!
*/
char* LoggingRequestHeader
(
REQUEST_STRUCT *rqptr,
char *DirectivePtr
)
{
int NameLength;
char *cptr, *sptr, *zptr;
char FieldName [256];
DICT_ENTRY_STRUCT *denptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "LoggingRequestHeader()");
cptr = DirectivePtr + 2;
if (*cptr != ':') return (NULL);
zptr = (sptr = FieldName) + sizeof(FieldName)-1;
for (cptr++; *cptr && *cptr != ':' && sptr < zptr; *sptr++ = *cptr++);
if (*cptr != ':') return (NULL);
*sptr = '\0';
NameLength = sptr - FieldName;
if (denptr = DictLookup (rqptr->rqDictPtr, DICT_TYPE_REQUEST,
FieldName, NameLength))
return (DICT_GET_VALUE(denptr));
/* not found */
return ("");
}
/*****************************************************************************/
/*
Fills 'WeeklyTime7Ptr' with the date of the most recent
'LoggingDayWeekBegins' (i.e. the last Monday, Tuesday ... Sunday)
*/
LoggingWeek
(
int64 *Time64Ptr,
ushort *Time7Ptr,
ushort *WeeklyTime7Ptr
)
{
static int64 DeltaDaysTime64,
ResultTime64;
static $DESCRIPTOR (DeltaDaysFaoDsc, "!UL 00:00:00.00");
int status,
DeltaDays;
ushort Length;
char DeltaString [32];
$DESCRIPTOR (DeltaStringDsc, DeltaString);
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "LoggingWeek()");
/* monday == 1, tuesday == 2 ... sunday == 7 */
if ((DeltaDays = HttpdDayOfWeek - LoggingDayWeekBegins) < 0) DeltaDays += 7;
if (!DeltaDays)
{
/* same bat-time, same bat-channel */
memcpy (WeeklyTime7Ptr, Time7Ptr, sizeof(ushort)*7);
return;
}
status = sys$fao (&DeltaDaysFaoDsc, &Length, &DeltaStringDsc, DeltaDays);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
DeltaStringDsc.dsc$w_length = Length;
status = sys$bintim (&DeltaStringDsc, &DeltaDaysTime64);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
ResultTime64 = *(INT64PTR)Time64Ptr + DeltaDaysTime64;
/* overwrite the supplied numeric time with the start of week's */
sys$numtim (WeeklyTime7Ptr, &ResultTime64);
}
/*****************************************************************************/
/*
Return a plain text report comprising access records in the last 65kBytes
(maximum) of the log associated with the specified service. Not asynchronous
but fast (and convenient) enough not to introduce too much granularity.
*/
LoggingReport
(
REQUEST_STRUCT *rqptr,
char *ServerHostPort
)
{
int cnt, status,
BufferBlockCount;
char *cptr, *zptr,
*BufferPtr;
struct FAB LogFileFab;
struct RAB LogFileRab;
struct XABFHC LogFileXabFhc;
SERVICE_STRUCT *svptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"LoggingReport() !&Z", ServerHostPort);
LIST_ITERATE (svptr, &ServiceList)
if (strsame (svptr->ServerHostPort, ServerHostPort, -1)) break;
if (!svptr)
{
rqptr->rqResponse.HttpStatus = 404;
ErrorGeneral (rqptr, "Service not found.", FI_LI);
AdminEnd (rqptr);
return;
}
if (!LoggingPerService) svptr = LIST_GET_HEAD(&ServiceList);
if (!svptr->LogFileNameLength)
{
rqptr->rqResponse.HttpStatus = 404;
ErrorGeneral (rqptr, "Log file not defined.", FI_LI);
AdminEnd (rqptr);
return;
}
/* make sure we get all the latest access records */
if (svptr->LogFileOpen) sys$flush (&svptr->LogFileRab, 0, 0);
LogFileFab = cc$rms_fab;
LogFileFab.fab$l_dna = LoggingFileName;
LogFileFab.fab$b_dns = LoggingFileNameLength;
LogFileFab.fab$l_fna = svptr->LogFileName;
LogFileFab.fab$b_fns = svptr->LogFileNameLength;
LogFileFab.fab$b_fac = FAB$M_GET | FAB$M_BIO;
LogFileFab.fab$b_shr = FAB$M_SHRGET | FAB$M_SHRPUT | FAB$M_UPI;
LogFileFab.fab$l_xab = &LogFileXabFhc;
LogFileXabFhc = cc$rms_xabfhc;
sys$setprv (1, &SysPrvMask, 0, 0);
status = sys$open (&LogFileFab, 0, 0);
sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSok (status)) status = LogFileFab.fab$l_sts;
if (VMSnok (status))
{
rqptr->rqResponse.ErrorTextPtr = svptr->LogFileName;
ErrorVmsStatus (rqptr, status, FI_LI);
AdminEnd (rqptr);
return;
}
if (LogFileXabFhc.xab$l_ebk > 127)
BufferBlockCount = 127;
else
BufferBlockCount = LogFileXabFhc.xab$l_ebk;
BufferPtr = VmGetHeap (rqptr, BufferBlockCount * 512);
LogFileRab = cc$rms_rab;
if (BufferBlockCount >= LogFileXabFhc.xab$l_ebk)
LogFileRab.rab$l_bkt = 1;
else
LogFileRab.rab$l_bkt = LogFileXabFhc.xab$l_ebk - BufferBlockCount + 1;
LogFileRab.rab$l_fab = &LogFileFab;
LogFileRab.rab$l_rop = RAB$M_BIO;
LogFileRab.rab$l_ubf = BufferPtr;
LogFileRab.rab$w_usz = BufferBlockCount * 512;
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"XABFHC ebk:!UL ffb:!UL bkt:!UL usz:!UL",
LogFileXabFhc.xab$l_ebk, LogFileXabFhc.xab$w_ffb,
LogFileRab.rab$l_bkt, LogFileRab.rab$w_usz);
status = sys$connect (&LogFileRab, 0, 0);
if (VMSok (status)) status = LogFileRab.rab$l_sts;
if (VMSnok (status))
{
rqptr->rqResponse.ErrorTextPtr = svptr->LogFileName;
ErrorVmsStatus (rqptr, status, FI_LI);
sys$close (&LogFileFab, 0, 0);
AdminEnd (rqptr);
return;
}
status = sys$read (&LogFileRab, 0, 0);
if (VMSok (status)) status = LogFileRab.rab$l_sts;
if (status == RMS$_EOF) status = SS$_NORMAL;
if (VMSnok (status))
{
rqptr->rqResponse.ErrorTextPtr = svptr->LogFileName;
ErrorVmsStatus (rqptr, status, FI_LI);
sys$close (&LogFileFab, 0, 0);
AdminEnd (rqptr);
return;
}
status = sys$close (&LogFileFab, 0, 0);
if (VMSok (status)) status = LogFileFab.fab$l_sts;
if (VMSnok (status))
{
rqptr->rqResponse.ErrorTextPtr = svptr->LogFileName;
ErrorVmsStatus (rqptr, status, FI_LI);
AdminEnd (rqptr);
return;
}
/* whole records only (quite likely to straddle a block boundary) */
zptr = (cptr = BufferPtr) + LogFileRab.rab$w_rsz;
while (cptr < zptr && *cptr != '\n') cptr++;
cptr++;
/* if empty or only the one record */
if (cptr >= zptr) cptr = BufferPtr;
cnt = LogFileRab.rab$w_rsz - (cptr - BufferPtr);
rqptr->rqResponse.PreExpired = PRE_EXPIRE_ADMIN;
ResponseHeader200 (rqptr, "text/plain", NULL);
if (cnt)
NetWrite (rqptr, AdminEnd, cptr, cnt);
else
AdminEnd (rqptr);
}
/*****************************************************************************/