[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
[1230]
[1231]
[1232]
[1233]
[1234]
[1235]
[1236]
[1237]
[1238]
[1239]
[1240]
[1241]
[1242]
[1243]
[1244]
[1245]
[1246]
[1247]
[1248]
[1249]
[1250]
[1251]
[1252]
[1253]
[1254]
[1255]
[1256]
[1257]
[1258]
[1259]
[1260]
[1261]
[1262]
[1263]
[1264]
[1265]
[1266]
[1267]
[1268]
[1269]
[1270]
[1271]
[1272]
[1273]
[1274]
[1275]
[1276]
[1277]
[1278]
[1279]
[1280]
[1281]
[1282]
[1283]
[1284]
[1285]
[1286]
[1287]
[1288]
[1289]
[1290]
[1291]
[1292]
[1293]
[1294]
[1295]
[1296]
[1297]
[1298]
[1299]
[1300]
[1301]
[1302]
[1303]
[1304]
[1305]
[1306]
[1307]
[1308]
[1309]
[1310]
[1311]
[1312]
[1313]
[1314]
[1315]
[1316]
[1317]
[1318]
[1319]
[1320]
[1321]
[1322]
[1323]
[1324]
[1325]
[1326]
[1327]
[1328]
[1329]
[1330]
[1331]
[1332]
[1333]
[1334]
[1335]
[1336]
[1337]
[1338]
[1339]
[1340]
[1341]
[1342]
[1343]
[1344]
[1345]
[1346]
[1347]
[1348]
[1349]
[1350]
[1351]
[1352]
[1353]
[1354]
[1355]
[1356]
[1357]
[1358]
[1359]
[1360]
[1361]
[1362]
[1363]
[1364]
[1365]
[1366]
[1367]
[1368]
[1369]
[1370]
[1371]
[1372]
[1373]
[1374]
[1375]
[1376]
[1377]
[1378]
[1379]
[1380]
[1381]
[1382]
[1383]
[1384]
[1385]
[1386]
[1387]
[1388]
[1389]
[1390]
[1391]
[1392]
[1393]
[1394]
[1395]
[1396]
[1397]
[1398]
[1399]
[1400]
[1401]
[1402]
[1403]
[1404]
[1405]
[1406]
[1407]
[1408]
[1409]
[1410]
[1411]
[1412]
[1413]
[1414]
[1415]
[1416]
[1417]
[1418]
[1419]
[1420]
[1421]
[1422]
[1423]
[1424]
[1425]
[1426]
[1427]
[1428]
[1429]
[1430]
[1431]
[1432]
[1433]
[1434]
[1435]
[1436]
[1437]
[1438]
[1439]
[1440]
[1441]
[1442]
[1443]
[1444]
[1445]
[1446]
[1447]
[1448]
[1449]
[1450]
[1451]
[1452]
[1453]
[1454]
[1455]
[1456]
[1457]
[1458]
[1459]
[1460]
[1461]
[1462]
[1463]
[1464]
[1465]
[1466]
[1467]
[1468]
[1469]
[1470]
[1471]
[1472]
[1473]
[1474]
[1475]
[1476]
[1477]
[1478]
[1479]
[1480]
[1481]
[1482]
[1483]
[1484]
[1485]
[1486]
[1487]
[1488]
[1489]
[1490]
[1491]
[1492]
[1493]
[1494]
[1495]
[1496]
[1497]
[1498]
[1499]
[1500]
[1501]
[1502]
[1503]
[1504]
[1505]
[1506]
[1507]
[1508]
[1509]
[1510]
[1511]
[1512]
[1513]
[1514]
[1515]
[1516]
[1517]
[1518]
[1519]
[1520]
[1521]
[1522]
[1523]
[1524]
[1525]
[1526]
[1527]
[1528]
[1529]
[1530]
[1531]
[1532]
[1533]
[1534]
[1535]
[1536]
[1537]
[1538]
[1539]
[1540]
[1541]
[1542]
[1543]
[1544]
[1545]
[1546]
[1547]
[1548]
[1549]
[1550]
[1551]
[1552]
[1553]
[1554]
[1555]
[1556]
[1557]
[1558]
[1559]
[1560]
[1561]
[1562]
[1563]
[1564]
[1565]
[1566]
[1567]
[1568]
[1569]
[1570]
[1571]
[1572]
[1573]
[1574]
[1575]
[1576]
[1577]
[1578]
[1579]
[1580]
[1581]
[1582]
[1583]
[1584]
[1585]
[1586]
[1587]
[1588]
[1589]
[1590]
[1591]
[1592]
[1593]
[1594]
[1595]
[1596]
[1597]
[1598]
[1599]
[1600]
[1601]
[1602]
[1603]
[1604]
[1605]
[1606]
[1607]
[1608]
[1609]
[1610]
[1611]
[1612]
[1613]
[1614]
[1615]
[1616]
[1617]
[1618]
[1619]
[1620]
[1621]
[1622]
[1623]
[1624]
[1625]
[1626]
[1627]
[1628]
[1629]
[1630]
[1631]
[1632]
[1633]
[1634]
[1635]
[1636]
[1637]
[1638]
[1639]
[1640]
[1641]
[1642]
[1643]
[1644]
[1645]
[1646]
[1647]
[1648]
[1649]
[1650]
[1651]
[1652]
[1653]
[1654]
[1655]
[1656]
[1657]
[1658]
[1659]
[1660]
[1661]
[1662]
[1663]
[1664]
[1665]
[1666]
[1667]
[1668]
[1669]
[1670]
[1671]
[1672]
[1673]
[1674]
[1675]
[1676]
[1677]
[1678]
[1679]
[1680]
[1681]
[1682]
[1683]
[1684]
[1685]
[1686]
[1687]
[1688]
[1689]
[1690]
[1691]
[1692]
[1693]
[1694]
[1695]
[1696]
[1697]
[1698]
[1699]
[1700]
[1701]
[1702]
[1703]
[1704]
[1705]
[1706]
[1707]
[1708]
[1709]
[1710]
[1711]
[1712]
[1713]
[1714]
[1715]
[1716]
[1717]
[1718]
[1719]
[1720]
[1721]
[1722]
[1723]
[1724]
[1725]
[1726]
[1727]
[1728]
[1729]
[1730]
[1731]
[1732]
[1733]
[1734]
[1735]
[1736]
[1737]
[1738]
[1739]
[1740]
[1741]
[1742]
[1743]
[1744]
[1745]
[1746]
[1747]
[1748]
[1749]
[1750]
[1751]
[1752]
[1753]
[1754]
[1755]
[1756]
[1757]
[1758]
[1759]
[1760]
[1761]
[1762]
[1763]
[1764]
[1765]
[1766]
[1767]
[1768]
[1769]
[1770]
[1771]
[1772]
[1773]
[1774]
[1775]
[1776]
[1777]
[1778]
[1779]
[1780]
[1781]
[1782]
[1783]
[1784]
[1785]
[1786]
[1787]
[1788]
[1789]
[1790]
[1791]
[1792]
[1793]
[1794]
[1795]
[1796]
[1797]
[1798]
[1799]
[1800]
[1801]
[1802]
[1803]
[1804]
[1805]
[1806]
[1807]
[1808]
[1809]
[1810]
[1811]
[1812]
[1813]
[1814]
[1815]
[1816]
[1817]
[1818]
[1819]
[1820]
[1821]
[1822]
[1823]
[1824]
[1825]
[1826]
[1827]
[1828]
[1829]
[1830]
[1831]
[1832]
[1833]
[1834]
[1835]
[1836]
[1837]
[1838]
[1839]
[1840]
[1841]
[1842]
[1843]
[1844]
[1845]
[1846]
[1847]
[1848]
[1849]
[1850]
[1851]
[1852]
[1853]
[1854]
[1855]
[1856]
[1857]
[1858]
[1859]
[1860]
[1861]
[1862]
[1863]
[1864]
[1865]
[1866]
[1867]
[1868]
[1869]
[1870]
[1871]
[1872]
[1873]
[1874]
[1875]
[1876]
[1877]
[1878]
[1879]
[1880]
[1881]
[1882]
[1883]
[1884]
[1885]
[1886]
[1887]
[1888]
[1889]
[1890]
[1891]
[1892]
[1893]
[1894]
[1895]
[1896]
[1897]
[1898]
[1899]
[1900]
[1901]
[1902]
[1903]
[1904]
[1905]
[1906]
[1907]
[1908]
[1909]
[1910]
[1911]
[1912]
[1913]
[1914]
[1915]
[1916]
[1917]
[1918]
[1919]
[1920]
[1921]
[1922]
[1923]
[1924]
[1925]
[1926]
[1927]
[1928]
[1929]
[1930]
[1931]
[1932]
[1933]
[1934]
[1935]
[1936]
[1937]
[1938]
[1939]
[1940]
[1941]
[1942]
[1943]
[1944]
[1945]
[1946]
[1947]
[1948]
[1949]
[1950]
[1951]
[1952]
[1953]
[1954]
[1955]
[1956]
[1957]
[1958]
[1959]
[1960]
[1961]
[1962]
[1963]
[1964]
[1965]
[1966]
[1967]
[1968]
[1969]
[1970]
[1971]
[1972]
[1973]
[1974]
[1975]
[1976]
[1977]
[1978]
[1979]
[1980]
[1981]
[1982]
[1983]
[1984]
[1985]
[1986]
[1987]
[1988]
[1989]
[1990]
[1991]
[1992]
[1993]
[1994]
[1995]
[1996]
[1997]
[1998]
[1999]
[2000]
[2001]
[2002]
[2003]
[2004]
[2005]
[2006]
[2007]
[2008]
[2009]
[2010]
[2011]
[2012]
[2013]
[2014]
[2015]
[2016]
[2017]
[2018]
[2019]
[2020]
[2021]
[2022]
[2023]
[2024]
[2025]
[2026]
[2027]
[2028]
[2029]
[2030]
[2031]
[2032]
[2033]
[2034]
[2035]
[2036]
[2037]
[2038]
[2039]
[2040]
[2041]
[2042]
[2043]
[2044]
[2045]
[2046]
[2047]
[2048]
[2049]
[2050]
[2051]
[2052]
[2053]
[2054]
[2055]
[2056]
[2057]
[2058]
[2059]
[2060]
[2061]
[2062]
[2063]
[2064]
[2065]
[2066]
[2067]
[2068]
[2069]
[2070]
[2071]
[2072]
[2073]
[2074]
[2075]
[2076]
[2077]
[2078]
[2079]
[2080]
[2081]
[2082]
[2083]
[2084]
[2085]
[2086]
[2087]
[2088]
[2089]
[2090]
[2091]
[2092]
[2093]
[2094]
[2095]
[2096]
[2097]
[2098]
[2099]
[2100]
[2101]
[2102]
[2103]
[2104]
[2105]
[2106]
[2107]
[2108]
[2109]
[2110]
[2111]
[2112]
[2113]
[2114]
[2115]
[2116]
[2117]
[2118]
[2119]
[2120]
[2121]
[2122]
[2123]
[2124]
[2125]
[2126]
[2127]
[2128]
[2129]
[2130]
[2131]
[2132]
[2133]
[2134]
[2135]
[2136]
[2137]
[2138]
[2139]
[2140]
[2141]
[2142]
[2143]
[2144]
[2145]
[2146]
[2147]
[2148]
[2149]
[2150]
[2151]
[2152]
[2153]
[2154]
[2155]
[2156]
[2157]
[2158]
[2159]
[2160]
[2161]
[2162]
[2163]
[2164]
[2165]
[2166]
[2167]
[2168]
[2169]
[2170]
[2171]
[2172]
[2173]
[2174]
[2175]
[2176]
[2177]
[2178]
[2179]
[2180]
[2181]
[2182]
[2183]
[2184]
[2185]
[2186]
[2187]
[2188]
[2189]
[2190]
[2191]
[2192]
[2193]
[2194]
[2195]
[2196]
[2197]
[2198]
[2199]
[2200]
[2201]
[2202]
[2203]
[2204]
[2205]
[2206]
[2207]
[2208]
[2209]
[2210]
[2211]
[2212]
[2213]
[2214]
[2215]
[2216]
[2217]
[2218]
[2219]
[2220]
[2221]
[2222]
[2223]
[2224]
[2225]
[2226]
[2227]
[2228]
[2229]
[2230]
[2231]
[2232]
[2233]
[2234]
[2235]
[2236]
[2237]
[2238]
[2239]
[2240]
[2241]
[2242]
[2243]
[2244]
[2245]
[2246]
[2247]
[2248]
[2249]
[2250]
[2251]
[2252]
[2253]
[2254]
[2255]
[2256]
[2257]
[2258]
[2259]
[2260]
[2261]
[2262]
[2263]
[2264]
[2265]
[2266]
[2267]
[2268]
[2269]
[2270]
[2271]
[2272]
[2273]
[2274]
[2275]
[2276]
[2277]
[2278]
[2279]
[2280]
[2281]
[2282]
[2283]
[2284]
[2285]
[2286]
[2287]
[2288]
[2289]
[2290]
[2291]
[2292]
[2293]
[2294]
[2295]
[2296]
[2297]
[2298]
[2299]
[2300]
[2301]
[2302]
[2303]
[2304]
[2305]
[2306]
[2307]
[2308]
[2309]
[2310]
[2311]
[2312]
[2313]
[2314]
[2315]
[2316]
[2317]
[2318]
[2319]
[2320]
[2321]
[2322]
[2323]
[2324]
[2325]
[2326]
[2327]
[2328]
[2329]
[2330]
[2331]
[2332]
[2333]
[2334]
[2335]
[2336]
[2337]
[2338]
[2339]
[2340]
[2341]
[2342]
[2343]
[2344]
[2345]
[2346]
[2347]
[2348]
[2349]
[2350]
[2351]
[2352]
[2353]
[2354]
[2355]
[2356]
[2357]
[2358]
[2359]
[2360]
[2361]
[2362]
[2363]
[2364]
[2365]
[2366]
[2367]
[2368]
[2369]
[2370]
[2371]
[2372]
[2373]
[2374]
[2375]
[2376]
[2377]
[2378]
[2379]
[2380]
[2381]
[2382]
[2383]
[2384]
[2385]
[2386]
[2387]
[2388]
[2389]
[2390]
[2391]
[2392]
[2393]
[2394]
[2395]
[2396]
[2397]
[2398]
[2399]
[2400]
[2401]
[2402]
[2403]
[2404]
[2405]
[2406]
[2407]
[2408]
[2409]
[2410]
[2411]
[2412]
[2413]
[2414]
[2415]
[2416]
[2417]
[2418]
[2419]
[2420]
[2421]
[2422]
[2423]
[2424]
[2425]
[2426]
[2427]
[2428]
[2429]
[2430]
[2431]
[2432]
[2433]
[2434]
[2435]
[2436]
[2437]
[2438]
[2439]
[2440]
[2441]
[2442]
[2443]
[2444]
[2445]
[2446]
[2447]
[2448]
[2449]
[2450]
[2451]
[2452]
[2453]
[2454]
[2455]
[2456]
[2457]
[2458]
[2459]
[2460]
[2461]
[2462]
[2463]
[2464]
[2465]
[2466]
[2467]
[2468]
[2469]
[2470]
[2471]
[2472]
[2473]
[2474]
[2475]
[2476]
[2477]
[2478]
[2479]
[2480]
[2481]
[2482]
[2483]
[2484]
[2485]
[2486]
[2487]
[2488]
[2489]
[2490]
[2491]
[2492]
[2493]
[2494]
[2495]
[2496]
[2497]
[2498]
[2499]
[2500]
[2501]
[2502]
[2503]
[2504]
[2505]
[2506]
[2507]
[2508]
[2509]
[2510]
[2511]
[2512]
[2513]
[2514]
[2515]
[2516]
[2517]
[2518]
[2519]
[2520]
[2521]
[2522]
[2523]
[2524]
[2525]
[2526]
[2527]
[2528]
[2529]
[2530]
[2531]
[2532]
[2533]
[2534]
[2535]
[2536]
[2537]
[2538]
[2539]
[2540]
[2541]
[2542]
[2543]
[2544]
[2545]
[2546]
[2547]
[2548]
[2549]
[2550]
[2551]
[2552]
[2553]
[2554]
[2555]
[2556]
[2557]
[2558]
[2559]
[2560]
[2561]
[2562]
[2563]
[2564]
[2565]
[2566]
[2567]
[2568]
[2569]
[2570]
[2571]
[2572]
[2573]
[2574]
[2575]
[2576]
[2577]
[2578]
[2579]
[2580]
[2581]
[2582]
[2583]
[2584]
[2585]
[2586]
[2587]
[2588]
[2589]
[2590]
[2591]
[2592]
[2593]
[2594]
[2595]
[2596]
[2597]
[2598]
[2599]
[2600]
[2601]
[2602]
[2603]
[2604]
[2605]
[2606]
[2607]
[2608]
[2609]
[2610]
[2611]
[2612]
[2613]
[2614]
[2615]
[2616]
[2617]
[2618]
[2619]
[2620]
[2621]
[2622]
[2623]
[2624]
[2625]
[2626]
[2627]
[2628]
[2629]
[2630]
[2631]
[2632]
[2633]
[2634]
[2635]
[2636]
[2637]
[2638]
[2639]
[2640]
[2641]
[2642]
[2643]
[2644]
[2645]
[2646]
[2647]
[2648]
[2649]
[2650]
[2651]
[2652]
[2653]
[2654]
[2655]
[2656]
[2657]
[2658]
[2659]
[2660]
[2661]
[2662]
[2663]
[2664]
[2665]
[2666]
[2667]
[2668]
[2669]
[2670]
[2671]
[2672]
[2673]
[2674]
[2675]
[2676]
[2677]
[2678]
[2679]
[2680]
[2681]
[2682]
[2683]
[2684]
[2685]
[2686]
[2687]
[2688]
[2689]
[2690]
[2691]
[2692]
[2693]
[2694]
[2695]
[2696]
[2697]
[2698]
[2699]
[2700]
[2701]
[2702]
[2703]
[2704]
[2705]
[2706]
[2707]
[2708]
[2709]
[2710]
[2711]
[2712]
[2713]
[2714]
[2715]
[2716]
[2717]
[2718]
[2719]
[2720]
[2721]
[2722]
[2723]
[2724]
[2725]
[2726]
[2727]
[2728]
[2729]
[2730]
[2731]
[2732]
[2733]
[2734]
[2735]
[2736]
[2737]
[2738]
[2739]
[2740]
[2741]
[2742]
[2743]
[2744]
[2745]
[2746]
[2747]
[2748]
[2749]
[2750]
[2751]
[2752]
[2753]
[2754]
[2755]
[2756]
[2757]
[2758]
[2759]
[2760]
[2761]
[2762]
[2763]
[2764]
[2765]
[2766]
[2767]
[2768]
[2769]
[2770]
[2771]
[2772]
[2773]
[2774]
[2775]
[2776]
[2777]
[2778]
[2779]
[2780]
[2781]
[2782]
[2783]
[2784]
[2785]
[2786]
[2787]
[2788]
[2789]
[2790]
[2791]
[2792]
[2793]
[2794]
[2795]
[2796]
[2797]
[2798]
[2799]
[2800]
[2801]
[2802]
[2803]
[2804]
[2805]
[2806]
[2807]
[2808]
[2809]
[2810]
[2811]
[2812]
[2813]
[2814]
[2815]
[2816]
[2817]
[2818]
[2819]
[2820]
[2821]
[2822]
[2823]
[2824]
[2825]
[2826]
[2827]
[2828]
[2829]
[2830]
[2831]
[2832]
[2833]
[2834]
[2835]
[2836]
[2837]
[2838]
[2839]
[2840]
[2841]
[2842]
[2843]
[2844]
[2845]
[2846]
[2847]
[2848]
[2849]
[2850]
[2851]
[2852]
[2853]
[2854]
[2855]
[2856]
[2857]
[2858]
[2859]
[2860]
[2861]
[2862]
[2863]
[2864]
[2865]
[2866]
[2867]
[2868]
[2869]
[2870]
[2871]
[2872]
[2873]
[2874]
[2875]
[2876]
[2877]
[2878]
[2879]
[2880]
[2881]
[2882]
[2883]
[2884]
[2885]
[2886]
[2887]
[2888]
[2889]
[2890]
[2891]
[2892]
[2893]
[2894]
[2895]
[2896]
[2897]
[2898]
[2899]
[2900]
[2901]
[2902]
[2903]
[2904]
[2905]
[2906]
[2907]
[2908]
[2909]
[2910]
[2911]
[2912]
[2913]
[2914]
[2915]
[2916]
[2917]
[2918]
[2919]
[2920]
[2921]
[2922]
[2923]
[2924]
[2925]
[2926]
[2927]
[2928]
[2929]
[2930]
[2931]
[2932]
[2933]
[2934]
[2935]
[2936]
[2937]
[2938]
[2939]
[2940]
[2941]
[2942]
[2943]
[2944]
[2945]
[2946]
[2947]
[2948]
[2949]
[2950]
[2951]
[2952]
[2953]
[2954]
[2955]
[2956]
[2957]
[2958]
[2959]
[2960]
[2961]
[2962]
[2963]
[2964]
[2965]
[2966]
[2967]
[2968]
[2969]
[2970]
[2971]
[2972]
[2973]
[2974]
[2975]
[2976]
[2977]
[2978]
[2979]
[2980]
[2981]
[2982]
[2983]
[2984]
[2985]
[2986]
[2987]
[2988]
[2989]
[2990]
[2991]
[2992]
[2993]
[2994]
[2995]
[2996]
[2997]
[2998]
[2999]
[3000]
[3001]
[3002]
[3003]
[3004]
[3005]
[3006]
[3007]
[3008]
[3009]
[3010]
[3011]
[3012]
[3013]
[3014]
[3015]
[3016]
[3017]
[3018]
[3019]
[3020]
[3021]
[3022]
[3023]
[3024]
[3025]
[3026]
[3027]
[3028]
[3029]
[3030]
[3031]
[3032]
[3033]
[3034]
[3035]
[3036]
[3037]
[3038]
[3039]
[3040]
[3041]
[3042]
[3043]
[3044]
[3045]
[3046]
[3047]
[3048]
[3049]
[3050]
[3051]
[3052]
[3053]
[3054]
[3055]
[3056]
[3057]
[3058]
[3059]
[3060]
[3061]
[3062]
[3063]
[3064]
[3065]
[3066]
[3067]
[3068]
[3069]
[3070]
[3071]
[3072]
[3073]
[3074]
[3075]
[3076]
[3077]
[3078]
[3079]
[3080]
[3081]
[3082]
[3083]
[3084]
[3085]
[3086]
[3087]
[3088]
[3089]
[3090]
[3091]
[3092]
[3093]
[3094]
[3095]
[3096]
[3097]
[3098]
[3099]
[3100]
[3101]
[3102]
[3103]
[3104]
[3105]
[3106]
[3107]
[3108]
[3109]
[3110]
[3111]
[3112]
[3113]
[3114]
[3115]
[3116]
[3117]
[3118]
[3119]
[3120]
[3121]
[3122]
[3123]
[3124]
[3125]
[3126]
[3127]
[3128]
[3129]
[3130]
[3131]
[3132]
[3133]
[3134]
[3135]
[3136]
[3137]
[3138]
[3139]
[3140]
[3141]
[3142]
[3143]
[3144]
[3145]
[3146]
[3147]
[3148]
[3149]
[3150]
[3151]
[3152]
[3153]
[3154]
[3155]
[3156]
[3157]
[3158]
[3159]
[3160]
[3161]
[3162]
[3163]
[3164]
[3165]
[3166]
[3167]
[3168]
[3169]
[3170]
[3171]
[3172]
[3173]
[3174]
[3175]
[3176]
[3177]
[3178]
[3179]
[3180]
[3181]
[3182]
[3183]
[3184]
[3185]
[3186]
[3187]
[3188]
[3189]
[3190]
[3191]
[3192]
[3193]
[3194]
[3195]
[3196]
[3197]
[3198]
[3199]
[3200]
[3201]
[3202]
[3203]
[3204]
[3205]
[3206]
[3207]
[3208]
[3209]
[3210]
[3211]
[3212]
[3213]
[3214]
[3215]
[3216]
[3217]
[3218]
[3219]
[3220]
[3221]
[3222]
[3223]
[3224]
[3225]
[3226]
[3227]
[3228]
[3229]
[3230]
[3231]
[3232]
[3233]
[3234]
[3235]
[3236]
[3237]
[3238]
[3239]
[3240]
[3241]
[3242]
[3243]
[3244]
[3245]
[3246]
[3247]
[3248]
[3249]
[3250]
[3251]
[3252]
[3253]
[3254]
[3255]
[3256]
[3257]
[3258]
[3259]
[3260]
[3261]
[3262]
[3263]
[3264]
[3265]
[3266]
[3267]
[3268]
[3269]
[3270]
[3271]
[3272]
[3273]
[3274]
[3275]
[3276]
[3277]
[3278]
[3279]
[3280]
[3281]
[3282]
[3283]
[3284]
[3285]
[3286]
[3287]
[3288]
[3289]
[3290]
[3291]
[3292]
[3293]
[3294]
[3295]
[3296]
[3297]
[3298]
[3299]
[3300]
[3301]
[3302]
[3303]
[3304]
[3305]
[3306]
[3307]
[3308]
[3309]
[3310]
[3311]
[3312]
[3313]
[3314]
[3315]
[3316]
[3317]
[3318]
[3319]
[3320]
[3321]
[3322]
[3323]
[3324]
[3325]
[3326]
[3327]
[3328]
[3329]
[3330]
[3331]
[3332]
[3333]
[3334]
[3335]
[3336]
[3337]
[3338]
[3339]
[3340]
[3341]
[3342]
[3343]
[3344]
[3345]
[3346]
[3347]
[3348]
[3349]
[3350]
[3351]
[3352]
[3353]
[3354]
[3355]
[3356]
[3357]
[3358]
[3359]
[3360]
[3361]
[3362]
[3363]
[3364]
[3365]
[3366]
[3367]
[3368]
[3369]
[3370]
[3371]
[3372]
[3373]
[3374]
[3375]
[3376]
[3377]
[3378]
[3379]
[3380]
[3381]
[3382]
[3383]
[3384]
[3385]
[3386]
[3387]
[3388]
[3389]
[3390]
[3391]
[3392]
[3393]
[3394]
[3395]
[3396]
[3397]
[3398]
[3399]
[3400]
[3401]
[3402]
[3403]
[3404]
[3405]
[3406]
[3407]
[3408]
[3409]
[3410]
[3411]
[3412]
[3413]
[3414]
[3415]
[3416]
[3417]
[3418]
[3419]
[3420]
[3421]
[3422]
[3423]
[3424]
[3425]
[3426]
[3427]
[3428]
[3429]
[3430]
[3431]
[3432]
[3433]
[3434]
[3435]
[3436]
[3437]
[3438]
[3439]
[3440]
[3441]
[3442]
[3443]
[3444]
[3445]
[3446]
[3447]
[3448]
[3449]
[3450]
[3451]
[3452]
[3453]
[3454]
[3455]
[3456]
[3457]
[3458]
[3459]
[3460]
[3461]
[3462]
[3463]
[3464]
[3465]
[3466]
[3467]
[3468]
[3469]
[3470]
[3471]
[3472]
[3473]
[3474]
[3475]
[3476]
[3477]
[3478]
[3479]
[3480]
[3481]
[3482]
[3483]
[3484]
[3485]
[3486]
[3487]
[3488]
[3489]
[3490]
[3491]
[3492]
[3493]
[3494]
[3495]
[3496]
[3497]
[3498]
[3499]
[3500]
[3501]
[3502]
[3503]
[3504]
[3505]
[3506]
[3507]
[3508]
[3509]
[3510]
[3511]
[3512]
[3513]
[3514]
[3515]
[3516]
[3517]
[3518]
[3519]
[3520]
[3521]
[3522]
[3523]
[3524]
[3525]
[3526]
[3527]
[3528]
[3529]
[3530]
[3531]
[3532]
[3533]
[3534]
[3535]
[3536]
[3537]
[3538]
[3539]
[3540]
[3541]
[3542]
[3543]
[3544]
[3545]
[3546]
[3547]
[3548]
[3549]
[3550]
[3551]
[3552]
[3553]
[3554]
[3555]
[3556]
[3557]
[3558]
[3559]
[3560]
[3561]
[3562]
[3563]
[3564]
[3565]
[3566]
[3567]
[3568]
[3569]
[3570]
[3571]
[3572]
[3573]
[3574]
[3575]
[3576]
[3577]
[3578]
[3579]
[3580]
[3581]
[3582]
[3583]
[3584]
[3585]
[3586]
[3587]
[3588]
[3589]
[3590]
[3591]
[3592]
[3593]
[3594]
[3595]
[3596]
[3597]
[3598]
[3599]
[3600]
[3601]
[3602]
[3603]
[3604]
[3605]
[3606]
[3607]
[3608]
[3609]
[3610]
[3611]
[3612]
[3613]
[3614]
[3615]
[3616]
[3617]
[3618]
[3619]
[3620]
[3621]
[3622]
[3623]
[3624]
[3625]
[3626]
[3627]
[3628]
[3629]
[3630]
[3631]
[3632]
[3633]
[3634]
[3635]
[3636]
[3637]
[3638]
[3639]
[3640]
[3641]
[3642]
[3643]
[3644]
[3645]
[3646]
[3647]
[3648]
[3649]
[3650]
[3651]
[3652]
[3653]
[3654]
[3655]
[3656]
/*****************************************************************************/
/*
Conan.c
CGI-compliant script providing access to VMS help and text libraries.
Can be used in the WASD CGI, WASD CGI-plus, OSU and vanilla CGI environments.
"Conan The Librarian"
AND REMEMBER ... Conan can be used as a CGIplus script. This may require the
script to be purged from the server before new startup parameters come into
effect. Use a command like the following:
HTTPD /DO=DCL=PURGE
WASD SERVER CONFIGURATION
-------------------------
This script uses URL-style paths for accessing libraries. The HTTP server must
therefore provide a mapping for all directories that libraries will be
accessed. Something like:
pass /sys$common/syshlp/* /sys$common/syshlp/*
If auto-scripting is available (as with WASD) these should also be a
configuration directive providing this (example from WASD):
.HLB application/x-script /Conan VMS help library
HELP LIBRARIES
--------------
Help library modules have a reasonably complex internal structure described in
the "Utility Routines Manual" and the "Command Definition, Librarian, and
Message Utilities Manual". The structure will not be described here.
KeyWord[1]...KeyWord[10] represent the help keywords 1...10 that are used as
keys into help information.
CGI ENVIRONMENT VARIABLES
-------------------------
?single=1 one module per line (rather than alphabetically grouped)
?extract=1 extract (rather than format) a Help module
(the final 'e' in 'explode' is a link to this)
LOGICAL NAMES
-------------
CONAN$DBUG turns on all "if (Debug)" statements
CONAN$PARAM equivalent to (overrides) the command line
parameters/qualifiers (define as a system-wide logical)
HTTPD$GMT timezone offset from Greenwich Mean Time
(e.g. "+09:30" and only needed if DTSS is not in use)
QUALIFIERS
----------
/BUTTONS= custom button string
/CHARSET= "Content-Type: text/html; charset=...", empty suppress charset
/DBUG turns on all "if (Debug)" statements
/[NO]ODS5 control extended file specification (basically for testing)
/SINGLE one module per line (rather than alphabetically grouped)
for all requests
/STYLE= URL for site CSS style sheet
BUILD DETAILS
-------------
See BUILD_CONAN.COM procedure.
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!)
---------------
31-AUG-2020 MGD v4.1.2, bugfix; eliminate &referer= XSS vulnerability
10-FEB-2020 MGD v4.1.1, put constraints on some parameters
28-JUL-2015 MGD v4.1.0, why not HEAD as it's just a foreshortened GET?
04-OCT-2014 MGD v4.0.0, a nod to the twenty-first century
30-DEC-2008 MGD v3.7.5, bugfix; OTS Bug? See notes in code below.
10-MAY-2005 MGD v3.7.4, SWS 2.0 ignore query string components supplied as
command-line parameters differently to CSWS 1.2/3
23-DEC-2003 MGD v3.7.3, minor conditional mods to support IA64
12-APR-2003 MGD v3.7.2, link colour changed to 0000cc
20-AUG-2002 MGD v3.7.1, allow for HTTP/1.1 'Cache-control:' field used
by Mozilla variants (instead of HTTP/1.0 'pragma:')
17-AUG-2002 MGD v3.7.0, changed help module formatting that absorbed
all leading white-space destroying intentional
formatting (surprised someone hasn't complained
about it long before this - thanks Dave Pampreen.),
extract a help module as a plain-text page
(click on the final 'e' in 'explode'),
some accomodations for CSWS v1.2,
bugfix; allow for strings with space separated
keywords as help keywords in OpenHelpModule()
01-JUL-2001 MGD v3.6.1, add 'SkipParameters' for direct OSU support
28-OCT-2000 MGD v3.6.0, use CGILIB object module
11-APR-2000 MGD v3.5.0, support extended file specifications (ODS-5),
bugfix; eliminate extraneous comma in keyword list
07-AUG-1999 MGD v3.4.0, use more of the CGILIB functionality
29-JUN-1999 MGD v3.3.0, optional module name list of one per line
(rather than alphabetically grouped)
24-APR-1999 MGD v3.2.0, use CGILIB.C,
standard CGI environment (Netscape FastTrack)
02-OCT-1998 MGD v3.1.0, provide content-type "; charset=..."
08-AUG-1998 MGD v3.0.3, OSU output processing reworked,
bugfix; TimeSetTimezone() 'Seconds' unsigned->signed
06-AUG-1998 MGD v3.0.2, accomodation for OSU ... reduce HTTP response
header carriage control from <CR><LF> to <LF> only
(OSU/IE4 combination problematic)
01-AUG-1998 MGD v3.0.1, suppress table background colours if empty,
accomodations for OSU environment
29-APR-1998 MGD v3.0.0, remove need for WASD MapUrl() functions
(making it a GENERIC CGI script!!),
some tidying up and cosmetic changes
26-FEB-1998 MGD v2.9.2, added HTML table around title in help library,
TimeSetGmt() modified to be in line with HTTPd
19-AUG-1997 MGD v2.9.1, MapUrl() to MapUrl_Map() for conditional mapping
20-JUL-1997 MGD v2.9.0, added /BODY= qualifier (changed background colour)
20-JUN-1997 MGD v2.8.0, compatible with standard and CGIplus environments,
"Pragma: no-cache" now overrides "If-Modified-Since:"
14-MAR-1997 MGD v2.7.1, bugfix; absorbtion of leading white-space
07-AUG-1996 MGD v2.7.0, allow help topic to be specified in path, for example
"/conan/run/process" or "/help/delete/file"
16-MAY-1996 MGD v2.6.2, changed XBMs to tranparaent GIFs
23-FEB-1996 MGD v2.6.1, bugfix, after modifying the HTTPD$GMT format for the
HTTPd server I had forgotten about some scripts
12-OCT-1995 MGD v2.6.0, added 'Referer:', 'Last-Modified:'/'If-Modified-Since:'
18-AUG-1995 MGD v2.5.0, added "search" form at appropriate places
20-JUN-1995 MGD v2.4.0, added "explode" feature, lists all help levels below
the key specified in a single page
24-MAY-1995 MGD v2.3.0, minor changes for AXP compatibility
31-MAR-1995 MGD v2.2.0, ongoing maintenance
02-FEB-1995 MGD v2.1.0, add "Conan the Librarian" icon
13-DEC-1994 MGD v2.0.0, made CGI compliant
09-JUL-1994 MGD v1.0.0, initial development
*/
/*****************************************************************************/
#define SOFTWAREVN "4.1.2"
#define SOFTWARENM "CONAN"
#define SOFTWARECR "Copyright (C) 1996-2020 Mark G.Daniel"
#ifdef __ALPHA
# define SOFTWAREID SOFTWARENM " AXP-" SOFTWAREVN
#endif
#ifdef __ia64
# define SOFTWAREID SOFTWARENM " IA64-" SOFTWAREVN
#endif
#ifdef __VAX
# define SOFTWAREID SOFTWARENM " VAX-" SOFTWAREVN
#endif
#ifdef __x86_64
# define SOFTWAREID SOFTWARENM " X86-" SOFTWAREVN
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
/* VMS related header files */
#include <descrip.h>
#include <iodef.h>
#include <jpidef.h>
#include <libdef.h>
#include <libdtdef.h>
#include <lbrdef.h>
#include <lhidef.h>
#include <lnmdef.h>
#include <rms.h>
#include <ssdef.h>
#include <stsdef.h>
#include <syidef.h>
/* application related header files */
#include "enamel.h"
#include <cgilib.h>
#ifndef __VAX
# pragma nomember_alignment
#endif
#ifndef __VAX
# ifndef NO_ODS_EXTENDED
# define ODS_EXTENDED 1
/* this is smaller than the technical maximum, but still quite large! */
# define ODS_MAX_FILE_NAME_LENGTH 511
# define ODS_MAX_FILESYS_NAME_LENGTH 264
# endif
#endif
#define ODS2_MAX_FILE_NAME_LENGTH 255
#ifndef ODS_MAX_FILE_NAME_LENGTH
# define ODS_MAX_FILE_NAME_LENGTH ODS2_MAX_FILE_NAME_LENGTH
#endif
#if ODS_MAX_FILE_NAME_LENGTH < ODS2_MAX_FILE_NAME_LENGTH
# define ODS_MAX_FILE_NAME_LENGTH ODS2_MAX_FILE_NAME_LENGTH
#endif
#define DEFAULT_STYLE "\
body { margin:0.5em; background-color:white; color:black; \
font-family:sans-serif; }\n\
a { text-decoration:none; color:black; \
border:1px solid slategray; border-radius:3px; padding:1px 5px 1px 5px; }\n\
.header { padding:0.5em 0.5em 0.5em 1em; background-color: gainsboro; \
border:1px solid lightslategray; border-radius:1px; \
font-size: 140%; font-weight: bold; }\n\
.helpmodules, .textmodules { width:90%; margin:1.0em 0 1.0em 1.4em; }\n\
.helpmodules a, .textmodules a { line-height:1.7em; \
background-color:whitesmoke; \
white-space:nowrap; margin-right:0.1em; }\n\
.helpmodules p, .textmodules p { margin:0.6em 0 0.5em 0; }\n\
.searchform { margin:1em; }\n\
.results { margin:1.5em 2em 1em 2em; }\n\
.libcontent { margin:1em; }\n\
.libcontent a { background-color:whitesmoke; white-space:nowrap; }\n\
.addinfo { margin:1em; max-width:50em; }\n\
.addinfo a { line-height:1.7em; white-space:nowrap; margin-right:0.1em; }\n\
.module { white-space:pre; }\n\
.buttonbar { padding:0.7em 1em 0.7em 1em; \
border:1px solid lightslategray; border-radius:1px; \
background-color: gainsboro; min-height:1.3em; }\n\
.buttonbar a { text-decoration:none; color:inherit; \
border:1px solid slategray; border-radius:3px; padding:1px 5px 2px 5px; }\n\
.explode { padding-left:4em; font-size:70%; }\n\
.explevel { font-weight:bold; font-size:105% }\n\
.explevel1 { font-weight:bold; font-size:120% }\n\
.helpresult { white-space:nowrap; }\n\
.textresult { font-family:monospace; white-space:nowrap; }\n\
.highlight { border: 1px dotted slategray; \
padding:0 2px 0 2px; background-color:yellow; }\n\
.searchstats { font-size:90%; }\n\
"
#define boolean int
#define true 1
#define false 0
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define FI_LI __FILE__, __LINE__
#define DEFAULT_LIBRARY "SYS$HELP:HELPLIB.HLB"
#define DEFAULT_BUTTONS "↶Back=javascript:parent.history.go(-1)$\
Close$^Help=/conan/-/conanhelp.html"
char Utility [] = "CONAN";
boolean Debug,
CliListSingle,
DoHeaderInformation,
DoListLibraries,
DoLibraryMenu,
DoLibraryOpen,
DoSearch,
DoSearchStatistics,
ExplodeHelp,
ExtractHelp,
MethodGet,
MethodHead,
KeyNameWildcard,
ListSingle,
OsuEnvironment,
StdCgiEnvironment,
TimeAheadOfGmt;
int SearchHitCount,
KeyWordCount,
OdsExtended,
RecordsSearched,
SearchStringLength;
unsigned long LibraryIndex,
IndexNumber;
unsigned long IfModifiedSinceBinaryTime [2],
TimeGmtDeltaBinary [2];
char ContentTypeCharset [64],
DefaultButtons [] = DEFAULT_BUTTONS,
DefaultStyle [] = DEFAULT_STYLE,
HtmlFormTitle [256],
HtmlLibraryTitle [256],
HtmlReferer [512],
HtmlSearchString [512],
LastModifiedGmDateTime [32],
LibraryDirPath [ODS_MAX_FILE_NAME_LENGTH+1],
LibraryFileName [ODS_MAX_FILE_NAME_LENGTH+1],
LibraryPathInfo [ODS_MAX_FILE_NAME_LENGTH+1],
LibrarySpec [ODS_MAX_FILE_NAME_LENGTH+1],
LibraryTitle [256],
TimeGmtString [32],
TimeGmtVmsString [32],
UnixDateTime [64],
UriFormTitle [256],
UriReferer [512];
char *ButtonsPtr = DefaultButtons,
*CgiHttpIfModifiedSincePtr,
*CgiHttpPragmaPtr,
*CgiHttpCacheControlPtr,
*CgiLibEnvironmentPtr,
*CgiPathInfoPtr,
*CgiPathTranslatedPtr,
*CgiRequestMethodPtr,
*CgiScriptNamePtr,
*CgiServerSoftwarePtr,
*CgiFormDoPtr,
*CgiFormExplodePtr,
*CgiFormExtractPtr,
*CgiFormKeyPtr,
*CgiFormRefererPtr,
*CgiFormTitlePtr,
*CgiFormSearchPtr,
*CgiFormSinglePtr,
*CliCharsetPtr,
*CharsetPtr,
*StyleSheetPtr = "";
/* element 0 is not used, keywords number from 1 to 10 */
char KeyWord [11][256],
KeyWordHtml [11][256],
KeyName [11][256],
KeyNameHtml [11][256],
SoftwareCopy [] = SOFTWARECR,
SoftwareID [48];
struct lhidef LibraryHeader;
struct {
unsigned long lo32;
unsigned long hi32;
} ModuleRFA;
/* CGIplus specific */
int IsCgiPlus,
CgiPlusUsageCount;
/* required function prototypes */
char* ButtonBarButton (char*, char*);
char* SearchText (char*, char*, boolean);
int ListHelpModule (struct dsc$descriptor_s*, void*);
int ListTextModule (struct dsc$descriptor_s*, void*);
char* MungeUnderScores (char*);
char* FormatRequestKeys (boolean, int);
int ExtractHelpModule (struct dsc$descriptor_s*, void*);
int OpenHelpModule (struct dsc$descriptor_s*, void*);
int OpenTextModule (struct dsc$descriptor_s*, void*);
int SearchHelpModule (struct dsc$descriptor_s*, void*);
int SearchTextModule (struct dsc$descriptor_s*, void*);
struct dsc$descriptor_s* KeyNameDsc ();
char* XSSuspect (char*);
/*****************************************************************************/
/*
'argc' and 'argv' are only required to support CgiLibEnvironmentInit(), in
particular the OSU environment.
*/
main
(
int argc,
char *argv[]
)
{
int idx,
status;
char *cptr, *sptr;
/*********/
/* begin */
/*********/
sprintf (SoftwareID, "%s (%s)", SOFTWAREID, CgiLibEnvironmentVersion());
if (getenv ("CONAN$DBUG")) Debug = true;
CgiLibEnvironmentSetDebug (Debug);
if (Debug) fputs ("Content-Type: text/plain\n\n", stdout);
CgiLibEnvironmentInit (argc, argv, false);
CgiLibEnvironmentPtr = CgiLibEnvironmentName();
GetParameters ();
CgiLibResponseSetCharset (CliCharsetPtr);
CgiLibResponseSetSoftwareID (SoftwareID);
CgiLibResponseSetErrorMessage ("Reported by Conan The Librarian");
IsCgiPlus = CgiLibEnvironmentIsCgiPlus ();
#ifdef ODS_EXTENDED
OdsExtended = (GetVmsVersion() >= 72);
ENAMEL_NAML_SANITY_CHECK
#endif /* ODS_EXTENDED */
if (IsCgiPlus)
{
for (;;)
{
/* block waiting for the next request */
CgiLibVar ("");
CgiPlusUsageCount++;
if (Debug) fputs ("Content-Type: text/plain\n\n", stdout);
ConanTheLibrarian ();
CgiLibCgiPlusEOF ();
}
}
else
ConanTheLibrarian ();
exit (SS$_NORMAL);
}
/*****************************************************************************/
/*
Get "command-line" parameters, whether from the command-line or from a
configuration symbol or logical containing the equivalent. OSU scripts have
the 'method', 'url' and 'protocol' supplied as P1, P2, P3 (these being detected
and used by CGILIB), and are of no interest to this function.
*/
GetParameters ()
{
static char CommandLine [256];
static unsigned long Flags = 0;
int status,
SkipParameters;
unsigned short Length;
char ch;
char *aptr, *cptr, *clptr, *sptr;
$DESCRIPTOR (CommandLineDsc, CommandLine);
/*********/
/* begin */
/*********/
if (!(clptr = getenv ("CONAN$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';
}
/* if [C]SWS (VMS Apache) */
if (CgiLibEnvironmentIsApache())
{
/* CSWS 1.2/3 look for something non-space outside of quotes */
for (cptr = clptr; *cptr; cptr++)
{
if (isspace(*cptr)) continue;
if (*cptr != '\"') break;
cptr++;
while (*cptr && *cptr != '\"') cptr++;
if (*cptr) cptr++;
}
/* CSWS 1.2/3 if nothing outside of quotes then ignore command line */
if (!*cptr) return;
/* SWS 2.0 doesn't begin with /APACHE from DCL procedure wrapper */
if (!strsame (cptr, "/APACHE", 7)) return;
}
/* if OSU environment then skip P1, P2, P3 */
if (CgiLibEnvironmentIsOsu())
SkipParameters = 3;
else
SkipParameters = 0;
aptr = NULL;
ch = *clptr;
for (;;)
{
if (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 (SkipParameters)
{
SkipParameters--;
continue;
}
if (strsame (aptr, "/APACHE", 4))
{
/* just skip this marker for command-line parameters under SWS 2.0 */
continue;
}
if (strsame (aptr, "/BUTTONS=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
if (*cptr == '+')
{
/* append buttons to defaults */
aptr = calloc (1, strlen(ButtonsPtr)+strlen(cptr)+2);
strcpy (aptr, ButtonsPtr);
strcat (aptr, "$");
strcat (aptr, cptr+1);
ButtonsPtr = aptr;
}
else
ButtonsPtr = cptr;
continue;
}
if (strsame (aptr, "/CHARSET=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliCharsetPtr = cptr;
continue;
}
if (strsame (aptr, "/DBUG", -1))
{
Debug = true;
continue;
}
if (strsame (aptr, "/ODS5", 5))
{
OdsExtended = true;
continue;
}
if (strsame (aptr, "/NOODS5", 7))
{
OdsExtended = false;
continue;
}
if (strsame (aptr, "/SINGLE", -1))
{
CliListSingle = true;
continue;
}
if (strsame (aptr, "/STYLE=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
StyleSheetPtr = cptr;
continue;
}
if (*aptr != '/')
{
fprintf (stdout, "%%%s-E-MAXPARM, too many parameters\n \\%s\\\n",
Utility, aptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
else
{
fprintf (stdout, "%%%s-E-IVQUAL, unrecognized qualifier\n \\%s\\\n",
Utility, aptr+1);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
}
}
/*****************************************************************************/
/*
*/
ButtonBar (int Top1Bottom2)
{
char *cptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ButtonBar() %d\n", Top1Bottom2);
fprintf (stdout, "<div class=\"buttonbar\">");
cptr = ButtonsPtr;
/* back */
cptr = ButtonBarButton (cptr, "");
/* close */
if (CgiFormRefererPtr[0])
cptr = ButtonBarButton (cptr, HtmlReferer);
else
cptr = ButtonBarButton (cptr, NULL);
/* further buttons (starting with "help") */
while (*cptr) cptr = ButtonBarButton (cptr, NULL);
fprintf (stdout, "</div>\n");
}
/*****************************************************************************/
/*
Generate a single "button" inside the context created by ButtonBar().
*/
char* ButtonBarButton
(
char *ButtonLabel,
char *ButtonPath
)
{
char *cptr, *sptr, *tptr, *uptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ButtonBarButton() |%s|\n", ButtonLabel);
if (!*ButtonLabel)
for (cptr = ButtonLabel = "*ERROR*"; *cptr; cptr++);
else
for (cptr = ButtonLabel; *cptr && *cptr != '=' && *cptr != '$'; cptr++);
if (*ButtonLabel == '^')
{
ButtonLabel++;
tptr = " target=\"_blank\"";
}
else
tptr = "";
if (*cptr == '=')
for (sptr = uptr = cptr+1; *sptr && *sptr != '$'; sptr++);
else
if (ButtonPath)
sptr = (uptr = ButtonPath) + strlen(ButtonPath);
else
sptr = (uptr = "*ERROR*") + 8;
if (!memcmp(uptr,"javascript:", 11))
fprintf (stdout,
"<script type=\"text/javascript\">\
document.write(\'<a%s href=\"%*.*s\">%*.*s</a>\\n\');\
</script>\n",
tptr, sptr-uptr, sptr-uptr, uptr,
cptr-ButtonLabel, cptr-ButtonLabel, ButtonLabel);
else
fprintf (stdout, "<a%s href=\"%*.*s\">%*.*s</a>\n",
tptr, sptr-uptr, sptr-uptr, uptr,
cptr-ButtonLabel, cptr-ButtonLabel, ButtonLabel);
while (*cptr && *cptr != '$') cptr++;
while (*cptr && *cptr == '$') cptr++;
return (cptr);
}
/*****************************************************************************/
/*
*/
ConanTheLibrarian ()
{
int idx, status;
unsigned long UnixTime;
char *cptr, *sptr;
struct tm *UnixTmPtr;
/*********/
/* begin */
/*********/
time (&UnixTime);
UnixTmPtr = localtime (&UnixTime);
if (!strftime (UnixDateTime, sizeof(UnixDateTime),
"%a, %d %b %Y %T", UnixTmPtr))
strcpy (UnixDateTime, "[error]");
if (Debug) fprintf (stdout, "UnixDateTime |%s|\n", UnixDateTime);
/* initialize anything specifically required for CGIplus */
DoHeaderInformation = DoListLibraries = DoLibraryMenu = DoSearch =
KeyNameWildcard = ExplodeHelp = ExtractHelp = ListSingle = false;
DoSearchStatistics = true;
for (idx = 0; idx < 11; idx++)
KeyWord[idx][0] = KeyWordHtml[idx][0] =
KeyName[idx][0] = KeyNameHtml[idx][0] = '\0';
CgiServerSoftwarePtr = CgiLibVar ("WWW_SERVER_SOFTWARE");
CgiRequestMethodPtr = CgiLibVar ("WWW_REQUEST_METHOD");
MethodGet = MethodHead = false;
if (!(MethodGet = (strcmp (CgiRequestMethodPtr, "GET") == 0)) &&
!(MethodHead = (strcmp (CgiRequestMethodPtr, "HEAD") == 0)))
{
CgiLibResponseHeader (501, "text/html");
fprintf (stdout, "Not implemented!\n");
return;
}
CgiPathInfoPtr = CgiLibVar ("WWW_PATH_INFO");
CgiPathTranslatedPtr = CgiLibVar ("WWW_PATH_TRANSLATED");
CgiScriptNamePtr = CgiLibVar ("WWW_SCRIPT_NAME");
CgiHttpPragmaPtr = CgiLibVar ("WWW_HTTP_PRAGMA");
CgiHttpCacheControlPtr = CgiLibVar ("WWW_HTTP_CACHE_CONTROL");
CgiHttpIfModifiedSincePtr = CgiLibVar ("WWW_HTTP_IF_MODIFIED_SINCE");
CgiFormDoPtr = CgiLibVar ("WWW_FORM_DO");
CgiFormExplodePtr = CgiLibVar ("WWW_FORM_EXPLODE");
CgiFormExtractPtr = CgiLibVar ("WWW_FORM_EXTRACT");
CgiFormSinglePtr = CgiLibVar ("WWW_FORM_SINGLE");
CgiFormKeyPtr = CgiLibVar ("WWW_FORM_KEY");
CgiFormTitlePtr = CgiLibVar ("WWW_FORM_TITLE");
CgiFormSearchPtr = CgiLibVar ("WWW_FORM_SEARCH");
if (!CgiFormSearchPtr[0])
CgiFormSearchPtr = CgiLibVar ("WWW_KEY_1");
CgiFormRefererPtr = CgiLibVar ("WWW_FORM_REFERER");
if (!CgiFormRefererPtr[0])
CgiFormRefererPtr = CgiLibVar ("WWW_HTTP_REFERER");
/* OWASP ZAP demonstrates unusual parameters can cause spits */
if (strlen (CgiPathInfoPtr) > 255 ||
strlen (CgiPathTranslatedPtr) > 255 ||
strlen (CgiFormKeyPtr) > 255 ||
strlen (CgiFormRefererPtr) > 255 ||
strlen (CgiFormSearchPtr) > 255 ||
strlen (CgiFormTitlePtr) > 255)
{
CgiLibResponseError (FI_LI, 0, "Parameter (significantly) out of range.");
return;
}
/* if a bit suspect (XSS) then give it the chop! (q&d) */
if (cptr = XSSuspect (CgiFormRefererPtr))
{
CgiLibResponseError (FI_LI, 0, cptr);
return;
}
if (CgiFormRefererPtr[0])
{
/* re-escape the URL-escaped percentages */
CgiLibUrlEncode (CgiFormRefererPtr, -1, UriReferer, sizeof(UriReferer));
CgiLibHtmlEscape (CgiFormRefererPtr, -1, HtmlReferer, sizeof(HtmlReferer));
}
else
UriReferer[0] = HtmlReferer[0] = '\0';
if (VMSnok (status = TimeSetGmt ()))
{
if (status != SS$_NOLOGNAM)
{
CgiLibResponseError (FI_LI, status, CgiScriptNamePtr);
exit (SS$_NORMAL);
}
}
if (CgiHttpIfModifiedSincePtr[0])
{
if (VMSnok (HttpGmTime (CgiHttpIfModifiedSincePtr,
&IfModifiedSinceBinaryTime)))
{
if (Debug) fprintf (stdout, "If-Modified-Since: NBG!\n");
IfModifiedSinceBinaryTime[0] = IfModifiedSinceBinaryTime[0] = 0;
CgiHttpIfModifiedSincePtr = "";
}
}
strcpy (LibraryPathInfo, CgiPathInfoPtr);
if (Debug) fprintf (stdout, "|%s|\n", LibraryPathInfo);
/**************/
/* initialize */
/**************/
idx = 0;
if (CgiFormKeyPtr[0])
{
/*****************************************/
/* get keywords from "key=" query string */
/*****************************************/
cptr = CgiFormKeyPtr;
while (*cptr)
{
if (idx <= 10) idx++;
if (*cptr == '~') cptr++;
sptr = KeyWord[idx];
while (*cptr && *cptr != '~') *sptr++ = *cptr++;
*sptr = '\0';
CgiLibHtmlEscape (KeyWord[idx], -1, KeyWordHtml[idx], -1);
if (Debug)
fprintf (stdout, "KeyWord[%d] (form) |%s|%s|\n",
idx, KeyWord[idx], KeyWordHtml[idx]);
}
}
else
if (!strstr (CgiPathTranslatedPtr, ".HLB") &&
!strstr (CgiPathTranslatedPtr, ".hlb") &&
!strstr (CgiPathTranslatedPtr, ".TLB") &&
!strstr (CgiPathTranslatedPtr, ".tlb") &&
!strchr (CgiPathTranslatedPtr, '*') &&
!strchr (CgiPathTranslatedPtr, '%'))
{
/*******************************/
/* get keywords from path info */
/*******************************/
/* make sure the default help library is used */
CgiPathTranslatedPtr = "";
idx = 0;
/* by comparing, scan past the script component of the path */
sptr = CgiScriptNamePtr;
cptr = CgiPathInfoPtr;
while (toupper(*cptr) == toupper(*sptr)) { cptr++; sptr++; }
while (*cptr)
{
if (idx <= 10) idx++;
if (*cptr == '/') cptr++;
sptr = KeyWord[idx];
if (*cptr == '_' || *cptr == '/')
{
/*
Some other HTML help systems use an underscore for qualifiers.
This implementation also allows two concurrent forward-slashes
so that the qualifier may be entered literally!
*/
*sptr++ = '/';
cptr++;
}
while (*cptr && *cptr != '/') *sptr++ = *cptr++;
*sptr = '\0';
CgiLibHtmlEscape (KeyWord[idx], -1, KeyWordHtml[idx], -1);
if (Debug)
fprintf (stdout, "KeyWord[%d] (path) |%s|%s|\n",
idx, KeyWord[idx], KeyWordHtml[idx]);
}
/* finished with the path if we've used it for keywords! */
CgiPathInfoPtr = "";
LibraryPathInfo[0] = '\0';
}
KeyWordCount = idx;
while (idx++ < 10) KeyWord[idx][0] = KeyWordHtml[idx][0] = '\0';
/* isolate the directory component of the path */
strcpy (LibraryDirPath, LibraryPathInfo);
for (cptr = LibraryDirPath; *cptr; cptr++);
if (cptr > LibraryDirPath) cptr--;
while (cptr > LibraryDirPath && *cptr != '/') cptr--;
if (*cptr == '/') cptr++;
*cptr = '\0';
if (Debug) fprintf (stdout, "|%s|\n", LibraryDirPath);
strcpy (LibrarySpec, CgiPathTranslatedPtr);
for (sptr = LibrarySpec; *sptr && *sptr != '*' && *sptr != '%'; sptr++);
if (*sptr) DoListLibraries = true;
switch (tolower(CgiFormDoPtr[0]))
{
case 'h' : DoHeaderInformation = true; break;
case 'l' : DoListLibraries = true; break;
case 'm' : DoLibraryMenu = true; break;
case 'o' : DoLibraryOpen = true; break;
case 's' : DoSearch = true; break;
default :
for (cptr = CgiPathTranslatedPtr; *cptr; cptr++)
if (*cptr == '*' || *cptr == '%') DoListLibraries = true;
}
if (CgiFormExplodePtr[0])
ExplodeHelp = true;
else
ExplodeHelp = false;
if (CgiFormExtractPtr[0])
ExtractHelp = true;
else
ExtractHelp = false;
if (CgiFormSinglePtr[0] || CliListSingle)
ListSingle = true;
else
ListSingle = false;
if (CgiFormSearchPtr[0])
{
DoSearch = true;
SearchStringLength = strlen(CgiFormSearchPtr);
CgiLibHtmlEscape (CgiFormSearchPtr, -1, HtmlSearchString, -1);
}
if (DoSearch && !CgiFormSearchPtr[0])
{
CgiLibResponseError (FI_LI, 0, "Search string not supplied.");
return;
}
if (!KeyWord[1][0])
{
/* no module keyname supplied, wildcard to list all modules */
strcpy (KeyWord[1], "*");
KeyNameWildcard = true;
}
else
{
/* check for a wildcard in the keyname, list all modules if there is */
for (sptr = KeyWord[1]; *sptr && *sptr != '*' && *sptr != '%'; sptr++);
if (*sptr) KeyNameWildcard = true;
}
LibraryTitle[0] = '\0';
if (!CgiPathTranslatedPtr[0]) CgiFormTitlePtr = "VMS Help";
if (CgiFormTitlePtr[0]) strcpy (LibraryTitle, CgiFormTitlePtr);
if (LibraryTitle[0])
CgiLibHtmlEscape (LibraryTitle, -1, HtmlLibraryTitle, -1);
else
{
sprintf (LibraryTitle, "Library %s", LibraryPathInfo);
CgiLibHtmlEscape (LibraryTitle, -1, HtmlLibraryTitle, -1);
}
if (Debug) fprintf (stdout, "LibraryTitle |%s|\n", LibraryTitle);
CgiLibUrlEncode (LibraryTitle, -1, UriFormTitle, -1);
CgiLibHtmlEscape (LibraryTitle, -1, HtmlFormTitle, -1);
/***********/
/* process */
/***********/
if (DoListLibraries)
ListLibraries ();
else
if (DoLibraryMenu)
LibraryMenu ();
else
if (DoLibraryOpen)
Librarian ();
else
Librarian ();
}
/****************************************************************************/
/*
Search for library files according to the the supplied specification (defaults
to help libraries; SYS$HELP:*.HLB). Display the name of each library in lower
case as a list item.
*/
ListLibraries ()
{
boolean SupportedLibraryType;
int len, status,
FileCount = 0;
char PrevFirstChar = '\0';
char *cptr, *sptr;
char ResFileName [ODS_MAX_FILE_NAME_LENGTH+1],
ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1],
String [2048],
UrlEncoded [ODS_MAX_FILE_NAME_LENGTH+64+1];
struct FAB FileFab;
#ifdef ODS_EXTENDED
struct NAML FileNaml;
#endif /* ODS_EXTENDED */
struct NAM FileNam;
if (Debug) fprintf (stdout, "ListLibraries() |%s|\n", LibrarySpec);
/* if no library specifcation provided then default to help libraries */
if (!LibrarySpec[0]) strcpy (LibrarySpec, "SYS$HELP:*.HLB;0");
if (Debug) fprintf (stdout, "|%s|\n", LibrarySpec);
FileFab = cc$rms_fab;
FileFab.fab$l_fop = FAB$V_NAM;
FileFab.fab$l_nam = &FileNam;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
FileFab.fab$l_fna = (char*)-1;
FileFab.fab$b_fns = 0;
FileFab.fab$l_nam = (struct namdef*)&FileNaml;
ENAMEL_RMS_NAML(FileNaml)
FileNaml.naml$l_long_filename = LibrarySpec;
FileNaml.naml$l_long_filename_size = strlen(LibrarySpec);
FileNaml.naml$l_long_expand = ExpFileName;
FileNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
FileNaml.naml$l_long_result = ResFileName;
FileNaml.naml$l_long_result_alloc = sizeof(ResFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
FileFab.fab$l_fna = LibrarySpec;
FileFab.fab$b_fns = strlen(LibrarySpec);
FileFab.fab$l_nam = &FileNam;
FileNam = cc$rms_nam;
FileNam.nam$l_esa = ExpFileName;
FileNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
FileNam.nam$l_rsa = ResFileName;
FileNam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
if (VMSnok (status = sys$parse (&FileFab, 0, 0)))
{
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
BeginPage (LibraryPathInfo, LibraryPathInfo);
fprintf (stdout, "<div class=\"results\">\n");
while (VMSok (status = sys$search (&FileFab, 0, 0)))
{
FileCount++;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
if (strsame(FileNaml.naml$l_long_type, ".DIR;", 5)) continue;
}
else
#endif /* ODS_EXTENDED */
if (strsame(FileNam.nam$l_type, ".DIR;", 5)) continue;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
cptr = FileNaml.naml$l_long_name;
if (strsame (FileNaml.naml$l_long_type, ".HLB;", 5) ||
strsame (FileNaml.naml$l_long_type, ".TLB;", 5))
SupportedLibraryType = true;
else
SupportedLibraryType = false;
}
else
#endif /* ODS_EXTENDED */
{
cptr = FileNam.nam$l_type;
if (strsame (FileNam.nam$l_type, ".HLB;", 5) ||
strsame (FileNam.nam$l_type, ".TLB;", 5))
SupportedLibraryType = true;
else
SupportedLibraryType = false;
}
if (!SupportedLibraryType) continue;
sptr = String;
if (PrevFirstChar && tolower(*cptr) != tolower(PrevFirstChar))
sptr += sprintf (sptr, "<p>");
PrevFirstChar = *cptr;
if (SupportedLibraryType)
{
#ifdef ODS_EXTENDED
if (OdsExtended)
{
CgiLibUrlEncode (LibraryDirPath, -1, UrlEncoded, -1);
sptr += sprintf (sptr, "<a href=\"%s%s",
CgiScriptNamePtr, UrlEncoded);
for (cptr = FileNaml.naml$l_long_name;
cptr < FileNaml.naml$l_long_ver;
*sptr++ = *cptr++);
}
else
#endif /* ODS_EXTENDED */
{
sptr += sprintf (sptr, "<a href=\"%s%s",
CgiScriptNamePtr, LibraryDirPath);
for (cptr = FileNam.nam$l_name;
cptr < FileNam.nam$l_ver;
*sptr++ = tolower(*cptr++));
}
sptr += sprintf (sptr, "?do=menu&title=%s&referer=%s\">",
UriFormTitle, UriReferer);
}
/* if there was wildcard in the file type then include it */
#ifdef ODS_EXTENDED
if (OdsExtended)
{
if (FileNaml.naml$l_fnb & NAM$M_WILD_TYPE)
for (cptr = FileNaml.naml$l_long_name;
cptr < FileNaml.naml$l_long_ver;
*sptr++ = tolower(*cptr++));
else
for (cptr = FileNaml.naml$l_long_name;
cptr < FileNaml.naml$l_long_type;
*sptr++ = tolower(*cptr++));
}
else
#endif /* ODS_EXTENDED */
{
if (FileNam.nam$l_fnb & NAM$M_WILD_TYPE)
for (cptr = FileNam.nam$l_name;
cptr < FileNam.nam$l_ver;
*sptr++ = tolower(*cptr++));
else
for (cptr = FileNam.nam$l_name;
cptr < FileNam.nam$l_type;
*sptr++ = tolower(*cptr++));
}
if (SupportedLibraryType) sptr += sprintf (sptr, "</a>");
*sptr++ = '\n';
*sptr = '\0';
fputs (String, stdout);
}
if (!FileCount) fprintf (stdout, "<p>No files found.\n");
if (status == RMS$_FNF || status == RMS$_NMF) status = SS$_NORMAL;
if (VMSnok (status))
{
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
fprintf (stdout, "</div>\n</div>\n");
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
return (status);
}
/*****************************************************************************/
/*
For the specified library file provide a menu of four services; librarian,
searching, library header and help.
*/
LibraryMenu ()
{
char *cptr, *sptr;
char UrlEncoded [ODS_MAX_FILE_NAME_LENGTH+64+1];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "LibraryMenu() |%s|\n", LibrarySpec);
strcpy (LibraryTitle, LibraryPathInfo);
CgiLibHtmlEscape (LibraryPathInfo, -1, HtmlLibraryTitle, -1);
CgiLibUrlEncode (LibraryTitle, -1, UriFormTitle, -1);
CgiLibHtmlEscape (LibraryTitle, -1, HtmlFormTitle, -1);
BeginPage (LibraryTitle, HtmlLibraryTitle);
CgiLibUrlEncode (LibraryPathInfo, -1, UrlEncoded, -1);
fprintf (stdout,
"<div class=\"results\">\n\
<p><a href=\"%s%s?title=%s&referer=%s\">Open Library</a>\n\
<p><a href=\"%s%s?do=header&title=%s&referer=%s\">Library Header</a>\n\
<div class=\"searchform\">\n\
<form action=\"%s%s\">\n\
<input type=\"hidden\" name=\"referer\" value=\"%s\">\n\
<input type=\"hidden\" name=\"title\" value=\"%s\">\n\
<input type=\"hidden\" name=\"do\" value=\"search\">\n\
<input type=\"submit\" value=\"Search for: \">\n\
<input type=\"text\" name=\"Search\">\n\
<input type=\"reset\" value=\"Reset\">\n\
</form>\n\
</div>\n\
</div>\n",
CgiScriptNamePtr, UrlEncoded, UriFormTitle, UriReferer,
CgiScriptNamePtr, UrlEncoded, UriFormTitle, UriReferer,
CgiScriptNamePtr, UrlEncoded,
HtmlReferer, HtmlFormTitle);
fprintf (stdout, "</div>\n</div>\n");
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
}
/*****************************************************************************/
/*
Initialise library control. Open the library specified by LibrarySpec. Get
header information from the library so its internal format can be determined
(help or text, other are not supported). Call ProcessLibrary() to perform the
requested access according to the library type.
*/
Librarian ()
{
int status;
unsigned long Function = LBR$C_READ,
FileNameLength;
char *cptr;
char String [1024];
$DESCRIPTOR (LibrarySpecDsc, "");
static struct dsc$descriptor_s
LibraryDefDsc = { sizeof(DEFAULT_LIBRARY)-1, DSC$K_DTYPE_T,
DSC$K_CLASS_S, DEFAULT_LIBRARY },
LibraryFileNameDsc = { sizeof(LibraryFileName)-1, DSC$K_DTYPE_T,
DSC$K_CLASS_S, LibraryFileName };
/****************************************/
/* initialize, open library, get header */
/****************************************/
if (Debug) fprintf (stdout, "Librarian()\n");
if (VMSnok (status = lbr$ini_control (&LibraryIndex, &Function, 0, 0)))
{
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
LibrarySpecDsc.dsc$w_length = strlen(LibrarySpec);
LibrarySpecDsc.dsc$a_pointer = LibrarySpec;
if (VMSnok (status = lbr$open (&LibraryIndex,
&LibrarySpecDsc,
0,
&LibraryDefDsc,
0,
&LibraryFileNameDsc,
&FileNameLength)))
{
if (Debug) fprintf (stdout, "lib$open() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
/* terminate, removing the trailing version number */
LibraryFileName[FileNameLength] = '\0';
for (cptr = LibraryFileName; *cptr && *cptr != ';'; cptr++);
*cptr = '\0';
if (Debug) fprintf (stdout, "LibraryFileName |%s|\n", LibraryFileName);
if (VMSnok (status = lbr$get_header (&LibraryIndex, &LibraryHeader)))
{
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
if (CgiHttpIfModifiedSincePtr[0])
{
if (VMSnok (ModifiedSince (&IfModifiedSinceBinaryTime,
&LibraryHeader.lhi$l_updtim)))
{
/* library has not been modified since the date/time, don't send */
status = lbr$close (&LibraryIndex);
return (SS$_NORMAL);
}
}
HttpGmTimeString (LastModifiedGmDateTime, &LibraryHeader.lhi$l_updtim);
/*******************/
/* process library */
/*******************/
if (DoHeaderInformation)
HeaderInformation ();
else
if (LibraryHeader.lhi$l_type == LBR$C_TYP_TXT)
{
if (DoSearch)
SearchTextLibraryModules ();
else
if (KeyNameWildcard)
ListTextLibraryModules ();
else
OpenTextLibraryModule ();
}
else
if (LibraryHeader.lhi$l_type == LBR$C_TYP_HLP)
{
if (DoSearch)
SearchHelpLibraryModules ();
else
if (KeyNameWildcard)
ListHelpLibraryModules ();
else
OpenHelpLibraryModule ();
}
else
{
sprintf (String,
"Library type %d not supported. (Only HELP and TEXT libraries are valid)",
LibraryHeader.lhi$l_type);
CgiLibResponseError (FI_LI, 0, String);
return (SS$_NORMAL);
}
status = lbr$close (&LibraryIndex);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Provide selected library header information.
*/
HeaderInformation ()
{
static char *LibraryTypes[] =
{ "Unknown", "VAX Object", "Macro", "Help", "Text",
"VAX Sharable Image", "NCS",
"Alpha Object", "Alpha Sharable Image", "?" };
static $DESCRIPTOR (CreatedFaoDsc,
"<tr><th>Created:</th><td>!%D</td></tr>\n");
static $DESCRIPTOR (RevisedFaoDsc,
"<tr><th>Revised:</th><td>!%D</td></tr>\n");
unsigned short slen;
char String [1024];
$DESCRIPTOR (StringDsc, String);
/*********/
/* begin */
/*********/
BeginPage (LibraryTitle, LibraryTitle);
fprintf (stdout,
"<div class=\"results\">\n\
<table class=\"tabhead\" border=\"0\" cellpadding=\"3\" cellspacing=\"0\">\n");
if (LibraryHeader.lhi$l_type > 8) LibraryHeader.lhi$l_type = 9;
fprintf (stdout, "<tr><th align=\"right\">Type:</th><td>%s</td></tr>\n",
LibraryTypes[LibraryHeader.lhi$l_type]);
fprintf (stdout, "<tr><th align=\"right\">Creator:</th><td>%-*s</td></tr>\n",
*(char*)LibraryHeader.lhi$t_lbrver,
(char*)LibraryHeader.lhi$t_lbrver+1);
fprintf (stdout, "<tr><th align=\"right\">Format:</th><td>%d.%d</td></tr>\n",
LibraryHeader.lhi$l_majorid, LibraryHeader.lhi$l_minorid);
sys$fao (&CreatedFaoDsc, &slen, &StringDsc, &LibraryHeader.lhi$l_credat);
String[slen] = '\0';
fprintf (stdout, "%s", String);
sys$fao (&RevisedFaoDsc, &slen, &StringDsc, &LibraryHeader.lhi$l_updtim);
String[slen] = '\0';
fprintf (stdout, "%s", String);
if (LibraryHeader.lhi$l_libstatus)
fprintf (stdout,
"<tr><th align=\"right\">Status:</th><td>OK</td></tr>\n");
else
fprintf (stdout,
"<tr><th align=\"right\">Status:</th>\
<td><span style=\"color:red;\">PROBLEM</span></td></tr>\n");
fprintf (stdout, "</table>\n");
fprintf (stdout, "</div>\n</div>\n");
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
}
/*****************************************************************************/
/*
*/
struct dsc$descriptor_s* KeyNameDsc ()
{
static char Key [256];
static $DESCRIPTOR (KeyDsc, Key);
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "KeyNameDsc()\n");
/* although spaces *look* better, in fact underscores */
zptr = (sptr = Key) + sizeof(Key)-1;
for (cptr = KeyWord[1]; *cptr && sptr < zptr; cptr++)
{
if (*cptr == ' ')
*sptr++ = '_';
else
*sptr++ = toupper(*cptr);
}
*sptr = '\0';
KeyDsc.dsc$w_length = sptr - Key;
if (Debug) fprintf (stdout, "|%s|\n", Key);
return (&KeyDsc);
}
/*****************************************************************************/
/*
*/
int ListHelpLibraryModules ()
{
int status;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ListHelpLibraryModules()\n");
BeginPage (LibraryTitle, HtmlLibraryTitle);
fprintf (stdout,
"<div class=\"searchform\">\n\
<form action=\"%s%s\">\n\
<input type=\"hidden\" name=\"referer\" value=\"%s\">\n\
<input type=\"hidden\" name=\"title\" value=\"%s\">\n\
<input type=\"hidden\" name=\"do\" value=\"search\">\n\
<input type=\"submit\" value=\"Search for: \">\n\
<input type=\"text\" name=\"Search\">\n\
<input type=\"reset\" value=\"Reset\">\n\
</form>\n\
</div>\n\
<div class=\"helpmodules\">\n",
CgiScriptNamePtr, CgiPathInfoPtr,
HtmlReferer, HtmlFormTitle);
fflush (stdout);
IndexNumber = 1;
if (VMSnok (status = lbr$get_index (&LibraryIndex,
&IndexNumber,
&ListHelpModule,
KeyNameDsc())))
{
if (Debug) fprintf (stdout, "lib$get_index() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
fprintf (stdout, "\n");
fprintf (stdout, "</div>\n</div>\n");
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
}
/*****************************************************************************/
/*
*/
int ListHelpModule
(
struct dsc$descriptor_s *KeyNameDscPtr,
void *RFAptr
)
{
static char PrevAlpha = 0,
PrevChar = 0xff;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ListHelpModule()\n");
strncpy (KeyWord[1],
KeyNameDscPtr->dsc$a_pointer,
KeyNameDscPtr->dsc$w_length);
KeyWord[1][KeyNameDscPtr->dsc$w_length] = '\0';
strcpy (KeyName[1], KeyWord[1]);
CgiLibHtmlEscape (KeyWord[1], -1, KeyNameHtml[1], -1);
if (Debug) fprintf (stdout, "KeyNameDsc |%s|\n", KeyWord[1]);
if (ListSingle)
{
if ((unsigned char)KeyName[1][0] >= (unsigned char)PrevChar)
fprintf (stdout, "\n<li>");
else
fprintf (stdout, "<li>");
}
else
if (!isalpha(KeyName[1][0]) ||
toupper(KeyName[1][0]) == PrevAlpha)
{
if ((unsigned char)KeyName[1][0] >= (unsigned char)PrevChar)
fprintf (stdout, "\n");
}
else
{
if ((unsigned char)KeyName[1][0] >= (unsigned char)PrevChar)
fprintf (stdout, "\n<p>");
PrevAlpha = toupper(KeyName[1][0]);
}
fprintf (stdout, "<a href=\"%s%s?key=%s&title=%s&referer=%s\">%s</a>\n",
CgiScriptNamePtr, LibraryPathInfo,
FormatRequestKeys(true,1),
UriFormTitle, UriReferer,
MungeUnderScores(KeyNameHtml[1]));
PrevChar = KeyName[1][0];
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
*/
int OpenHelpLibraryModule ()
{
int status;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "OpenHelpLibraryModule()\n");
IndexNumber = 1;
if (ExtractHelp)
{
status = lbr$get_index (&LibraryIndex, &IndexNumber,
&ExtractHelpModule, KeyNameDsc());
if (VMSnok (status))
{
if (Debug) fprintf (stdout, "lib$get_index() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
}
return (SS$_NORMAL);
}
status = lbr$get_index (&LibraryIndex, &IndexNumber,
&OpenHelpModule, KeyNameDsc());
if (VMSnok (status))
{
if (Debug) fprintf (stdout, "lib$get_index() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
fprintf (stdout, "</div>\n");
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
This is a reasonably complex function, and reflects the complexities internal
to help library modules!
*/
int OpenHelpModule
(
struct dsc$descriptor_s *KeyNameDscPtr,
void *RFAptr
)
{
static int MatchedCount = 0,
PreviousCgiPlusUsageCount = 0;
boolean AdditionalInformation = true,
ExplodedHeading = false,
OutputModuleTitle = true;
int status,
AdditionalInformationCount = 0,
BlankLineCount = 0,
Count,
ExplodeLevel = 0,
HelpLevel = 0,
Length,
MatchedLevel = 0,
MatchesToLevel = 0,
PreviousHelpLevel = 0,
TextLineCount = 0;
int KeyCount [11];
char PrevFirstBufferChar = '\0';
char *cptr, *sptr;
char Buffer [1024],
PrevAdditionalChar [2] = "\0\0",
String [1024];
$DESCRIPTOR (InBufferDsc, Buffer);
$DESCRIPTOR (OutBufferDsc, Buffer);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "OpenHelpModule()\n");
if (CgiPlusUsageCount != PreviousCgiPlusUsageCount)
{
MatchedCount = 0;
PreviousCgiPlusUsageCount = CgiPlusUsageCount;
}
strncpy (KeyName[1],
KeyNameDscPtr->dsc$a_pointer,
KeyNameDscPtr->dsc$w_length);
KeyName[1][KeyNameDscPtr->dsc$w_length] = '\0';
if (Debug) fprintf (stdout, "KeyNameDsc |%s|\n", KeyName[1]);
CgiLibHtmlEscape (KeyName[1], -1, KeyWordHtml[1], -1);
if (!KeyWordCount)
{
strcpy (KeyWord[1], KeyName[1]);
KeyWordCount = 1;
}
if (ExplodeHelp)
for (Count = 0; Count < 11; KeyCount[Count++] = 0);
if (VMSnok (status = lbr$lookup_key (&LibraryIndex,
KeyNameDscPtr,
&ModuleRFA)))
{
if (Debug) fprintf (stdout, "lib$lookup_key() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
/**************************************/
/* loop through all records in module */
/**************************************/
for (;;)
{
status = lbr$get_record (&LibraryIndex,
&InBufferDsc,
&OutBufferDsc);
if (Debug) fprintf (stdout, "lbr$get_record() %%X%08.08X\n", status);
if (VMSnok (status)) break;
/* terminate output buffer, removing any trailing white space */
cptr = Buffer+OutBufferDsc.dsc$w_length-1;
while (cptr >= Buffer && isspace(*cptr)) cptr--;
*++cptr = '\0';
/* comment record (line) in module */
if (Buffer[0] == '!') continue;
if (Debug) fprintf (stdout, "Buffer |%s|\n", Buffer);
/*
30-DEC-2008 OTS Bug? (V7.3-1 and V8.3 at least)
Use of isdigit() of copyright char 0xa9 resulted in ACCVIO
LIBOTS 0 00000000000217B0 FFFFFFFF809117B0
DECC$SHR_EV56 0 00000000000CD0E4 FFFFFFFF80B650E4
DECC$SHR_EV56 0 000000000014504C FFFFFFFF80BDD04C
DECC$SHR_EV56 0 0000000000144FAC FFFFFFFF80BDCFAC
Explicit test of digit range worked around issue.
*/
if ((Buffer[0] >= '0' && Buffer[0] <= '9' && Buffer[1] == ' ') ||
Buffer[0] == '/')
{
/***************************/
/* help level or qualifier */
/***************************/
PreviousHelpLevel = HelpLevel;
if (Buffer[0] == '/')
{
/* if no previous qualifier encountered at this help level */
/* then the qualifier effectively creates a new help level */
if (PrevFirstBufferChar != '/') HelpLevel++;
cptr = Buffer;
for (sptr = cptr; *sptr && !isspace(*sptr); sptr++);
}
else
{
/* help level topic (line begins with a digit then a space) */
HelpLevel = Buffer[0] - '0';
for (cptr = Buffer + 1; isspace(*cptr); cptr++);
for (sptr = cptr; *sptr && !isspace(*sptr); sptr++);
}
strncpy (KeyName[HelpLevel], cptr, sptr-cptr);
KeyName[HelpLevel][sptr-cptr] = '\0';
CgiLibHtmlEscape (cptr, -1, KeyNameHtml[HelpLevel], -1);
PrevFirstBufferChar = Buffer[0];
if (MatchesToLevel >= HelpLevel)
{
/* if the topic's been matched and output, finish up */
if (MatchedLevel) break;
MatchesToLevel = ExplodeLevel = 0;
for (Count = 1; Count <= HelpLevel; Count++)
{
if (strsame (KeyWord[Count], KeyName[Count], -1))
MatchesToLevel = Count;
else
break;
}
}
else
{
for (Count = MatchesToLevel + 1; Count <= HelpLevel; Count++)
{
if (strsame (KeyWord[Count], KeyName[Count], -1))
MatchesToLevel = Count;
else
break;
}
}
if (MatchesToLevel == KeyWordCount && MatchesToLevel == HelpLevel)
{
/****************/
/* module title */
/****************/
MatchedCount++;
sptr = String;
sptr += sprintf (sptr, "%s", LibraryTitle);
for (Count = 1; Count <= HelpLevel; Count++)
{
if (Count > 1)
for (cptr = KeyNameHtml[Count-1];
*cptr && *cptr != '_' && *cptr != ' ';
cptr++);
if (Count > 1 && *cptr)
sptr += sprintf (sptr, ", %s",
MungeUnderScores(KeyNameHtml[Count]));
else
if (Count > 1)
sptr += sprintf (sptr, "  %s",
MungeUnderScores(KeyNameHtml[Count]));
else
sptr += sprintf (sptr, " — %s",
MungeUnderScores(KeyNameHtml[Count]));
}
BeginPage (LibraryTitle, String);
if (ExplodeHelp)
{
ExplodedHeading = true;
ExplodeLevel = HelpLevel + 1;
}
MatchedLevel = HelpLevel;
}
else
if (ExplodeLevel && HelpLevel >= ExplodeLevel)
{
/******************/
/* exploding help */
/******************/
if (TextLineCount)
if (PreviousHelpLevel == ExplodeLevel - 1)
fprintf (stdout, "</pre>\n<p>");
else
fprintf (stdout, "</pre>\n");
TextLineCount = 0;
ExplodedHeading = true;
for (Count = HelpLevel+1; Count < 11; KeyCount[Count++] = 0);
KeyCount[HelpLevel]++;
fprintf (stdout, "<p><span class=\"explevel%s\">",
ExplodeLevel == HelpLevel ? "1" : "");
for (Count = ExplodeLevel; Count <= HelpLevel; Count++)
if (Count < HelpLevel)
fprintf (stdout, "%d.", KeyCount[Count]);
else
fprintf (stdout, "%d", KeyCount[Count]);
if (KeyNameHtml[HelpLevel][0] == '/')
fprintf (stdout, " %s</span>\n",
MungeUnderScores(KeyNameHtml[HelpLevel]));
else
fprintf (stdout, " – %s</span>\n",
MungeUnderScores(KeyNameHtml[HelpLevel]));
}
else
if (MatchesToLevel == KeyWordCount && HelpLevel == KeyWordCount+1)
{
/*************/
/* subtopics */
/*************/
if (AdditionalInformation)
{
if (TextLineCount) fprintf (stdout, "</pre>\n");
if (HelpLevel == 2)
{
fprintf (stdout,
"<div class=\"searchform\">\n\
<form action=\"%s%s\">\n\
<input type=\"hidden\" name=\"referer\" value=\"%s\">\n\
<input type=\"hidden\" name=\"title\" value=\"%s\">\n\
<input type=\"hidden\" name=\"do\" value=\"search\">\n\
<input type=\"hidden\" name=\"key\" value=\"%s\">\n\
<input type=\"submit\" value=\"Search "%s" for: \">\n\
<input type=\"text\" name=\"Search\">\n\
<input type=\"reset\" value=\"Reset\">\n\
</form>\n\
</div>\n",
CgiScriptNamePtr, CgiPathInfoPtr,
HtmlReferer, HtmlFormTitle,
FormatRequestKeys(false,HelpLevel-1),
KeyWordHtml[1]);
}
fprintf (stdout,
"<b>Additional Information:</b>\n\
<span class=\"explode\">\n\
<a href=\"%s%s?key=%s&explode=yes&title=%s&referer=%s\">explode</a>\n\
<a href=\"%s%s?key=%s&extract=yes\">extract</a>\n\
</span>\n\
<div class=\"addinfo\">\n",
CgiScriptNamePtr, LibraryPathInfo,
FormatRequestKeys(true,HelpLevel-1),
UriFormTitle, UriReferer,
CgiScriptNamePtr, LibraryPathInfo,
FormatRequestKeys(true,HelpLevel-1));
AdditionalInformation = false;
}
else
{
if (TextLineCount) fprintf (stdout, "</pre>\n");
}
if (PrevAdditionalChar[0] ||
!isalpha(KeyNameHtml[HelpLevel][0]) ||
islower(KeyNameHtml[HelpLevel][0]))
{
if (isalpha(KeyNameHtml[HelpLevel][0]))
{
if (!isalpha(PrevAdditionalChar[0]) ||
(isalpha(PrevAdditionalChar[0]) &&
KeyNameHtml[HelpLevel][0] != PrevAdditionalChar[0]))
fprintf (stdout, "<br>");
}
else
{
if (isalpha(PrevAdditionalChar[0]) ||
KeyNameHtml[HelpLevel][1] != PrevAdditionalChar[1])
fprintf (stdout, "<br>");
}
}
if (PrevAdditionalChar[0] ||
!isalpha(KeyNameHtml[HelpLevel][0]) ||
islower(KeyNameHtml[HelpLevel][0]))
{
PrevAdditionalChar[0] = KeyNameHtml[HelpLevel][0];
PrevAdditionalChar[1] = KeyNameHtml[HelpLevel][1];
}
fprintf (stdout,
"<a href=\"%s%s?key=%s&title=%s&referer=%s\">%s</a>\n",
CgiScriptNamePtr, LibraryPathInfo,
FormatRequestKeys(true,HelpLevel),
UriFormTitle, UriReferer,
MungeUnderScores(KeyNameHtml[HelpLevel]));
AdditionalInformationCount++;
TextLineCount = 0;
}
}
else
{
/*************/
/* help text */
/*************/
if ((ExplodeLevel && HelpLevel >= ExplodeLevel) ||
(MatchesToLevel == KeyWordCount && HelpLevel == KeyWordCount))
{
/* check to see if this module record has any non-space chars */
for (cptr = Buffer;
*cptr && (*cptr == ' ' || *cptr == '\t');
cptr++);
/* ignore special directive for DECwindows on-line help */
if (*cptr && *cptr != '=')
{
if (!TextLineCount) fprintf (stdout, "<pre class=\"module\">");
sptr = String;
if (ExplodedHeading)
{
ExplodedHeading = false;
BlankLineCount = 0;
}
if (BlankLineCount && TextLineCount) *sptr++ = '\n';
if (BlankLineCount) BlankLineCount = 0;
*sptr++ = ' ';
cptr = Buffer;
while (*cptr) *sptr++ = *cptr++;
*sptr++ = '\n';
*sptr = '\0';
HtmlOutputString (String, true);
TextLineCount++;
}
else
if (!*cptr)
BlankLineCount++;
}
}
}
if (AdditionalInformationCount)
{
ListOtherHelp ();
fprintf (stdout, "</div>\n");
}
else
if (TextLineCount)
fprintf (stdout, "</pre>\n");
else
if (!MatchedCount)
return (0x00268838);
return (SS$_NORMAL);
}
/****************************************************************************/
/*
Search for library files with names containing the first keyword. The idea is
that an in-program help file might exist for additional information, so for the
example of TELNET this function searches for SYS$COMMON:[SYSHLP]*TELNET*.HLB
and lists any matching. Help topic HELP lists all those
SYS$COMMON:[SYSHLP]*HELP*.HLB :-)
*/
ListOtherHelp ()
{
int len, status,
FileCount = 0;
char *cptr, *sptr, *zptr;
char HelpSpec [ODS_MAX_FILE_NAME_LENGTH+1],
ResFileName [ODS_MAX_FILE_NAME_LENGTH+1],
ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1],
SimplePath [ODS_MAX_FILE_NAME_LENGTH+1],
String [2048],
UrlEncoded [ODS_MAX_FILE_NAME_LENGTH+64+1];
struct FAB FileFab;
#ifdef ODS_EXTENDED
struct NAML FileNaml;
#endif /* ODS_EXTENDED */
struct NAM FileNam;
if (Debug) fprintf (stdout, "ListOtherHelp() |%s|\n", LibraryFileName);
sptr = HelpSpec;
for (cptr = LibraryFileName;
*cptr && *(cptr-1) != ']' && *(cptr-2) != '^' && *(cptr-2) != '.';
*sptr++ = *cptr++);
*sptr++ = '*';
for (cptr = KeyWord[1]; *cptr; *sptr++ = *cptr++);
for (cptr = "*.HLB"; *cptr; *sptr++ = *cptr++);
*sptr++ = '\0';
if (Debug) fprintf (stdout, "|%s|\n", HelpSpec);
FileFab = cc$rms_fab;
FileFab.fab$l_fop = FAB$V_NAM;
FileFab.fab$l_nam = &FileNam;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
FileFab.fab$l_fna = (char*)-1;
FileFab.fab$b_fns = 0;
FileFab.fab$l_nam = (struct namdef*)&FileNaml;
ENAMEL_RMS_NAML(FileNaml)
FileNaml.naml$l_long_filename = HelpSpec;
FileNaml.naml$l_long_filename_size = sptr - HelpSpec;
FileNaml.naml$l_long_expand = ExpFileName;
FileNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
FileNaml.naml$l_long_result = ResFileName;
FileNaml.naml$l_long_result_alloc = sizeof(ResFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
FileFab.fab$l_fna = HelpSpec;
FileFab.fab$b_fns = sptr - HelpSpec;
FileFab.fab$l_nam = &FileNam;
FileNam = cc$rms_nam;
FileNam.nam$l_esa = ExpFileName;
FileNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
FileNam.nam$l_rsa = ResFileName;
FileNam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
if (VMSnok (status = sys$parse (&FileFab, 0, 0))) return (SS$_NORMAL);
while (VMSok (status = sys$search (&FileFab, 0, 0)))
{
#ifdef ODS_EXTENDED
if (OdsExtended)
{
cptr = FileNaml.naml$l_long_dev;
zptr = FileNaml.naml$l_long_ver;
}
else
#endif /* ODS_EXTENDED */
{
cptr = FileNam.nam$l_dev;
zptr = FileNam.nam$l_ver;
}
/* q&d conversion to URL format */
sptr = SimplePath;
while (cptr < zptr)
{
if (*cptr == ':' && *(cptr+1) == '[')
{
*sptr++ = '/';
cptr += 2;
}
else
if (*cptr == '.' && *(cptr+1) == ']' && *(cptr+1) == '[')
{
*sptr++ = '/';
cptr += 3;
}
else
if (*cptr == ']')
{
*sptr++ = '/';
cptr++;
}
else
*sptr++ = tolower(*cptr++);
}
*sptr = '\0';
CgiLibUrlEncode (SimplePath, -1, UrlEncoded, -1);
sptr = String;
if (!FileCount++) sptr += sprintf (sptr, "<p>");
sptr += sprintf (sptr, "<a href=\"%s/%s?do=open&referer=%s&title=",
CgiScriptNamePtr, UrlEncoded, UriReferer);
#ifdef ODS_EXTENDED
if (OdsExtended)
{
for (cptr = FileNaml.naml$l_long_name;
cptr < FileNaml.naml$l_long_ver;
*sptr++ = *cptr++);
sptr += sprintf (sptr, "\">");
for (cptr = FileNaml.naml$l_long_name;
cptr < FileNaml.naml$l_long_ver;
*sptr++ =*cptr++);
}
else
#endif /* ODS_EXTENDED */
{
for (cptr = FileNam.nam$l_name;
cptr < FileNam.nam$l_ver;
*sptr++ = *cptr++);
sptr += sprintf (sptr, "\">");
for (cptr = FileNam.nam$l_name;
cptr < FileNam.nam$l_ver;
*sptr++ = *cptr++);
}
sptr += sprintf (sptr, "</a>\n");
fputs (String, stdout);
}
if (status == RMS$_FNF || status == RMS$_NMF) status = SS$_NORMAL;
return (status);
}
/*****************************************************************************/
/*
Just suck the brains out of the module as a plain-text document.
*/
int ExtractHelpModule
(
struct dsc$descriptor_s *KeyNameDscPtr,
void *RFAptr
)
{
int status;
char Buffer [1024];
$DESCRIPTOR (InBufferDsc, Buffer);
$DESCRIPTOR (OutBufferDsc, Buffer);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ExtractHelpModule()\n");
if (VMSnok (status = lbr$lookup_key (&LibraryIndex,
KeyNameDscPtr,
&ModuleRFA)))
{
if (Debug) fprintf (stdout, "lib$lookup_key() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
/**************************************/
/* loop through all records in module */
/**************************************/
CgiLibResponseHeader (200, "text/plain",
"Last-Modified: %s\n", LastModifiedGmDateTime);
if (MethodHead) return (SS$_NORMAL);
for (;;)
{
status = lbr$get_record (&LibraryIndex,
&InBufferDsc,
&OutBufferDsc);
if (Debug) fprintf (stdout, "lbr$get_record() %%X%08.08X\n", status);
if (VMSnok (status)) break;
Buffer[OutBufferDsc.dsc$w_length] = '\n';
Buffer[OutBufferDsc.dsc$w_length+1] = '\0';
fputs (Buffer, stdout);
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
*/
int SearchHelpLibraryModules ()
{
int status;
char *cptr, *sptr;
char String [1024];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SearchHelpLibraryModules()\n");
sprintf (String, "Search "%s" for "%s"",
HtmlLibraryTitle, HtmlSearchString);
BeginPage (String, String);
fprintf (stdout, "<div class=\"results\">\n");
RecordsSearched = SearchHitCount = 0;
IndexNumber = 1;
if (DoSearchStatistics) lib$init_timer (0);
if (VMSnok (status = lbr$get_index (&LibraryIndex,
&IndexNumber,
&SearchHelpModule,
KeyNameDsc())))
{
if (Debug) fprintf (stdout, "lib$get_index() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
if (!SearchHitCount) fprintf (stdout, "<b>Not found!</b>\n<p>");
if (DoSearchStatistics) SearchStatistics ();
fprintf (stdout, "</div>\n</div>\n");
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
}
/*****************************************************************************/
/*
This is a reasonably complex function, and reflects the complexities internal
to help library modules!
*/
int SearchHelpModule
(
struct dsc$descriptor_s *KeyNameDscPtr,
void *RFAptr
)
{
static boolean HitThisTopic = false;
static char PrevFirstBufferChar = '\0';
int status,
Count,
HelpLevel = 0,
Length;
char ch;
char *cptr, *hptr, *sptr;
char Buffer [1024],
String [8192];
$DESCRIPTOR (InBufferDsc, Buffer);
$DESCRIPTOR (OutBufferDsc, Buffer);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SearchHelpModule()\n");
strncpy (KeyWord[1],
KeyNameDscPtr->dsc$a_pointer,
KeyNameDscPtr->dsc$w_length);
KeyWord[1][KeyNameDscPtr->dsc$w_length] = '\0';
strcpy (KeyName[1], KeyWord[1]);
CgiLibHtmlEscape (KeyWord[1], -1, KeyWordHtml[1], -1);
if (!KeyWordCount) KeyWordCount = 1;
if (Debug) fprintf (stdout, "KeyNameDsc |%s|\n", KeyWord[1]);
if (VMSnok (status = lbr$lookup_key (&LibraryIndex,
KeyNameDscPtr,
&ModuleRFA)))
{
if (Debug) fprintf (stdout, "lib$lookup_key() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
/**************************************/
/* loop through all records in module */
/**************************************/
for (;;)
{
status = lbr$get_record (&LibraryIndex,
&InBufferDsc,
&OutBufferDsc);
if (Debug) fprintf (stdout, "lbr$get_record() %%X%08.08X\n", status);
if (VMSnok (status)) break;
/* terminate output buffer, removing any trailing white space */
cptr = Buffer+OutBufferDsc.dsc$w_length-1;
while (cptr >= Buffer && isspace(*cptr)) cptr--;
*++cptr = '\0';
/* comment record (line) in module */
if (Buffer[0] == '!') continue;
if (Debug) fprintf (stdout, "Buffer |%s|\n", Buffer);
/*
30-DEC-2008 OTS Bug? (V7.3-1 and V8.3 at least)
Use of isdigit() of copyright char 0xa9 resulted in ACCVIO
LIBOTS 0 00000000000217B0 FFFFFFFF809117B0
DECC$SHR_EV56 0 00000000000CD0E4 FFFFFFFF80B650E4
DECC$SHR_EV56 0 000000000014504C FFFFFFFF80BDD04C
DECC$SHR_EV56 0 0000000000144FAC FFFFFFFF80BDCFAC
Explicit test of digit range worked around issue.
*/
if ((Buffer[0] >= '0' && Buffer[0] <= '9' && Buffer[1] == ' ') ||
Buffer[0] == '/')
{
/***************************/
/* help level or qualifier */
/***************************/
if (Buffer[0] == '/')
{
/* if no previous qualifier encountered at this help level */
/* then the qualifier effectively creates a new help level */
if (PrevFirstBufferChar != '/') HelpLevel++;
cptr = Buffer;
}
else
{
/* help level topic (line begins with a digit then a space) */
HelpLevel = Buffer[0] - '0';
for (cptr = Buffer + 1; isspace(*cptr); cptr++);
}
PrevFirstBufferChar = Buffer[0];
strcpy (KeyName[HelpLevel], cptr);
CgiLibHtmlEscape (cptr, -1, KeyNameHtml[HelpLevel], -1);
/* if previous topic had a hit then end the list of the hit(s) */
if (HitThisTopic)
{
fprintf (stdout, "</ul>\n");
fflush (stdout);
}
HitThisTopic = false;
}
else
{
/*************/
/* help text */
/*************/
/* check to see if this module record has any non-space chars */
for (cptr = Buffer; *cptr && isspace(*cptr); cptr++);
if (*cptr)
{
if (*(hptr = SearchText (cptr, CgiFormSearchPtr, false)))
{
/********/
/* hit! */
/********/
if (Debug) fprintf (stdout, "Hit |%s|\n", hptr);
SearchHitCount++;
sptr = String;
if (!HitThisTopic)
{
for (Count = 1; Count <= HelpLevel; Count++)
{
if (Count > 1) *sptr++ = ' ';
sptr += sprintf (sptr,
"<a href=\"%s%s?key=%s&title=%s&referer=%s\">%s</a>\n",
CgiScriptNamePtr, LibraryPathInfo,
FormatRequestKeys(true,Count),
UriFormTitle, UriReferer,
MungeUnderScores(KeyNameHtml[Count]));
}
sptr += sprintf (sptr, "<ul>\n<li class=\"helpresult\">");
HitThisTopic = true;
}
else
{
/* same topic, new hit */
sptr += sprintf (sptr, "<li class=\"helpresult\">");
}
ch = cptr[hptr-cptr];
cptr[hptr-cptr] = '\0';
sptr += CgiLibHtmlEscape (cptr, -1, sptr, -1);
cptr[hptr-cptr] = ch;
sptr += sprintf (sptr, "<span class=\"highlight\">");
strncpy (sptr, hptr, SearchStringLength);
sptr += SearchStringLength;
sptr += sprintf (sptr, "</span>");
sptr += CgiLibHtmlEscape (hptr+SearchStringLength, -1, sptr, -1);
sprintf (sptr, "</li>\n");
fputs (String, stdout);
}
}
}
}
if (HitThisTopic)
{
fprintf (stdout, "</ul>\n");
fflush (stdout);
HitThisTopic = false;
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
String together the keys associated with this help item.
*/
char* FormatRequestKeys
(
boolean ForUri,
int ToLevel
)
{
static char RequestKeys [256];
int idx;
char *sptr;
sptr = RequestKeys;
for (idx = 1; idx <= ToLevel; idx++)
{
if (ForUri)
sptr += CgiLibUrlEncode (KeyName[idx], -1, sptr, -1);
else
sptr += CgiLibHtmlEscape (KeyName[idx], -1, sptr, -1);
*sptr++ = '~';
}
/* if needed, get rid of that last '~'! */
if (idx > 1)
sptr[-1] = '\0';
else
*sptr = '\0';
return (RequestKeys);
}
/*****************************************************************************/
/*
*/
int ListTextLibraryModules ()
{
int status;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ListTextLibraryModules()\n");
BeginPage (LibraryTitle, HtmlLibraryTitle);
fprintf (stdout,
"<div class=\"searchform\">\n\
<form action=\"%s%s\">\n\
<input type=\"hidden\" name=\"referer\" value=\"%s\">\n\
<input type=\"hidden\" name=\"title\" value=\"%s\">\n\
<input type=\"hidden\" name=\"do\" value=\"search\">\n\
<input type=\"submit\" value=\"Search for: \">\n\
<input type=\"text\" name=\"Search\">\n\
<input type=\"reset\" value=\"Reset\">\n\
</form>\n\
</div>\n\
<div class=\"textmodules\">\n",
CgiScriptNamePtr, CgiPathInfoPtr,
HtmlReferer, HtmlFormTitle);
IndexNumber = 1;
if (VMSnok (status = lbr$get_index (&LibraryIndex,
&IndexNumber,
&ListTextModule,
KeyNameDsc())))
{
if (Debug) fprintf (stdout, "lib$get_index() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
fprintf (stdout, "</div>\n</div>\n");
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
}
/*****************************************************************************/
/*
*/
int ListTextModule
(
struct dsc$descriptor_s *KeyNameDscPtr,
void *RFAptr
)
{
static int PreviousCgiPlusUsageCount = 0;
static char PrevAlpha = '\0';
char String [1024],
UriKeyName [256];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ListTextModule()\n");
strncpy (KeyWord[1],
KeyNameDscPtr->dsc$a_pointer,
KeyNameDscPtr->dsc$w_length);
KeyWord[1][KeyNameDscPtr->dsc$w_length] = '\0';
strcpy (KeyName[1], KeyWord[1]);
CgiLibUrlEncode (KeyWord[1], -1, UriKeyName, -1);
CgiLibHtmlEscape (KeyWord[1], -1, KeyNameHtml[1], -1);
if (Debug) fprintf (stdout, "KeyNameDsc |%s|\n", KeyWord[1]);
if (ListSingle)
{
if (CgiPlusUsageCount == PreviousCgiPlusUsageCount)
fprintf (stdout, "\n<p>");
else
fprintf (stdout, "<p>");
}
else
if (!isalpha(KeyName[1][0]) ||
KeyName[1][0] == PrevAlpha)
{
if (CgiPlusUsageCount == PreviousCgiPlusUsageCount)
fprintf (stdout, "\n");
}
else
{
if (CgiPlusUsageCount == PreviousCgiPlusUsageCount)
fprintf (stdout, "\n<p>");
PrevAlpha = KeyName[1][0];
}
fprintf (stdout, "<a href=\"%s%s?key=%s&title=%s&referer=%s\">%s</a>\n",
CgiScriptNamePtr, LibraryPathInfo, UriKeyName,
UriFormTitle, UriReferer, KeyNameHtml[1]);
PreviousCgiPlusUsageCount = CgiPlusUsageCount;
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
*/
int OpenTextLibraryModule ()
{
int status;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "OpenTextLibraryModule()\n");
CgiLibResponseHeader (200, "text/plain",
"Last-Modified: %s\n", LastModifiedGmDateTime);
if (MethodHead) return (SS$_NORMAL);
IndexNumber = 1;
if (VMSnok (status = lbr$get_index (&LibraryIndex,
&IndexNumber,
&OpenTextModule,
KeyNameDsc())))
{
if (Debug) fprintf (stdout, "lib$get_index() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
return (status);
}
/*****************************************************************************/
/*
*/
int OpenTextModule
(
struct dsc$descriptor_s *KeyNameDscPtr,
void *RFAptr
)
{
int status;
char Buffer [1024];
$DESCRIPTOR (InBufferDsc, Buffer);
$DESCRIPTOR (OutBufferDsc, Buffer);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "OpenTextModule()\n");
strncpy (KeyWord[1],
KeyNameDscPtr->dsc$a_pointer,
KeyNameDscPtr->dsc$w_length);
KeyWord[1][KeyNameDscPtr->dsc$w_length] = '\0';
if (Debug) fprintf (stdout, "KeyNameDsc |%s|\n", KeyWord[1]);
if (VMSnok (status = lbr$lookup_key (&LibraryIndex,
KeyNameDscPtr,
&ModuleRFA)))
{
if (Debug) fprintf (stdout, "lib$lookup_key() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
/**************************************/
/* loop through all records in module */
/**************************************/
for (;;)
{
status = lbr$get_record (&LibraryIndex,
&InBufferDsc,
&OutBufferDsc);
if (Debug) fprintf (stdout, "lbr$get_record() %%X%08.08X\n", status);
if (VMSnok (status)) break;
/* add HTTP required carriage-control */
Buffer[OutBufferDsc.dsc$w_length] = '\n';
Buffer[OutBufferDsc.dsc$w_length+1] = '\0';
fputs (Buffer, stdout);
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
*/
int SearchTextLibraryModules ()
{
int status;
char String [1024];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SearchTextLibraryModules()\n");
sprintf (String, "Search "%s" for "%s"\n",
HtmlLibraryTitle, HtmlSearchString);
BeginPage (String, String);
fprintf (stdout, "<div class=\"results\">\n");
RecordsSearched = SearchHitCount = 0;
IndexNumber = 1;
if (DoSearchStatistics) lib$init_timer (0);
if (VMSnok (status = lbr$get_index (&LibraryIndex,
&IndexNumber,
&SearchTextModule,
KeyNameDsc())))
{
if (Debug) fprintf (stdout, "lib$get_index() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
if (!SearchHitCount) fprintf (stdout, "<b>Not found!</b>\n<p>");
if (DoSearchStatistics) SearchStatistics ();
fprintf (stdout, "</div>\n</div>\n");
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
}
/*****************************************************************************/
/*
*/
int SearchTextModule
(
struct dsc$descriptor_s *KeyNameDscPtr,
void *RFAptr
)
{
boolean HitThisModule = false;
int status;
char ch;
char *cptr, *hptr, *sptr;
char Buffer [1024],
String [1024];
$DESCRIPTOR (InBufferDsc, Buffer);
$DESCRIPTOR (OutBufferDsc, Buffer);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SearchTextModule()\n");
strncpy (KeyName[1],
KeyNameDscPtr->dsc$a_pointer,
KeyNameDscPtr->dsc$w_length);
KeyName[1][KeyNameDscPtr->dsc$w_length] = '\0';
CgiLibHtmlEscape (KeyName[1], -1, KeyNameHtml[1], -1);
if (Debug) fprintf (stdout, "KeyNameDsc |%s|\n", KeyName[1]);
if (VMSnok (status = lbr$lookup_key (&LibraryIndex,
KeyNameDscPtr,
&ModuleRFA)))
{
if (Debug) fprintf (stdout, "lib$get_index() %%X%08.08X\n", status);
CgiLibResponseError (FI_LI, status, HtmlLibraryTitle);
return (SS$_NORMAL);
}
/**************************************/
/* loop through all records in module */
/**************************************/
for (;;)
{
status = lbr$get_record (&LibraryIndex,
&InBufferDsc,
&OutBufferDsc);
if (Debug) fprintf (stdout, "lbr$get_record() %%X%08.08X\n", status);
if (VMSnok (status)) break;
Buffer[OutBufferDsc.dsc$w_length] = '\0';
if (Debug) fprintf (stdout, "Buffer |%s|\n", Buffer);
/* check to see if this module record has any non-space chars */
for (cptr = Buffer; *cptr && isspace(*cptr); cptr++);
if (*cptr)
{
if (*(hptr = SearchText (cptr, CgiFormSearchPtr, false)))
{
/********/
/* hit! */
/********/
if (Debug) fprintf (stdout, "Hit |%s|\n", sptr);
SearchHitCount++;
sptr = String;
if (!HitThisModule)
{
sptr += sprintf (sptr,
"<a href=\"%s%s?key=%s&title=%s&referer=%s\"><b>%s</b></a>\n<ul>\n",
CgiScriptNamePtr, LibraryPathInfo,
KeyName[1], UriFormTitle, UriReferer, KeyNameHtml[1]);
HitThisModule = true;
}
sptr += sprintf (sptr, "<li class=\"textresult\">");
ch = cptr[hptr-cptr];
cptr[hptr-cptr] = '\0';
sptr += CgiLibHtmlEscape (cptr, -1, sptr, -1);
cptr[hptr-cptr] = ch;
sptr += sprintf (sptr, "<span class=\"highlight\">");
strncpy (sptr, hptr, SearchStringLength);
sptr += SearchStringLength;
sptr += sprintf (sptr, "</span>");
sptr += CgiLibHtmlEscape (hptr+SearchStringLength, -1, sptr, -1);
sprintf (sptr, "</li>\n");
fputs (String, stdout);
}
}
}
if (HitThisModule)
{
fprintf (stdout, "</ul>\n");
fflush (stdout);
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Case sensistive or case insensistive search of the string pointed to by 'sptr'
for the string pointed to by 'SearchString'.
*/
char* SearchText
(
char *tptr,
char *SearchString,
boolean CaseSensitive
)
{
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SearchText()\n");
RecordsSearched++;
sptr = SearchString;
if (CaseSensitive)
{
while (*tptr)
{
if (*tptr++ != *sptr) continue;
/* first character of search string matched record character */
sptr++;
cptr = tptr;
while (*cptr && *sptr)
{
if (*cptr != *sptr) break;
cptr++;
sptr++;
}
if (!*sptr)
{
tptr--;
break;
}
sptr = SearchString;
}
}
else
{
while (*tptr)
{
if (toupper(*tptr++) != toupper(*sptr)) continue;
/* first character of search string matched record character */
sptr++;
cptr = tptr;
while (*cptr && *sptr)
{
if (toupper(*cptr) != toupper(*sptr)) break;
cptr++;
sptr++;
}
if (!*sptr)
{
tptr--;
break;
}
sptr = SearchString;
}
}
return (tptr);
}
/*****************************************************************************/
/*
*/
SearchStatistics ()
{
static long LibElapsedTime = 1,
LibCpuTime = 2;
static $DESCRIPTOR (ElapsedFaoDsc, "!%T");
static $DESCRIPTOR (SearchStats1FaoDsc,
"<div class=\"searchstats\">\
<b>Elapsed:</b> !AZ \
<b>CPU:</b> !2ZL:!2ZL.!2ZL \
<b>records (lines):</b> !UL\
</div>\n");
unsigned long ElapsedTime [2];
unsigned long CpuTime;
unsigned short Length;
char Elapsed [32],
String [512];
$DESCRIPTOR (ElapsedDsc, Elapsed);
$DESCRIPTOR (StringDsc, String);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SearchStatistics()\n");
lib$stat_timer (&LibElapsedTime, &ElapsedTime, 0);
lib$stat_timer (&LibCpuTime, &CpuTime, 0);
sys$fao (&ElapsedFaoDsc, &Length, &ElapsedDsc, &ElapsedTime);
Elapsed[Length] = '\0';
sys$fao (&SearchStats1FaoDsc, &Length, &StringDsc,
Elapsed+3,
CpuTime/6000, CpuTime/100, CpuTime%100,
RecordsSearched);
String[Length] = '\0';
fprintf (stdout, "%s", String);
}
/*****************************************************************************/
/*
Output the HTTP header and page header.
*/
BeginPage
(
char *TitleString,
char *HeaderString
)
{
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "BeginPage()\n");
CgiLibResponseHeader (200, "text/html",
"Last-Modified: %s\n", LastModifiedGmDateTime);
if (MethodHead) return;
fprintf (stdout,
"<!DOCTYPE html>\n\
<html>\n\
<head>\n\
<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">\n\
<meta name=\"generator\" content=\"%s\">\n\
<meta name=\"copyright\" content=\"%s - GPL licensed\">\n\
<meta name=\"environment\" content=\"%s\">\n\
<meta name=\"date\" content=\"%s\">\n\
<title>%s</title>\n\
<style type=\"text/css\">\n\
%s\
</style>\n\
%s\
</head>\n\
<body>\n",
SoftwareID, SoftwareCopy,
CgiLibEnvironmentPtr,
UnixDateTime,
TitleString,
DefaultStyle,
StyleSheetPtr);
fprintf (stdout,
"<div class=\"header\">%s</div>\n\
<div class=\"libcontent\">\n",
HeaderString);
fflush (stdout);
}
/*****************************************************************************/
/*
In a help key string turn underscores into spaces mixed case.
*/
char* MungeUnderScores (char *InString)
{
static char OutString [128];
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MungeUnderScores()\n");
sptr = OutString;
if (InString[0] != '/')
{
/* not a qualifier, see if it's all the one case! */
if (isupper(InString[0]))
{
for (cptr = InString; *cptr; cptr++)
if (isalpha(*cptr) && !isupper(*cptr)) break;
}
else
{
for (cptr = InString; *cptr; cptr++)
if (isalpha(*cptr) && !islower(*cptr)) break;
}
}
if (InString[0] != '/' && *cptr)
{
/* probably an underscore-joined topic string */
for (cptr = InString; *cptr; cptr++)
{
if (*cptr == '_')
*sptr++ = ' ';
else
*sptr++ = *cptr;
}
}
else
{
/* all upper-case, probably some particular VMS parameter */
for (cptr = InString; *cptr; cptr++)
*sptr++ = *cptr;
}
*sptr = '\0';
return (OutString);
}
/*****************************************************************************/
/*
If the object has been modified since the specified date and time then return
a normal status indicating that the data transfer is to continue. If not
modified then send a "not modified" HTTP header and return an error status to
indicate the object should not be sent.
*/
int ModifiedSince
(
unsigned long *SinceBinaryTimePtr,
unsigned long *BinaryTimePtr
)
{
static unsigned long OneSecondDelta [2] = { -10000000, -1 };
int status;
unsigned long AdjustedBinTime [2],
ScratchBinTime [2];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ModifiedSince()\n");
/* if request asks for a "reload" (not cached) then give it regardless */
if (strsame (CgiHttpPragmaPtr, "no-cache", -1)) return (SS$_NORMAL);
if (strsame (CgiHttpCacheControlPtr, "no-cache", 8)) return (SS$_NORMAL);
if (strsame (CgiHttpCacheControlPtr, "no-store", 8)) return (SS$_NORMAL);
if (strsame (CgiHttpCacheControlPtr, "max-age=0", 9)) return (SS$_NORMAL);
/*
Add one second to the modified time. Ensures a negative time
for VMS where fractional seconds may result in inconclusive
results when the target time is being specified in whole seconds.
*/
if (VMSnok (status =
lib$add_times (SinceBinaryTimePtr, &OneSecondDelta, &AdjustedBinTime)))
{
CgiLibResponseError (FI_LI, status, "IfModifiedSince:");
return (status);
}
if (Debug) fprintf (stdout, "sys$add_times() %%X%08.08X\n", status);
/* if a positive time results the file has been modified */
if (VMSok (status =
lib$sub_times (BinaryTimePtr, &AdjustedBinTime, &ScratchBinTime)))
return (status);
if (Debug) fprintf (stdout, "sys$sub_times() %%X%08.08X\n", status);
if (status != LIB$_NEGTIM)
{
CgiLibResponseError (FI_LI, status, "IfModifiedSince:");
return (status);
}
/* not modified */
CgiLibResponseHeader (304, "text/html");
fprintf (stdout, "Not modified!\n");
return (LIB$_NEGTIM);
}
/*****************************************************************************/
/*
Create an HTTP format Greenwich Mean Time (UTC) time string in the storage
pointed at by 'TimeString', e.g. "Fri, 25 Aug 1995 17:32:40 GMT" (RFC 1123).
This must be at least 30 characters capacity. If 'BinTimePtr' is null the
time string represents the current time. If it points to a quadword, VMS time
value the string represents that time. 'TimeString' must point to storage
large enough for 31 characters.
*/
int HttpGmTimeString
(
char *TimeString,
unsigned long *BinTimePtr
)
{
static char *DayNames [] =
{ "", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
static char *MonthName [] =
{ "", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
static $DESCRIPTOR (HttpTimeFaoDsc, "!AZ, !2ZW !AZ !4ZW !2ZW:!2ZW:!2ZW GMT");
static $DESCRIPTOR (TimeStringDsc, "");
int status;
unsigned long BinTime [2],
GmTime [2];
unsigned short Length;
unsigned short NumTime [7];
unsigned long DayOfWeek;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "HttpGmTimeString()\n");
if (!BinTimePtr)
sys$gettim (&GmTime);
else
{
GmTime[0] = BinTimePtr[0];
GmTime[1] = BinTimePtr[1];
}
if (VMSnok (status = TimeAdjustGMT (true, &GmTime)))
return (status);
status = sys$numtim (&NumTime, &GmTime);
if (Debug)
fprintf (stdout, "sys$numtim() %%X%08.08X %d %d %d %d %d %d %d\n",
status, NumTime[0], NumTime[1], NumTime[2],
NumTime[3], NumTime[4], NumTime[5], NumTime[6]);
if (VMSnok (status = lib$day_of_week (&GmTime, &DayOfWeek)))
return (status);
if (Debug)
fprintf (stdout, "lib$day_of_week() %%X%08.08X is %d\n",
status, DayOfWeek);
/* set the descriptor address and size of the resultant time string */
TimeStringDsc.dsc$w_length = 30;
TimeStringDsc.dsc$a_pointer = TimeString;
if (VMSnok (status =
sys$fao (&HttpTimeFaoDsc, &Length, &TimeStringDsc,
DayNames[DayOfWeek], NumTime[2], MonthName[NumTime[1]],
NumTime[0], NumTime[3], NumTime[4], NumTime[5])))
{
if (Debug) fprintf (stdout, "sys$fao() %%X%08.08X\n", status);
TimeString[0] = '\0';
}
else
TimeString[Length] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", TimeString);
return (status);
}
/*****************************************************************************/
/*
Given a string such as "Fri, 25 Aug 1995 17:32:40 GMT" (RFC 1123), or "Friday,
25-Aug-1995 17:32:40 GMT" (RFC 1036), create an internal, local, binary time
with the current GMT offset. See complementary function HttpGmTimeString().
*/
int HttpGmTime
(
char *TimeString,
unsigned long *BinTimePtr
)
{
static char *MonthName [] =
{ "", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
int status;
char *tptr;
unsigned short Length;
unsigned short NumTime [7] = { 0,0,0,0,0,0,0 };
unsigned long DayOfWeek;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "HttpGmTime() |%s|\n", TimeString);
tptr = TimeString;
/* hunt straight for the comma after the weekday name! */
while (*tptr && *tptr != ',') tptr++;
if (*tptr) tptr++;
/* span white space between weekday name and date */
while (*tptr && isspace(*tptr)) tptr++;
if (Debug) fprintf (stdout, "tptr |%s|\n", tptr);
if (!*tptr) return (STS$K_ERROR);
/* get the date and then skip to month name */
if (isdigit(*tptr)) NumTime[2] = atoi (tptr);
while (*tptr && isdigit(*tptr)) tptr++;
while (*tptr && (*tptr == '-' || isspace(*tptr))) tptr++;
if (Debug) fprintf (stdout, "tptr |%s|\n", tptr);
if (!*tptr) return (STS$K_ERROR);
/* get the month number from the name and skip to the year */
for (NumTime[1] = 1; NumTime[1] <= 12; NumTime[1]++)
if (strsame (tptr, MonthName[NumTime[1]], 3)) break;
if (NumTime[1] > 12) return (STS$K_ERROR);
while (*tptr && isalpha(*tptr)) tptr++;
while (*tptr && (*tptr == '-' || isspace(*tptr))) tptr++;
if (Debug) fprintf (stdout, "tptr |%s|\n", tptr);
if (!*tptr) return (STS$K_ERROR);
/* get the year and then skip to the hour */
if (isdigit(*tptr))
{
NumTime[0] = atoi (tptr);
if (NumTime[0] < 100) NumTime[0] += 1900;
}
while (*tptr && isdigit(*tptr)) tptr++;
while (*tptr && isspace(*tptr)) tptr++;
if (Debug) fprintf (stdout, "tptr |%s|\n", tptr);
if (!*tptr) return (STS$K_ERROR);
/* get the hour, minute and second */
if (isdigit(*tptr)) NumTime[3] = atoi (tptr);
while (*tptr && isdigit(*tptr)) tptr++;
if (*tptr == ':') tptr++;
if (isdigit(*tptr)) NumTime[4] = atoi (tptr);
while (*tptr && isdigit(*tptr)) tptr++;
if (*tptr == ':') tptr++;
if (isdigit(*tptr)) NumTime[5] = atoi (tptr);
while (*tptr && isdigit(*tptr)) tptr++;
if (*tptr == ':') tptr++;
if (!*tptr) return (STS$K_ERROR);
/* the only thing remaining should be the "GMT" */
while (*tptr && isspace(*tptr)) tptr++;
if (Debug) fprintf (stdout, "tptr |%s|\n", tptr);
if (!strsame (tptr, "GMT", 3)) return (STS$K_ERROR);
/*******************************************/
/* convert what looks like legitimate GMT! */
/*******************************************/
if (Debug)
fprintf (stdout, "NumTime[] %d %d %d %d %d %d %d\n",
NumTime[0], NumTime[1], NumTime[2], NumTime[3],
NumTime[4], NumTime[5], NumTime[6]);
status = lib$cvt_vectim (&NumTime, BinTimePtr);
if (VMSnok (status)) return (status);
if (Debug) fprintf (stdout, "lib$cvt_vectim() %%X%08.08X\n", status);
return (TimeAdjustGMT (false, BinTimePtr));
}
/*****************************************************************************/
/*
Determine the offset from GMT (UTC) using either the HTTPD$GMT or
SYS$TIMEZONE_DIFFERENTIAL logicals. If HTTPD$GMT is not defined time should be
set from the timezone differential logical. Function RequestBegin() calls
this every hour to recheck GMT offset and detect daylight saving or other
timezone changes.
*/
int TimeSetGmt ()
{
static boolean UseTimezoneDifferential = false;
int status;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "TimeSetGmt()\n");
if (!UseTimezoneDifferential)
{
status = TimeSetHttpdGmt();
/* return if error and that error was not that the name did not exist */
if (VMSok (status) || status != SS$_NOLOGNAM) return (status);
}
UseTimezoneDifferential = true;
return (TimeSetTimezone());
}
/*****************************************************************************/
/*
The SYS$TIMEZONE_DIFFERENTIAL logical contains the number of seconds offset
from GMT (UTC) as a positive (ahead) or negative (behind) number. Set the
'TimeGmtString' global storage to a "+hh:mm" or "-hh:mm" string equivalent, and
the 'TimeAheadOfGmt' global boolean and 'TimeGmtVmsString' delta-time global
string.
*/
int TimeSetTimezone ()
{
static unsigned short Length;
static $DESCRIPTOR (TimezoneLogicalNameDsc, "SYS$TIMEZONE_DIFFERENTIAL");
static $DESCRIPTOR (LnmSystemDsc, "LNM$SYSTEM");
static $DESCRIPTOR (TimeGmtStringFaoDsc, "!AZ!2ZL:!2ZL");
static $DESCRIPTOR (TimeGmtVmsStringFaoDsc, "0 !2ZL:!2ZL");
static $DESCRIPTOR (TimeGmtStringDsc, TimeGmtString);
static struct {
short int buf_len;
short int item;
void *buf_addr;
unsigned short *ret_len;
} LnmItems [] =
{
{ sizeof(TimeGmtString)-1, LNM$_STRING, TimeGmtString, &Length },
{ 0,0,0,0 }
};
int status;
long Hours,
Minutes,
Seconds;
char *SignPtr;
$DESCRIPTOR (TimeGmtVmsStringDsc, TimeGmtVmsString);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "TimeSetTimezone()\n");
status = sys$trnlnm (0, &LnmSystemDsc, &TimezoneLogicalNameDsc, 0, &LnmItems);
if (Debug) fprintf (stdout, "sys$trnlnm() %%X%08.08X\n", status);
if (VMSnok (status)) return (status);
TimeGmtString[Length] = '\0';
if (Debug) fprintf (stdout, "TimeGmtString |%s|\n", TimeGmtString);
Seconds = atol(TimeGmtString);
if (Seconds < 0)
{
TimeAheadOfGmt = false;
Seconds = -Seconds;
SignPtr = "-";
}
else
{
TimeAheadOfGmt = true;
SignPtr = "+";
}
Hours = Seconds / 3600;
Minutes = (Seconds - Hours * 3600) / 60;
if (Debug)
fprintf (stdout, "%d %s%d:%d\n", Seconds, SignPtr, Hours, Minutes);
sys$fao (&TimeGmtStringFaoDsc, &Length, &TimeGmtStringDsc,
SignPtr, Hours, Minutes);
TimeGmtString[Length] = '\0';
if (Debug) fprintf (stdout, "TimeGmtString |%s|\n", TimeGmtString);
sys$fao (&TimeGmtVmsStringFaoDsc, &Length, &TimeGmtVmsStringDsc,
Hours, Minutes);
TimeGmtVmsString[Length] = '\0';
if (Debug) fprintf (stdout, "TimeGmtVmsString |%s|\n", TimeGmtVmsString);
TimeGmtVmsStringDsc.dsc$w_length = Length;
if (VMSnok (status =
sys$bintim (&TimeGmtVmsStringDsc, &TimeGmtDeltaBinary)))
return (status);
if (TimeGmtDeltaBinary[0] || TimeGmtDeltaBinary[1])
return (status);
/* time must have been zero, make it one, one-hundreth of a second */
TimeGmtDeltaBinary[0] = -100000;
TimeGmtDeltaBinary[1] = -1;
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Translate the logical HTTPD$GMT (defined to be something like "+10:30" or "-
01:15") and convert it into a delta time structure and store in
'TimeGmtDeltaBinary'. Store whether it is in advance or behind GMT in boolean
'TimeAheadOfGmt'. Store the logical string in 'TimeGmtString'.
*/
int TimeSetHttpdGmt ()
{
static unsigned short Length;
static $DESCRIPTOR (GmtLogicalNameDsc, "HTTPD$GMT");
static $DESCRIPTOR (LnmFileDevDsc, "LNM$FILE_DEV");
static struct {
short int buf_len;
short int item;
void *buf_addr;
unsigned short *ret_len;
} LnmItems [] =
{
{ sizeof(TimeGmtString)-1, LNM$_STRING, TimeGmtString, &Length },
{ 0,0,0,0 }
};
int status;
char *cptr, *sptr;
$DESCRIPTOR (TimeGmtVmsStringDsc, TimeGmtVmsString);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "TimeSetHttpdGmt()\n");
status = sys$trnlnm (0, &LnmFileDevDsc, &GmtLogicalNameDsc, 0, &LnmItems);
if (Debug) fprintf (stdout, "sys$trnlnm() %%X%08.08X\n", status);
if (VMSnok (status)) return (status);
TimeGmtString[Length] = '\0';
if (Debug) fprintf (stdout, "TimeGmtString |%s|\n", TimeGmtString);
if (TimeGmtString[0] == '$') return (SS$_NORMAL);
if (*(cptr = TimeGmtString) == '-')
TimeAheadOfGmt = false;
else
TimeAheadOfGmt = true;
if (*cptr == '+' || *cptr == '-') cptr++;
sptr = TimeGmtVmsString;
*sptr++ = '0';
*sptr++ = ' ';
while (*cptr) *sptr++ = *cptr++;
*sptr = '\0';
if (Debug) fprintf (stdout, "TimeGmtVmsString |%s|\n", TimeGmtVmsString);
TimeGmtVmsStringDsc.dsc$w_length = sptr - TimeGmtVmsString;
if (VMSnok (status =
sys$bintim (&TimeGmtVmsStringDsc, &TimeGmtDeltaBinary)))
return (status);
if (TimeGmtDeltaBinary[0] || TimeGmtDeltaBinary[1])
return (status);
/* time must have been zero, make it one, one-hundreth of a second */
TimeGmtDeltaBinary[0] = -100000;
TimeGmtDeltaBinary[1] = -1;
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
The GMT is generated by calculating using an offset using
'TimeGmtDeltaOffset' and boolean 'TimeAheadOfGmt'. Adjust either to or from
GMT.
*/
int TimeAdjustGMT
(
boolean ToGmTime,
unsigned long *BinTimePtr
)
{
int status;
unsigned long AdjustedTime [2];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "TimeAdjustGMT() ToGmTime: %d\n", ToGmTime);
if ((ToGmTime && TimeAheadOfGmt) || (!ToGmTime && !TimeAheadOfGmt))
{
/* to GMT from local and ahead of GMT, or to local from GMT and behind */
status = lib$sub_times (BinTimePtr, &TimeGmtDeltaBinary, &AdjustedTime);
if (Debug) fprintf (stdout, "lib$sub_times() %%X%08.08X\n", status);
}
else
{
/* to GMT from local and behind GMT, or to local from GMT and ahead */
status = lib$add_times (BinTimePtr, &TimeGmtDeltaBinary, &AdjustedTime);
if (Debug) fprintf (stdout, "lib$add_times() %%X%08.08X\n", status);
}
if (Debug)
{
unsigned short Length;
char String [64];
$DESCRIPTOR (AdjustedTimeFaoDsc, "AdjustedTime: |!%D|\n");
$DESCRIPTOR (StringDsc, String);
sys$fao (&AdjustedTimeFaoDsc, &Length, &StringDsc, &AdjustedTime);
String[Length] = '\0';
fprintf (stdout, "%s", String);
}
BinTimePtr[0] = AdjustedTime[0];
BinTimePtr[1] = AdjustedTime[1];
return (status);
}
/*****************************************************************************/
/*
Output an HTML-escaped, URL-anchored, and "$ HELP"-anchored string.
*/
HtmlOutputString
(
char *InString,
boolean AnchorUrls
)
{
char OutString [1024];
char *cptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "HtmlOutputString()\n");
CgiLibAnchorHtmlEscape (InString, -1,
OutString, sizeof(OutString),
AnchorUrls);
if (cptr = strstr (OutString, "$ HELP"))
{
char *sptr, *tptr;
char Scratch [1024];
cptr += 2;
tptr = cptr + 4;
sptr = Scratch;
while (*tptr && *tptr != '\n')
{
switch (*tptr)
{
case ' ' : *sptr++ = '/'; break;
case '/' : *sptr++ = '/'; *sptr++ = '/'; break;
default : *sptr++ = *tptr;
}
tptr++;
}
*sptr = '\0';
*tptr = '\0';
fwrite (OutString, cptr-OutString, 1, stdout);
fprintf (stdout, "<a href=\"%s%s\">%s</a>\n",
CgiScriptNamePtr, Scratch, cptr);
}
else
fputs (OutString, stdout);
}
/****************************************************************************/
/*
Return an integer reflecting the major and minor version of VMS (e.g. 60, 61,
62, 70, 71, 72, etc.)
*/
#ifdef ODS_EXTENDED
int GetVmsVersion ()
{
static char SyiVersion [16];
static struct {
short int buf_len;
short int item;
void *buf_addr;
unsigned short *ret_len;
}
SyiItems [] =
{
{ 8, SYI$_VERSION, &SyiVersion, 0 },
{ 0,0,0,0 }
};
int status,
version;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "GetVmsVersion()\n");
if (VMSnok (status = sys$getsyiw (0, 0, 0, &SyiItems, 0, 0, 0)))
exit (status);
SyiVersion[8] = '\0';
version = ((SyiVersion[1]-48) * 10) + (SyiVersion[3]-48);
if (Debug) fprintf (stdout, "|%s| %d\n", SyiVersion, version);
return (version);
}
#endif /* ODS_EXTENDED */
/*****************************************************************************/
/*
Return non-NULL pointer if looks a bit suspect!
*/
char* XSSuspect (char *cptr)
{
static char XSSredacted [] = "XSS redacted! (tsk-tsk)";
char *sptr, *zptr;
char buf [1024];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "XSSuspect() |%s|\n", cptr);
if (!cptr || !*cptr) return (NULL);
if (strstr (cptr, "</")) return (XSSredacted);
zptr = (sptr = buf) + sizeof(buf)-1;
while (*cptr && *cptr && sptr < zptr) *sptr++ = tolower(*cptr++);
*sptr = '\0';
if (sptr >= zptr || strstr (buf, "<script>")) return (XSSredacted);
return (NULL);
}
/****************************************************************************/
/*
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.
*/
boolean 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);
}
/*****************************************************************************/