[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]
/*****************************************************************************/
/*
HyperShelf.c
A CGI-compliant script.
Can be supported by any server that supplies the CGI variables listed below.
ABOUT HYPERSHELF
----------------
Emulates the "Bookshelf Navigation Utility" (BNU) of 1997ff on-line
documentation CD releases, and the Bookreader shelf navigation capability of
earlier times. It has some additional capabilities not found in either, the
ability to provide access to PostScript, plain-text documents and PDF
documents.
Page colouration may be specified via the appropriate command-line qualifiers
(or corresponding logical name). Defaults for any not specified. Specifiy as
/BLAH="" to NOT specify the corresponding colour (i.e. leave it to the
browser).
Server mapping must include rules for all file paths (devices) which have
shelves residing on them. This script munges VMS file paths into URL-style
equivalents. For example:
DISK$AXPDOCSEP971:[DATABASE]D39QAAA8.BKB
would be represented as
/disk$axpdocsep971/database/d39qaaa8.bkb
Therefore the server must map the "/disk$axpdocsep971/*" into the VMS
equivalent, and of course all file paths that can possibly be returned.
Actual a useful rule for all BNU CDs is (depending on your architecture):
pass /disk$axpdoc* /disk$axpdoc*
pass /disk$vaxdoc* /disk$vaxdoc*
Thanks to Jeff Goodwin of Fairchild Semiconductor for these VMS Apache mappings
AliasMatch ^/disk\$axpdoc(.+) /disk$axpdoc$1
AliasMatch ^/disk\$vaxdoc(.+) /disk$vaxdoc$1
Digital Bookreader supports Bookreader format documents.
Digital BNU (currently) supports Bookreader and HTML documents.
WASD Hypershelf supports both plus the following extensions; PostScript, plain-
text and Adobe PDF documents. It does not support Bristol HyperHelp.
Note that the Hypershelf extensions are preceded by two comment characters,
either "##" (as in the example) or "!!". The prevents the BNU from barfing on
them. If a title is the same as the previous entry (or is missing altogether)
the document title becomes a description of the document type. For examples of
how they behave do a
http:///hypershelf/wasd_root/exercise/library.odl
http:///hypershelf/wasd_root/exercise/library.decw$bookshelf
HYPERSHELF EXTENSIONS (see examples for examples)
---------------------
##post PostScript document
##plain plain-text document
##pdf Adobe Portable Document Format
##url relative or full Web URL (e.g. 'http://the.host.name/library/')
EXAMPLE BNU SHELF (extension: .ODL)
-----------------
Title VMS Hypertext Services Library (BNU version!)
book /wasd_root/doc/htd/htd.decw$book Technical Overview
html /wasd_root/doc/htd/htd_0000.html Technical Overview
##post /wasd_root/doc/htd/htd.ps Technical Overview
##plain /wasd_root/doc/htd/htd.txt Technical Overview
##pdf /wasd_root/doc/htd/htd.pdf Technical Overview
book /wasd_root/doc/env/env.decw$book Hypertext Environment
html /wasd_root/doc/env/env_0000.html Hypertext Environment
# don't have to specify the title for the same document but different type
##post /wasd_root/doc/env/env.ps
##plain /wasd_root/doc/env/env.txt
book /wasd_root/doc/sdm2htm/sdm2htm.decw$book SDML to HTML Converter
html /wasd_root/doc/sdm2htm/sdm2htm_0000.html SDML to HTML Converter
##post /wasd_root/doc/sdm2htm/sdm2htm.ps SDML to HTML Converter
book /wasd_root/doc/menu_primer/menu_primer.decw$book Menu Primer
html /wasd_root/doc/menu_primer/menu_primer_0000.html Menu Primer
##url http://the.host.name/library/ The Host Name Library
##url /docs/ Local Server Documents
EXAMPLE BOOKREADER SHELF (extension: .DECW$BOOKSHELF or .BKS)
------------------------
title\\VMS Hypertext Services Library (Bookreader version!)
book\wasd_root:[doc.htd]htd\Technical Overview
##html\wasd_root:[doc.htd]htd_0000.html\
##ps\wasd_root:[doc.htd]htd.ps\
##plain\wasd_root:[doc.htd]htd.txt\
##pdf\wasd_root:[doc.htd]htd.pdf\
book\wasd_root:[doc.env]env\Hypertext Environment
##html\wasd_root:[doc.env]env_0000.html\
##post\wasd_root:[doc.env]env.ps\
##plain\wasd_root:[doc.env]env.txt\
book\wasd_root:[doc.sdm2htm]sdm2htm\SDML to HTML Converter
##html\wasd_root:[doc.sdm2htm]sdm2htm_0000.html\
##ps\wasd_root:[doc.sdm2htm]sdm2htm.ps\
book\wasd_root:[doc.menu_primer]menu_primer\Menu Primer
##html\wasd_root:[doc.menu_primer]menu_primer_0000.html\Menu Primer
##url\http://the.host.name/library/\The Host Name Library
##url\/docs/\Local Server Documents
BNU OR BOOKREADER BEHAVIOUR?
----------------------------
HyperShelf adjusts it's behaviour according to the shelf file it is given in
the path. If the file has a type of .ODL it is considered to be in BNU shelf
format (see above). Any other type (e.g. .BKS or .DECW$BOOKSHELF) it
considers to be in Bookreader format (again, see above).
If a path to a shelf is not provided HyperShelf looks into the environment for
the DECW$BOOK and DECW$BOOKSHELF logicals. If it finds DECW$BOOK it considers
it is a Bookreader environment and BNU is not in use. It they are not found it
considers it a BNU environment. To specify a default BNU library for when
none is supplied in the path use the /LIBRARY qualifier in a script support
procedure.
In a Bookreader environment HyperShelf will open any library specified by
DECW$BOOKSHELF (or libraries if it has multiple translations). If not defined
it searches for a file using DECW$BOOK:LIBRARY.* The first found will become
the default library. This will select all libraries (Digital and third party)
if DECW$BOOK is defined with multiple translations. The first library
encountered is expanded to display it's contents. Subsequent libraries have a
shelf link created for them with information appended to the description
indicating it is a library. The use of search lists can considerably extend
library access (search) times, particularly when slow CD-ROM readers,
InfoServers or DECnet/FAL is involved. A faster alternative is to incorporate
references to these in an explicit DECW$BOOKSHELF logical.
The BNU environment does not use logical names or logical search lists.
Everthing appears to be "hard-wired" into the shelves in a URL-style or
Unix-style file path (understandable when you consider part of the BNU viewing
environment is a browser (Netscape Navigator)). If HyperShelf is not supplied
with a path to an ODL shelf it will search for one of those listed in
'OdlShelfDefaults' storage below.
The qualifiers /BNU and /BOOKREADER can be used to force one behaviour or the
other.
SPECIFYING SHELVES
------------------
Shelves are specified in one of four ways, with the indicated precedence.
1. ?file= .......... request query string form field (VMS file spec)
2. /path/to/file ... path into VMS file spec via WWW_PATH_TRANSLATED
3. /LIBRARY= ....... HYPERSHELF script qualifier (VMS file spec)
4. no path ......... DECW$BOOK, DECW$BOOKSHELF, BNU default libraries
OSU ENVIRONMENT
---------------
Script responses are returned in OSU "raw" mode; the script taking care of the
full response header and correctly carriage-controlled data stream, text or
binary!! Uses the CGILIB.C to engage in the dialog phase generating, storing
and then making available the equivalent of CGI variables.
To use the executable directly (no wrapper procedure), as in
http://the.host.name/htbin/hypershelf
Define a system-wide logical during server startup
$ HYPERSHELF_PARAM = -
"/buttons=""Close$Help=/wasd/runtime/hypershelfhelp.html""" +-
"/icons=""/wasd/runtime"""
$ DEFINE /SYSTEM HYPERSHELF$PARAM HYPERSHELF_PARAM
APACHE CGI ENVIRONMENT
----------------------
To use the executable directly (no wrapper procedure), as in
http://the.host.name/cgi-bin/hypershelf
Define a system-wide logical during server startup
$ HYPERSHELF_PARAM = -
"/buttons=""Close$Help=/wasd/runtime/hypershelfhelp.html""" +-
"/icons=""/wasd/runtime"""
$ DEFINE /SYSTEM HYPERSHELF$PARAM HYPERSHELF_PARAM
CGI VARIABLES
-------------
Server generated ...
WWW_HTTP_IF_MODIFIED_SINCE if "304 Not modified" are desired (optional)
WWW_HTTP_PRAGMA "no-cache" (optional)
WWW_HTTP_REFERER "close" button becomes active
WWW_PATH_INFO URL path to shelf
WWW_PATH_TRANSLATED VMS file specification for shelf
WWW_REQUEST_METHOD "GET" only is supported
WWW_SCRIPT_NAME path to script
WWW_SERVER_CHARSET default character set of server
WWW_SERVER_NAME host on which the script is executing
WWW_SERVER_SOFTWARE HTTPd identifying string
HyperShelf generated ...
WWW_FORM_FILE VMS file name for shelf (when path cannot be supplied)
WWW_FORM_REFERER overrides the HTTP_REFERER URL
WWW_FORM_TITLE explicit title of book
QUALIFIERS
----------
/BOOKREADER Bookreader is the default shelf processor
/BNU Bookshelf Navigation Utility is the default shelf processor
/CHARSET= "Content-Type: text/html; charset=...", empty suppresses charset
/DBUG turns on all "if (Debug)" statements (don't use with OSU)
/HYPERREADER= name of 'HyperReader' script (defaults to "/hyperreader")
/ICON= path to icons
/LIBRARY= specifies the default library (shelf) file (VMS path)
/[NO]ODS5 control extended file specification (basically for testing)
/PRINT= name of 'Print' script (optional)
LOGICAL NAMES
-------------
HYPERSHELF$DBUG turns on all "if (Debug)" statements
HYPERSHELF$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)
BUILD DETAILS
-------------
See BUILD_HYPERSHELF.COM procedure.
COPYRIGHT
---------
Copyright (C) 1994-2020 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 v5.0.1, bugfix; eliminate &referer= XSS vulnerability
06-OCT-2014 MGD v5.0.0, although now largely only of historical interest ...
... a nod to the twenty-first century
(and happy 90th birthday Dad)
10-MAY-2005 MGD v4.7.8, SWS 2.0 ignore query string components supplied as
command-line parameters differently to CSWS 1.2/3
23-DEC-2003 MGD v4.7.7, minor conditional mods to support IA64
27-APR-2003 MGD v4.7.6, change DEFAULT_ICON to all lower-case for CSWS
12-APR-2003 MGD v4.7.5, link colour changed to 0000cc
20-AUG-2002 MGD v4.7.4, allow for HTTP/1.1 'Cache-control:' field used
by Mozilla variants (instead of HTTP/1.0 'pragma:')
15-AUG-2002 MGD v4.7.3, make MFD ('000000') suppression WASD-only
30-JUN-2002 MGD v4.7.2, bugfix; link path in ProcessShelf()
01-JUL-2001 MGD v4.7.1, add 'SkipParameters' for direct OSU support
28-OCT-2000 MGD v4.7.0, use CGILIB object module
31-AUG-2000 MGD v4.6.0, add URL as bookshelf entry type (good suggestion
Gerry..Czadowski@@nav-international..com)
18-JAN-2000 MGD v4.5.0, support extended file specifications (ODS-5)
07-AUG-1999 MGD v4.4.0, use more of the CGILIB functionality
24-APR-1999 MGD v4.3.0, use CGILIB.C,
standard CGI environment (Netscape FastTrack)
02-OCT-1998 MGD v4.2.0, provide content-type "; charset=..."
27-AUG-1998 MGD v4.1.1, iteratively translate DECW$BOOK translations
08-AUG-1998 MGD v4.1.0, refinements in shelf and library parsing,
OSU output processing reworked,
bugfix; TimeSetTimezone() 'Seconds' unsigned->signed
06-AUG-1998 MGD v4.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 v4.0.1, suppress table background colours if empty,
accomodations for OSU environment
29-APR-1998 MGD v4.0.0, remove the need for WASD MapUrl() functions
(making it a GENERIC CGI script!!),
some tidying up and cosmetic changes
26-FEB-1998 MGD v3.3.5, TimeSetGmt() modified to be in line with HTTPd
06-NOV-1997 MGD v3.3.4, discovered "hyperhelp" in latest 7.1 ODL
added "unknown" document type
19-AUG-1997 MGD v3.2.2, MapUrl() to MapUrl_Map() for conditional mapping
01-AUG-1997 MGD v3.2.1, 'HttpHasBeenOutput' not initialize for CGIplus
20-JUL-1997 MGD v3.2.0, added /BODY= qualifier, added Adobe PDF document type
07-JUL-1997 MGD v3.1.0, CGIplus capable
30-JUN-1997 MGD v3.0.0, major changes to support the BNU format shelves,
"Pragma: no-cache" now overrides "If-Modified-Since:"
16-MAY-1996 MGD v2.2.3, change all .XBMs to transparent .GIFs
23-FEB-1996 MGD v2.2.2, bugfix; after modifying the HTTPD$GMT format for the
HTTPd server I had forgotten about some scripts
22-NOV-1995 MGD v2.2.1, discovered the TITLE keyword in libraries
12-OCT-1995 MGD v2.2.0, add 'Referer:', 'Last-Modified:'/'If-Modified-Since:'
24-MAY-1995 MGD v2.1.0, minor changes for AXP compatibility
15-APR-1995 MGD v2.0.0, complete rewrite
10-JUN-1994 MGD v1.0.0, initial development
*/
/*****************************************************************************/
#define SOFTWAREVN "5.0.1"
#define SOFTWARENM "HYPERSHELF"
#define SOFTWARECR "Copyright (C) 1996-2014 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>
#include <unixio.h>
/* VMS-related header files */
#include <descrip.h>
#include <libdef.h>
#include <lnmdef.h>
#include <rms.h>
#include <ssdef.h>
#include <stsdef.h>
#include <syidef.h>
/* application header file */
#include "enamel.h"
#include "hyperreader.h"
#include <cgilib.h>
#ifndef __VAX
# pragma nomember_alignment
#endif
#define boolean int
#define true 1
#define false 0
#define FI_LI __FILE__, __LINE__
#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 VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) (!((x) & STS$M_SUCCESS))
#define DEFAULT_ICON "/hypershelf/-/"
char *BookshelfTypes [] = { ".ODL", ".BKS", ".DECW$BOOKSHELF", "" };
char OdlShelfDefaults [] =
"DECW$USER_DEFAULTS:LIBRARY.ODL, \
DECW$USER_DEFAULTS:CONTENTS.ODL, \
DECW$SYSTEM_DEFAULTS:LIBRARY.ODL, \
DECW$SYSTEM_DEFAULTS:CONTENTS.ODL";
#define DEFAULT_BUTTONS \
"↶Back=javascript:parent.history.go(-1)$\
Close$^Help=" DEFAULT_HYPERSHELF_HELP
char ErrorBookshelfType [] = "Doesn't look like a bookshelf type!";
char Utility [] = "HYPERSHELF";
boolean Debug,
DecwBookDefined,
DecwBookshelfDefined,
DoBnu,
DoBookreader,
ErrorReported,
IsCgiPlus,
StdCgiEnvironment,
PageBegun,
TimeAheadOfGmt,
WasdEnvironment;
unsigned long IfModifiedSinceBinaryTime [2],
TimeGmtDeltaBinary [2];
int BookshelfCount,
OdsExtended,
PrevBookshelfCount;
char ContentTypeCharset [64],
DefaultButtons [] = DEFAULT_BUTTONS,
DefaultStyle [] = DEFAULT_HYPERSHELF_STYLE,
LastModifiedGmDateTime [32],
HyperReaderReferer [512],
PrevTitle [256],
ShelfPath [ODS_MAX_FILE_NAME_LENGTH+1],
SoftwareID [48],
TimeGmtString [32],
TimeGmtVmsString [32],
UriReferer [512],
UriTitle [256],
ShelfSpec [ODS_MAX_FILE_NAME_LENGTH+1];
char *ButtonsPtr = DefaultButtons,
*CgiEnvironmentPtr,
*CgiFormFilePtr,
*CgiFormRefererPtr,
*CgiFormTitlePtr,
*CgiHttpCacheControlPtr,
*CgiHttpIfModifiedSincePtr,
*CgiHttpPragmaPtr,
*CgiPathInfoPtr,
*CgiPathTranslatedPtr,
*CgiRequestMethodPtr,
*CgiScriptNamePtr,
*CgiServerSoftwarePtr,
*CharsetPtr,
*CliCharsetPtr,
*HyperReaderScriptNamePtr,
*IconLocationPtr = DEFAULT_ICON,
*LibraryFileNamePtr = "",
*PrintScriptNamePtr = "",
*SoftwareCopy = SOFTWARECR,
*StyleSheetPtr = "";
/* required function prototypes */
char* VmsToPath (char*, char*);
char* ButtonBarButton (char*, char*);
char* XSSuspect (char*);
/*****************************************************************************/
/*
'argc' and 'argv' are only required to support CgiLibEnvironmentInit(), in
particular the OSU environment.
*/
main
(
int argc,
char *argv[]
)
{
/*********/
/* begin */
/*********/
sprintf (SoftwareID, "%s (%s)", SOFTWAREID, CgiLibEnvironmentVersion());
if (getenv ("HYPERSHELF$DBUG")) Debug = true;
CgiLibEnvironmentSetDebug (Debug);
CgiLibEnvironmentInit (argc, argv, false);
WasdEnvironment = CgiLibEnvironmentIsWasd();
GetParameters ();
CgiLibResponseSetCharset (CliCharsetPtr);
CgiLibResponseSetSoftwareID (SoftwareID);
CgiLibResponseSetErrorMessage ("Reported by HyperShelf");
if (StyleSheetPtr[0])
{
char *cptr = calloc (1, 64+strlen(StyleSheetPtr));
sprintf (cptr, "<link rel=\"stylesheet\" \
type=\"text/css\" href=\"%s\">\n",
StyleSheetPtr);
StyleSheetPtr = cptr;
}
#ifdef ODS_EXTENDED
OdsExtended = (GetVmsVersion() >= 72);
ENAMEL_NAML_SANITY_CHECK
#endif /* ODS_EXTENDED */
/* if not CLI set and old bookreader logicals then bookreader */
DecwBookDefined = (boolean)(getenv ("DECW$BOOK"));
DecwBookshelfDefined = (boolean)(getenv ("DECW$BOOKSHELF"));
if (!(DoBnu || DoBookreader) && (DecwBookDefined || DecwBookshelfDefined))
{
DoBookreader = true;
DoBnu = false;
}
else
{
DoBnu = true;
DoBookreader = false;
}
if (Debug)
fprintf (stdout,
"DecwBookDefined: %d DecwBookshelfDefined: %d DoBookreader: %d DoBnu: %d\n",
DecwBookDefined, DecwBookshelfDefined, DoBookreader, DoBnu);
IsCgiPlus = CgiLibEnvironmentIsCgiPlus ();
if (IsCgiPlus)
{
for (;;)
{
/* block waiting for the next request */
CgiLibVar ("");
if (Debug) fputs ("Content-Type: text/plain\n\n", stdout);
ProcessRequest ();
CgiLibCgiPlusEOF ();
}
}
else
ProcessRequest ();
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 ("HYPERSHELF$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, "/DBUG", -1))
{
Debug = true;
continue;
}
if (strsame (aptr, "/BNU", -1))
{
DoBookreader = false;
DoBnu = true;
continue;
}
if (strsame (aptr, "/BOOKREADER", 4))
{
DoBookreader = true;
DoBnu = false;
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, "/HYPERREADER=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
HyperReaderScriptNamePtr = cptr;
continue;
}
if (strsame (aptr, "/ICON=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
IconLocationPtr = cptr;
continue;
}
if (strsame (aptr, "/LIBRARY=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
LibraryFileNamePtr = cptr;
continue;
}
if (strsame (aptr, "/ODS5", 5))
{
OdsExtended = true;
continue;
}
if (strsame (aptr, "/NOODS5", 7))
{
OdsExtended = false;
continue;
}
if (strsame (aptr, "/PRINT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
PrintScriptNamePtr = cptr;
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);
}
}
}
/*****************************************************************************/
/*
*/
ProcessRequest ()
{
int status,
idx;
char c;
char *cptr, *sptr,
*ShelfFilePtr;
char ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1],
ResFileName [ODS_MAX_FILE_NAME_LENGTH+1],
Scratch [256],
SearchDefault [ODS_MAX_FILE_NAME_LENGTH+1];
struct FAB SearchFab;
#ifdef ODS_EXTENDED
struct NAML SearchNaml;
#endif /* ODS_EXTENDED */
struct NAM SearchNam;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ProcessRequest()\n");
CgiEnvironmentPtr = CgiLibEnvironmentName ();
ErrorReported = false;
CgiServerSoftwarePtr = CgiLibVar ("WWW_SERVER_SOFTWARE");
CgiRequestMethodPtr = CgiLibVar ("WWW_REQUEST_METHOD");
if (strcmp (CgiRequestMethodPtr, "GET"))
{
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");
CgiHttpCacheControlPtr = CgiLibVar ("WWW_HTTP_CACHE_CONTROL");
CgiHttpPragmaPtr = CgiLibVar ("WWW_HTTP_PRAGMA");
CgiFormTitlePtr = CgiLibVar ("WWW_FORM_TITLE");
CgiFormFilePtr = CgiLibVar ("WWW_FORM_FILE");
if (!CgiFormFilePtr[0]) CgiFormFilePtr = CgiLibVar ("WWW_FORM_SHELF");
if (VMSnok (status = TimeSetGmt ()))
{
if (status != SS$_NOLOGNAM)
{
CgiLibResponseError (FI_LI, status, "GMT offset");
return;
}
}
CgiHttpIfModifiedSincePtr = CgiLibVar ("WWW_HTTP_IF_MODIFIED_SINCE");
if (CgiHttpIfModifiedSincePtr[0])
{
if (VMSnok (HttpGmTime (CgiHttpIfModifiedSincePtr,
&IfModifiedSinceBinaryTime)))
{
if (Debug) fprintf (stdout, "If-Modified-Since: NBG!\n");
IfModifiedSinceBinaryTime[0] = IfModifiedSinceBinaryTime[0] = 0;
CgiHttpIfModifiedSincePtr = "";
}
}
if (!HyperReaderScriptNamePtr)
{
if (CgiLibEnvironmentIsWasd() ||
CgiLibEnvironmentIsCgiPlus())
HyperReaderScriptNamePtr = DEFAULT_WASD_HYPERREADER;
else
if (CgiLibEnvironmentIsOsu())
HyperReaderScriptNamePtr = DEFAULT_OSU_HYPERREADER;
else
HyperReaderScriptNamePtr = DEFAULT_CGI_HYPERREADER;
}
if (CgiPathInfoPtr[0] == '/' && !CgiPathInfoPtr[1])
CgiPathInfoPtr = CgiPathTranslatedPtr = "";
if (!CgiFormTitlePtr[0]) CgiFormTitlePtr = "Library";
CgiFormRefererPtr = CgiLibVar ("WWW_FORM_REFERER");
if (!CgiFormRefererPtr[0])
CgiFormRefererPtr = CgiLibVar ("WWW_HTTP_REFERER");
if (cptr = XSSuspect (CgiFormRefererPtr))
{
CgiLibResponseError (FI_LI, 0, cptr);
return;
}
if (CgiFormRefererPtr[0])
{
/* re-escape the URL-escaped percentages */
CgiLibUrlEncode (CgiFormRefererPtr, -1, UriReferer, -1);
}
else
UriReferer[0] = '\0';
ShelfSpec[0] = '\0';
if (!ShelfSpec[0]) strcpy (ShelfSpec, CgiFormFilePtr);
if (!ShelfSpec[0]) strcpy (ShelfSpec, CgiPathTranslatedPtr);
if (!ShelfSpec[0]) strcpy (ShelfSpec, LibraryFileNamePtr);
if (Debug) fprintf (stdout, "ShelfSpec |%s|\n", ShelfSpec);
if (ShelfSpec[0])
{
/* find file type (extension) */
for (cptr = ShelfSpec; *cptr; cptr++);
if (*(cptr-1) == ';') *(cptr-1) = '\0';
while (cptr > ShelfSpec && *cptr != '.' &&
*cptr != ']' && *cptr != ':') cptr--;
if (*cptr == '.')
{
/* check if looks like a bookshelf file type */
for (idx = 0; BookshelfTypes[idx][0]; idx++)
{
if (Debug) fprintf (stdout, "|%s|%s|\n", BookshelfTypes[idx], cptr);
if (strsame (BookshelfTypes[idx], cptr, -1)) break;
}
if (!BookshelfTypes[idx][0])
{
CgiLibResponseError (FI_LI, 0, ErrorBookshelfType);
return;
}
}
}
PageBegun = false;
BookshelfCount = PrevBookshelfCount = 0;
if (DoBookreader)
{
/**************/
/* Bookreader */
/**************/
idx = 0;
for (;;)
{
SearchFab = cc$rms_fab;
if (ShelfSpec[0])
{
SearchFab.fab$l_dna = "DECW$BOOK:.DECW$BOOKSHELF";
SearchFab.fab$b_dns = 25;
}
else
{
if (DecwBookshelfDefined)
{
SysTrnLnm ("DECW$BOOKSHELF", idx++, SearchDefault);
if (!SearchDefault[0]) break;
}
else
{
SysTrnLnm ("DECW$BOOK", idx++, SearchDefault);
if (!SearchDefault[0]) break;
for (;;)
{
SysTrnLnm (SearchDefault, 0, Scratch);
if (!Scratch[0]) break;
strcpy (SearchDefault, Scratch);
}
strcat (SearchDefault,"LIBRARY.*;");
}
SearchFab.fab$l_dna = SearchDefault;
SearchFab.fab$b_dns = strlen(SearchDefault);
}
SearchFab.fab$b_shr = FAB$M_SHRGET;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
SearchFab.fab$l_fna = (char*)-1;
SearchFab.fab$b_fns = 0;
SearchFab.fab$l_nam = (struct namdef*)&SearchNaml;
ENAMEL_RMS_NAML(SearchNaml)
SearchNaml.naml$l_long_filename = ShelfSpec;
SearchNaml.naml$l_long_filename_size = strlen(ShelfSpec);
SearchNaml.naml$l_long_expand = ExpFileName;
SearchNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
SearchNaml.naml$l_long_result = ResFileName;
SearchNaml.naml$l_long_result_alloc = sizeof(ResFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
SearchFab.fab$l_fna = ShelfSpec;
SearchFab.fab$b_fns = strlen(ShelfSpec);
SearchFab.fab$l_nam = &SearchNam;
SearchNam = cc$rms_nam;
SearchNam.nam$l_esa = ExpFileName;
SearchNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
SearchNam.nam$l_rsa = ResFileName;
SearchNam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
status = sys$parse (&SearchFab, 0, 0);
if (Debug) fprintf (stdout, "sys$parse() %%X%08.08X\n", status);
if (VMSnok (status))
{
/* subsequent translations ignore directories not being there! */
if (status == RMS$_DNF && idx > 0) continue;
if (ShelfSpec[0])
cptr = ShelfSpec;
else
cptr = SearchFab.fab$l_dna;
CgiLibResponseError (FI_LI, status, cptr);
return (status);
}
#ifdef ODS_EXTENDED
if (OdsExtended)
SearchNaml.naml$l_long_ver[SearchNaml.naml$l_long_ver_size] = '\0';
else
#endif /* ODS_EXTENDED */
SearchNam.nam$l_ver[SearchNam.nam$b_ver] = '\0';
if (Debug)
fprintf (stdout, "ExpFileName |%s|\n", ExpFileName);
status = sys$search (&SearchFab, 0, 0);
if (Debug) fprintf (stdout, "sys$search() %%X%08.08X\n", status);
if (VMSok (status))
{
#ifdef ODS_EXTENDED
if (OdsExtended)
*SearchNaml.naml$l_long_ver = '\0';
else
#endif /* ODS_EXTENDED */
*SearchNam.nam$l_ver = '\0';
if (Debug) fprintf (stdout, "ResFileName |%s|\n", ResFileName);
status = ProcessShelf (ResFileName);
if (Debug) fprintf (stdout, "ProcessShelf() %%X%08.08X\n", status);
}
if (status == RMS$_NMF) status = SS$_NORMAL;
if (VMSnok (status))
{
if (ShelfSpec[0])
cptr = ShelfSpec;
else
cptr = SearchFab.fab$l_dna;
CgiLibResponseError (FI_LI, status, cptr);
return (SS$_NORMAL);
}
/* continue to go through this rigmoral only if no shelf specified! */
if (ShelfSpec[0]) break;
}
}
else
{
/*******/
/* BNU */
/*******/
ShelfFilePtr = OdlShelfDefaults;
while (*ShelfFilePtr)
{
cptr = ShelfFilePtr;
while (*cptr == ' ' || *cptr == ',') cptr++;
if (!*cptr) break;
if (Debug) fprintf (stdout, "cptr |%s|\n", cptr);
ShelfFilePtr = cptr;
while (*cptr && *cptr != ' ' && *cptr != ',') cptr++;
c = *cptr;
SearchFab = cc$rms_fab;
SearchFab.fab$l_dna = ShelfFilePtr;
SearchFab.fab$b_dns = cptr - ShelfFilePtr;
SearchFab.fab$b_shr = FAB$M_SHRGET;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
SearchFab.fab$l_fna = (char*)-1;
SearchFab.fab$b_fns = 0;
SearchFab.fab$l_nam = (struct namdef*)&SearchNaml;
ENAMEL_RMS_NAML(SearchNaml)
SearchNaml.naml$l_long_filename = ShelfSpec;
SearchNaml.naml$l_long_filename_size = strlen(ShelfSpec);
SearchNaml.naml$l_long_expand = ExpFileName;
SearchNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
SearchNaml.naml$l_long_result = ResFileName;
SearchNaml.naml$l_long_result_alloc = sizeof(ResFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
SearchFab.fab$l_fna = ShelfSpec;
SearchFab.fab$b_fns = strlen(ShelfSpec);
SearchFab.fab$l_nam = &SearchNam;
SearchNam = cc$rms_nam;
SearchNam.nam$l_esa = ExpFileName;
SearchNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
SearchNam.nam$l_rsa = ResFileName;
SearchNam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
if (VMSnok (status = sys$parse (&SearchFab, 0, 0)))
{
if (ShelfSpec[0])
CgiLibResponseError (FI_LI, status, ShelfSpec);
else
CgiLibResponseError (FI_LI, status, ShelfFilePtr);
*cptr = c;
return (status);
}
*(ShelfFilePtr = cptr) = c;
#ifdef ODS_EXTENDED
if (OdsExtended)
SearchNaml.naml$l_long_ver[SearchNaml.naml$l_long_ver_size] = '\0';
else
#endif /* ODS_EXTENDED */
SearchNam.nam$l_ver[SearchNam.nam$b_ver] = '\0';
if (Debug)
fprintf (stdout, "ExpFileName |%s|\n", ExpFileName);
status = sys$search (&SearchFab, 0, 0);
if (Debug) fprintf (stdout, "sys$search() %%X%08.08X\n", status);
if (VMSok (status))
{
#ifdef ODS_EXTENDED
if (OdsExtended)
*SearchNaml.naml$l_long_ver = '\0';
else
#endif /* ODS_EXTENDED */
*SearchNam.nam$l_ver = '\0';
if (Debug) fprintf (stdout, "ResFileName |%s|\n", ResFileName);
status = ProcessShelf (ResFileName);
if (Debug) fprintf (stdout, "ProcessShelf() %%X%08.08X\n", status);
break;
}
/* try with the next combination of defaults (if any) */
if (status == RMS$_FNF) continue;
if (status == RMS$_DNF) continue;
break;
}
if (!*ShelfFilePtr)
{
status = RMS$_FNF;
CgiLibResponseError (FI_LI, status, OdlShelfDefaults);
return (status);
}
else
{
if (VMSnok (status))
{
if (ShelfSpec[0])
cptr = ShelfSpec;
else
cptr = ExpFileName;
CgiLibResponseError (FI_LI, status, cptr);
return (status);
}
}
}
if (BookshelfCount) fprintf (stdout, "</table>\n");
if (VMSok (status) && BookshelfCount)
{
ButtonBar (2);
fprintf (stdout, "</body>\n</html>\n");
}
else
if (VMSnok (status))
{
if (ShelfSpec[0])
cptr = ShelfSpec;
else
{
#ifdef ODS_EXTENDED
if (OdsExtended)
SearchNaml.naml$l_long_ver[SearchNaml.naml$l_long_ver_size] = '\0';
else
#endif /* ODS_EXTENDED */
SearchNam.nam$l_ver[SearchNam.nam$b_ver] = '\0';
cptr = ExpFileName;
}
CgiLibResponseError (FI_LI, status, cptr);
}
/* release any parse and search internal data structures (for CGIplus) */
SearchFab.fab$l_fna = "a:[b]c.d;";
SearchFab.fab$b_fns = 9;
SearchFab.fab$b_dns = 0;
#ifdef ODS_EXTENDED
if (OdsExtended)
SearchNaml.naml$b_nop = NAM$M_SYNCHK;
else
#endif /* ODS_EXTENDED */
SearchNam.nam$b_nop = NAM$M_SYNCHK;
sys$parse (&SearchFab, 0, 0);
}
/*****************************************************************************/
/*
Open the supplied shelf file name. Read each line in the file parsing the
entry type (shelf or book), the file specification, and entry description
(title of shelf or book). Close the file.
*/
int ProcessShelf (char* ShelfFileName)
{
boolean IsDecwShelf,
IsOdlShelf,
IsSameAsPrevTitle;
int status,
idx,
LineCount,
LineOutputCount;
char ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1],
FileName [ODS_MAX_FILE_NAME_LENGTH+1],
HtmlTitle [256],
Line [256],
LinkPath [ODS_MAX_FILE_NAME_LENGTH+1],
Scratch [ODS_MAX_FILE_NAME_LENGTH*2],
ShelfDirectory [ODS_MAX_FILE_NAME_LENGTH+1],
Title [256],
Type [256],
VmsLinkPath [ODS_MAX_FILE_NAME_LENGTH+1];
char *cptr, *sptr, *zptr,
*ExpDevicePtr,
*ExpNodePtr,
*ExpNamePtr,
*ExpTypePtr,
*PossibleOdlShelfTitlePtr;
struct FAB ShelfFab;
#ifdef ODS_EXTENDED
struct NAML ShelfNaml;
#endif /* ODS_EXTENDED */
struct NAM ShelfNam;
struct RAB ShelfRab;
struct XABDAT ShelfXabDat;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ProcessShelf() |%s|\n", ShelfFileName);
ShelfFab = cc$rms_fab;
ShelfFab.fab$b_fac = FAB$M_GET;
ShelfFab.fab$b_shr = FAB$M_SHRGET;
ShelfFab.fab$l_xab = &ShelfXabDat;
ShelfXabDat = cc$rms_xabdat;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
ShelfFab.fab$l_fna = (char*)-1;
ShelfFab.fab$b_fns = 0;
ShelfFab.fab$l_nam = (struct namdef*)&ShelfNaml;
ENAMEL_RMS_NAML(ShelfNaml)
ShelfNaml.naml$l_long_filename = ShelfFileName;
ShelfNaml.naml$l_long_filename_size = strlen(ShelfFileName);
ShelfNaml.naml$l_long_expand = ExpFileName;
ShelfNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
ShelfFab.fab$l_fna = ShelfFileName;
ShelfFab.fab$b_fns = strlen(ShelfFileName);
ShelfFab.fab$l_nam = &ShelfNam;
ShelfNam = cc$rms_nam;
ShelfNam.nam$l_esa = ExpFileName;
ShelfNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
}
status = sys$open (&ShelfFab, 0, 0);
if (VMSnok (status))
{
if (Debug) fprintf (stdout, "sys$open() %%X%08.08X\n", status);
if (ShelfSpec[0])
cptr = ShelfSpec;
else
cptr = ShelfFileName;
CgiLibResponseError (FI_LI, status, cptr);
return (status);
}
#ifdef ODS_EXTENDED
if (OdsExtended)
{
ExpNodePtr = ShelfNaml.naml$l_long_node;
ExpDevicePtr = ShelfNaml.naml$l_long_dev;
ExpNamePtr = ShelfNaml.naml$l_long_name;
ExpTypePtr = ShelfNaml.naml$l_long_type;
*ShelfNaml.naml$l_long_ver = '\0';
}
else
#endif /* ODS_EXTENDED */
{
ExpNodePtr = ShelfNam.nam$l_node;
ExpDevicePtr = ShelfNam.nam$l_dev;
ExpNamePtr = ShelfNam.nam$l_name;
ExpTypePtr = ShelfNam.nam$l_type;
*ShelfNam.nam$l_ver = '\0';
}
if (Debug) fprintf (stdout, "|%s|\n", ExpFileName);
/* don't last-modified check if using DECW$BOOK to search for libraries */
if ((ShelfSpec[0] ||
DoBnu) &&
!DecwBookshelfDefined)
{
if (CgiHttpIfModifiedSincePtr[0])
{
if (VMSnok (ModifiedSince (&IfModifiedSinceBinaryTime,
&ShelfXabDat.xab$q_rdt)))
{
/* book has not been modified since the date/time, don't send */
sys$close (&ShelfFab, 0, 0);
return (STS$K_ERROR);
}
}
}
HttpGmTimeString (LastModifiedGmDateTime, &ShelfXabDat.xab$q_rdt);
ShelfRab = cc$rms_rab;
ShelfRab.rab$l_fab = &ShelfFab;
/* 2 buffers and read ahead performance option */
ShelfRab.rab$b_mbf = 2;
ShelfRab.rab$l_rop = RAB$M_RAH;
ShelfRab.rab$l_ubf = Line;
ShelfRab.rab$w_usz = sizeof(Line)-1;
if (VMSnok (status = sys$connect (&ShelfRab, 0, 0)))
{
if (Debug) fprintf (stdout, "sys$connect() %%X%08.08X\n", status);
sys$close (&ShelfFab, 0, 0);
if (ShelfSpec[0])
cptr = ShelfSpec;
else
cptr = ShelfFileName;
CgiLibResponseError (FI_LI, status, cptr);
return (status);
}
/* convert the VMS file path into a slash-separated, sort-of equivalent */
VmsToPath (ShelfPath, ExpFileName);
if (Debug) fprintf (stdout, "|%s|\n", ExpTypePtr);
IsDecwShelf = IsOdlShelf = false;
if (!strcmp (ExpTypePtr, ".ODL"))
IsOdlShelf = true;
else
IsDecwShelf = true;
if (++BookshelfCount == 1)
{
/********************/
/* first/only shelf */
/********************/
sptr = HyperReaderReferer;
sptr += CgiLibUrlEncode (CgiScriptNamePtr, -1, sptr, -1);
if (CgiPathInfoPtr[0] != '/') *sptr++ = '/';
sptr += CgiLibUrlEncode (CgiPathInfoPtr, -1, sptr, -1);
sptr += CgiLibUrlEncode ("?title=", -1, sptr, -1);
/*
This escapes the escape percentages leaving the URI still escaped
when the script (HyperReader) receives it at the other end :^)
*/
CgiLibUrlEncode (CgiFormTitlePtr, -1, Scratch, -1);
sptr += CgiLibUrlEncode (Scratch, -1, sptr, -1);
sptr += CgiLibUrlEncode ("&referer=", -1, sptr, -1);
sptr += CgiLibUrlEncode (UriReferer, -1, sptr, -1);
*sptr = '\0';
if (Debug)
fprintf (stdout, "HyperReaderReferer |%s|\n", HyperReaderReferer);
/***************/
/* HTTP header */
/***************/
CgiLibResponseHeader (200, "text/html",
"Last-Modified: %s\n", LastModifiedGmDateTime);
}
/****************/
/* file records */
/****************/
LineCount = LineOutputCount = 0;
HtmlTitle[0] = PrevTitle[0] = UriTitle[0] = '\0';
while (VMSok (status = sys$get (&ShelfRab, 0, 0)))
{
LineCount++;
Line[ShelfRab.rab$w_rsz] = '\0';
if (Debug) fprintf (stdout, "Line |%s|\n", Line);
if (!Line[0]) continue;
/********************/
/* parse components */
/********************/
cptr = Line;
if ((cptr[0] == '#' && cptr[1] == '#' && isalpha(cptr[2])) ||
(cptr[0] == '!' && cptr[1] == '!' && isalpha(cptr[2])))
cptr += 2;
/* ignore unknown line types */
if (!isalpha(*cptr)) continue;
Type[0] = FileName[0] = Title[0] = '\0';
sptr = Type;
while (*cptr && isspace(*cptr)) cptr++;
if (IsOdlShelf)
{
while (*cptr && !isspace(*cptr)) *sptr++ = toupper(*cptr++);
*sptr = '\0';
while (*cptr && isspace(*cptr)) cptr++;
}
else
{
while (*cptr && *cptr != '\\' && !isspace(*cptr))
*sptr++ = toupper(*cptr++);
*sptr = '\0';
while (*cptr && isspace(*cptr)) cptr++;
if (*cptr == '\\') cptr++;
while (*cptr && isspace(*cptr)) cptr++;
}
PossibleOdlShelfTitlePtr = cptr;
if (IsOdlShelf)
{
sptr = FileName;
while (*cptr && !isspace(*cptr))
{
*sptr++ = *cptr++;
if (*cptr == '%')
{
*sptr++ = '2';
*sptr++ = '5';
}
}
*sptr = '\0';
while (*cptr && isspace(*cptr)) cptr++;
}
else
{
/* check if this specification has device and directory components */
for (zptr = cptr;
*zptr && *zptr != ':' && *zptr != '[' && *zptr != '/' &&
*zptr != '\\' && !isspace(*zptr);
zptr++);
if (*zptr == ':' || *zptr == '[' || *zptr == '/')
{
/* includes directory components, straight-up copy */
sptr = FileName;
while (*cptr && *cptr != '\\' && !isspace(*cptr))
*sptr++ = tolower(*cptr++);
*sptr = '\0';
}
else
{
/* use the device and directory of the current shelf */
sptr = FileName;
for (zptr = ExpNodePtr;
zptr < ExpNamePtr;
*sptr++ = tolower(*zptr++));
while (*cptr && *cptr != '\\' && !isspace(*cptr))
*sptr++ = tolower(*cptr++);
*sptr = '\0';
}
while (*cptr && isspace(*cptr)) cptr++;
if (*cptr == '\\') cptr++;
while (*cptr && isspace(*cptr)) cptr++;
}
sptr = Title;
while (*cptr) *sptr++ = *cptr++;
*sptr = '\0';
/***************/
/* shelf title */
/***************/
if (Type[0] == 'T' && strsame (Type, "TITLE", -1))
{
/* title of this shelf */
if (IsOdlShelf)
{
sptr = Title;
for (cptr = PossibleOdlShelfTitlePtr; *cptr; *sptr++ = *cptr++);
*sptr = '\0';
cptr = "ODL";
}
else
cptr = "DECW$BOOKSHELF";
if (!Title[0])
sprintf (Title, "[Unable to parse %s shelf title (line %d)]",
cptr, LineCount);
if (Debug) fprintf (stdout, "TITLE |%s|\n", Title);
if (!HtmlTitle[0])
{
CgiLibHtmlEscape (Title, -1, HtmlTitle, -1);
CgiLibUrlEncode (Title, -1, UriTitle, -1);
}
}
if (BookshelfCount == 1)
{
/***********************************/
/* first/only shelf ... page title */
/***********************************/
if (!PageBegun)
{
BeginPage (HtmlTitle);
PageBegun = true;
}
}
if (BookshelfCount == 1 && BookshelfCount != PrevBookshelfCount)
{
/* note that we are now working on a new bookshelf file */
PrevBookshelfCount = BookshelfCount;
fprintf (stdout, "<!-- %s -->\n", ExpFileName);
}
if (BookshelfCount > 1)
{
/* Bookreader type search list through libraries */
if (Type[0] == 'T' && strsame (Type, "TITLE", -1)) break;
continue;
}
if (Type[0] == 'T' && strsame (Type, "TITLE", -1)) continue;
/*********************/
/* shelf or document */
/*********************/
CgiLibHtmlEscape (Title, -1, HtmlTitle, -1);
CgiLibUrlEncode (Title, -1, UriTitle, -1);
if (strsame (Title, PrevTitle, -1) || strsame (Title, "ditto", 5))
IsSameAsPrevTitle = true;
else
IsSameAsPrevTitle = false;
LinkPath[0] = VmsLinkPath[0] = '\0';
if (FileName[0])
{
if (IsOdlShelf)
{
/*************/
/* ODL shelf */
/*************/
if (FileName[0] == '%')
{
/* full path was specified */
sptr = LinkPath;
for (cptr = "/disk$"; *cptr; *sptr++ = *cptr++);
for (cptr = FileName+1; *cptr; *sptr++ = tolower(*cptr++));
*sptr = '\0';
}
else
if (FileName[0] == '/')
{
/* full path was specified */
sptr = LinkPath;
for (cptr = FileName; *cptr; *sptr++ = tolower(*cptr++));
*sptr = '\0';
}
else
{
sptr = LinkPath;
for (cptr = CgiPathInfoPtr; *cptr; *sptr++ = *cptr++);
*sptr = '\0';
while (*sptr != '/' && sptr > LinkPath) sptr--;
if (*sptr == '/') sptr++;
for (cptr = FileName; *cptr; *sptr++ = tolower(*cptr++));
*sptr = '\0';
}
if (Debug) fprintf (stdout, "LinkPath |%s|\n", LinkPath);
}
else
{
/************************/
/* DECW$BOOKSHELF shelf */
/************************/
strcpy (VmsLinkPath, FileName);
}
}
if (Debug)
fprintf (stdout, "|%s|%s|%s|\n", FileName, LinkPath, VmsLinkPath);
/*******************/
/* output the HTML */
/*******************/
LineOutputCount++;
fprintf (stdout, "<tr><td>\n");
if (!Type[0] || !FileName[0])
fprintf (stdout, "ERROR-IN-SHELF-ENTRY: Line %d", LineCount);
else
if (Type[0] == 'S' && strsame (Type, "SHELF", -1))
{
/*********/
/* shelf */
/*********/
if (IsOdlShelf)
ItemLink (UriTitle, CgiScriptNamePtr, LinkPath, ".odl",
"shelf.gif", " _|\\_");
else
ItemLink (UriTitle, CgiScriptNamePtr, VmsLinkPath,
".decw$bookshelf", "shelf.gif", "_|\\_");
}
else
if (Type[0] == 'B' && strsame (Type, "BOOK", -1))
{
/********/
/* book */
/********/
if (!Title[0] || IsSameAsPrevTitle)
strcpy (HtmlTitle, "<FONT SIZE=-1><I>(Bookreader version)</I></FONT>");
if (IsOdlShelf)
ItemLink (UriTitle, HyperReaderScriptNamePtr, LinkPath,
".bkb", "book.gif", "[}{]");
else
ItemLink (UriTitle, HyperReaderScriptNamePtr, VmsLinkPath,
".decw$book", "book.gif", "[}{]");
}
else
if (Type[0] == 'H' && strsame (Type, "HTML", -1))
{
/****************/
/* HTML version */
/****************/
if (!Title[0] || IsSameAsPrevTitle)
strcpy (HtmlTitle, "<font size=-1><i>(html version)</i></font>");
/* convert the VMS file path into a sort-of URL equivalent */
if (VmsLinkPath[0]) VmsToPath (LinkPath, VmsLinkPath);
if (IsOdlShelf) cptr = ".htm"; else cptr = ".html";
ItemLink (NULL, "", LinkPath, cptr, "html.gif", "[htm]");
}
else
if (Type[0] == 'P' && strsame (Type, "PDF", -1))
{
/*********************************************/
/* Adobe PDF version (HyperReader extension) */
/*********************************************/
if (!Title[0] || IsSameAsPrevTitle)
strcpy (HtmlTitle, "<font size=-1><i>(pdf version)</i></font>");
/* convert the VMS file path into a sort-of URL equivalent */
if (VmsLinkPath[0]) VmsToPath (LinkPath, VmsLinkPath);
ItemLink (NULL, "", LinkPath, ".pdf", "pdf.gif", "[pdf]");
}
else
if (Type[0] == 'P' && strsame (Type, "PLAIN", -1))
{
/**********************************************/
/* plain-text version (HyperReader extension) */
/**********************************************/
if (!Title[0] || IsSameAsPrevTitle)
strcpy (HtmlTitle,
"<font size=-1><i>(plain-text version)</i></font>");
/* convert the VMS file path into a sort-of URL equivalent */
if (VmsLinkPath[0]) VmsToPath (LinkPath, VmsLinkPath);
ItemLink (NULL, "", LinkPath, ".txt", "plain.gif", "[txt]");
if (PrintScriptNamePtr[0])
ItemLink (NULL, PrintScriptNamePtr, LinkPath, ".txt",
"print.gif", "[prn]");
}
else
if ((Type[0] == 'P' && strsame (Type, "POST", 4)) ||
(Type[0] == 'P' && strsame (Type, "PS", -1)))
{
/**********************************************/
/* PostScript version (HyperReader extension) */
/**********************************************/
if (!Title[0] || IsSameAsPrevTitle)
strcpy (HtmlTitle, "<font size=-1><i>(PostScript version)</i></font>");
/* convert the VMS file path into a sort-of URL equivalent */
if (VmsLinkPath[0]) VmsToPath (LinkPath, VmsLinkPath);
ItemLink (NULL, "", LinkPath, ".ps", "ps.gif", "[.ps]");
if (PrintScriptNamePtr[0])
ItemLink (NULL, PrintScriptNamePtr, LinkPath, ".ps",
"print.gif", "[prn]");
}
else
if (Type[0] == 'U' && strsame (Type, "URL", -1))
{
/*******************************************/
/* URL (HTML link - HyperReader extension) */
/*******************************************/
if (!Title[0]) strcpy (HtmlTitle, FileName);
ItemLink (NULL, "", FileName, NULL, "url.gif", "[url]");
}
else
{
/*****************/
/* unknown agent */
/*****************/
if (!Title[0] || IsSameAsPrevTitle)
strcpy (HtmlTitle, "<font size=-1><i>(ditto)</i></font>");
ItemLink (UriTitle, "", LinkPath, "", "unknown.gif", "[???]");
}
fprintf (stdout, "</td><td>%s</td></tr>\n", HtmlTitle);
strcpy (PrevTitle, Title);
}
/****************/
/* end of shelf */
/****************/
sys$close (&ShelfFab, 0, 0);
if (status == RMS$_EOF) status = SS$_NORMAL;
if (VMSnok (status))
{
CgiLibHtmlEscape (CgiFormTitlePtr, -1, HtmlTitle, -1);
if (HtmlTitle[0])
cptr = HtmlTitle;
else
cptr = CgiPathInfoPtr;
CgiLibResponseError (FI_LI, status, cptr);
return (status);
}
if (BookshelfCount > 1)
{
/************************************/
/* bookreader search list libraries */
/************************************/
if (BookshelfCount != PrevBookshelfCount)
{
/* note that we are now working on a new bookshelf file */
PrevBookshelfCount = BookshelfCount;
fprintf (stdout, "<!-- %s -->\n", ExpFileName);
}
if (LineCount)
{
fprintf (stdout, "<tr><td>\n");
if (IsOdlShelf)
ItemLink (UriTitle, CgiScriptNamePtr,
VmsToPath(NULL, ShelfFileName), ".odl",
"shelf.gif", " _|\\_");
else
{
for (cptr = ShelfFileName; *cptr; cptr++) *cptr = tolower(*cptr);
ItemLink (UriTitle, CgiScriptNamePtr, ShelfFileName,
".decw$bookshelf", "shelf.gif", "_|\\_");
}
if (HtmlTitle[0])
fprintf (stdout,
"</td><td> %s\
<font size=-1>[library]</font></td></tr>\n",
HtmlTitle);
else
fprintf (stdout,
"</td><td> library %d\
<font size=-1>[library]</font></td></tr>\n",
BookshelfCount);
}
else
fprintf (stdout,
"<tr><td></td><td> Empty bookshelf: <tt>%s</tt></td></tr>\n",
VmsToPath (NULL, ShelfFileName));
}
else
if (!LineOutputCount)
{
if (!PageBegun)
{
BeginPage (HtmlTitle);
PageBegun = true;
}
if (BookshelfCount != PrevBookshelfCount)
{
/* note that we are now working on a new bookshelf file */
PrevBookshelfCount = BookshelfCount;
fprintf (stdout, "<!-- %s -->\n", ExpFileName);
}
fprintf (stdout,
"<tr><td></td><td> Empty bookshelf: <tt>%s</tt></td></tr>\n",
VmsToPath (NULL, ShelfFileName));
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
*/
BeginPage (char *HtmlTitle)
{
char *cptr, *ShelfModePtr;
char UnixDateTime [32];
unsigned long UnixTime;
struct tm *UnixTmPtr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "BeginPage() |%s|\n", HtmlTitle);
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);
if (!HtmlTitle[0]) CgiLibHtmlEscape (CgiFormTitlePtr, -1, HtmlTitle, -1);
if (DoBnu) ShelfModePtr = "BNU"; else ShelfModePtr = "Bookreader";
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 (%s)\">\n\
<meta name=\"date\" content=\"%s\">\n\
<title>HyperShelf ... %s</title>\n\
<style type=\"text/css\">\n\
%s\
</style>\n\
%s\
</head>\n\
<body>\n",
SoftwareID, SoftwareCopy,
CgiEnvironmentPtr, ShelfModePtr, UnixDateTime,
HtmlTitle,
DefaultStyle,
StyleSheetPtr);
fprintf (stdout, "<div class=\"header\">%s</div>\n", HtmlTitle);
ButtonBar (1);
fflush (stdout);
fputs ("<table class=\"shelves\" border=\"0\" \
cellpadding=\"0\" cellspacing=\"2\">\n", stdout);
}
/*****************************************************************************/
/*
Create a link for a single shelf item.
*/
ItemLink
(
char *UriTitle,
char *ScriptNamePtr,
char *LinkPath,
char *DefaultType,
char *IconName,
char *AltText
)
{
char *cptr;
char EncodedLinkPath [ODS_MAX_FILE_NAME_LENGTH+64+1];
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "ItemLink() |%s|%s|%s|%s|%s|%s|\n",
UriTitle, ScriptNamePtr, LinkPath, DefaultType,
IconName, AltText);
if (!DefaultType)
{
/* default file type is specified as NULL, must be a raw URL */
fprintf (stdout,
"<a href=\"%s\"><img src=\"%s%s\" align=\"top\" alt=\"%s\"></a>\n",
LinkPath, IconLocationPtr, IconName, AltText);
return;
}
/* look for file type in specification */
for (cptr = LinkPath; *cptr; cptr++);
while (cptr > LinkPath && *cptr != '.'
&& *cptr != '/' && *cptr != ']' && *cptr != ':')
cptr--;
if (*cptr != '.')
{
/* no file type supplied, default to one! */
while (*cptr) cptr++;
strcat (LinkPath, DefaultType);
}
/* now scan backwards to check for likely VMS specification */
while (cptr > LinkPath && *cptr != '/' && *cptr != ']' && *cptr != ':')
cptr--;
if (*cptr == ']' || *cptr == ':')
{
/* link has VMS file specification */
CgiLibUrlEncodeFileName (LinkPath,
EncodedLinkPath, sizeof(EncodedLinkPath),
true, true);
if (!UriTitle)
{
fprintf (stdout,
"<a href=\"%s?file=%s\">\
<img src=\"%s%s\" align=\"top\" alt=\"%s\" border=\"0\"></a>\n",
ScriptNamePtr, EncodedLinkPath,
IconLocationPtr, IconName, AltText);
}
else
{
fprintf (stdout,
"<a href=\"%s?file=%s&title=%s&referer=%s\">\
<img src=\"%s%s\" align=\"top\" alt=\"%s\" border=\"0\"></a>\n",
ScriptNamePtr, EncodedLinkPath, UriTitle, UriReferer,
IconLocationPtr, IconName, AltText);
}
}
else
{
/* link has URL-style path */
CgiLibUrlEncode (LinkPath, -1,
EncodedLinkPath, sizeof(EncodedLinkPath));
if (!UriTitle)
{
fprintf (stdout,
"<a href=\"%s%s\">\
<img src=\"%s%s\" align=\"top\" alt=\"%s\" border=\"0\"></a>\n",
ScriptNamePtr, EncodedLinkPath,
IconLocationPtr, IconName, AltText);
}
else
{
fprintf (stdout,
"<a href=\"%s%s?title=%s&referer=%s\">\
<img src=\"%s%s\" align=\"top\" alt=\"%s\" border=\"0\"></a>\n",
ScriptNamePtr, EncodedLinkPath, UriTitle, UriReferer,
IconLocationPtr, IconName, AltText);
}
}
}
/*****************************************************************************/
/*
Create the navigation buttons.
*/
ButtonBar (int Top1Bottom2)
{
int idx;
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ButtonBar()\n");
fprintf (stdout, "<div class=\"buttonbar%s\">\n",
Top1Bottom2 == 1 ? " butbartop" : "");
cptr = ButtonsPtr;
/* back */
cptr = ButtonBarButton (cptr, NULL);
/* close */
if (CgiFormRefererPtr[0])
cptr = ButtonBarButton (cptr, CgiFormRefererPtr);
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);
}
/*****************************************************************************/
/*
*/
int SysTrnLnm
(
char *LogicalName,
int IndexNumber,
char *LogicalValue
)
{
static unsigned short Length;
static $DESCRIPTOR (LnmFileDevDsc, "LNM$FILE_DEV");
static $DESCRIPTOR (LogicalNameDsc, "");
static struct {
short int buf_len;
short int item;
void *buf_addr;
unsigned short *ret_len;
} LnmItems [] =
{
{ sizeof(int), LNM$_INDEX, 0, 0, },
{ 255, LNM$_STRING, 0, &Length },
{ 0,0,0,0 }
};
int status;
char *SignPtr;
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "SysTrnLnm() |%s| %d\n", LogicalName, IndexNumber);
LogicalValue[0] = '\0';
LogicalNameDsc.dsc$a_pointer = LogicalName;
LogicalNameDsc.dsc$w_length = strlen(LogicalName);
LnmItems[0].buf_addr = &IndexNumber;
LnmItems[1].buf_addr = LogicalValue;
status = sys$trnlnm (0, &LnmFileDevDsc, &LogicalNameDsc, 0, &LnmItems);
if (Debug) fprintf (stdout, "sys$trnlnm() %%X%08.08X\n", status);
if (VMSnok (status)) return (status);
LogicalValue[Length] = '\0';
if (Debug) fprintf (stdout, "LogicalValue |%s|\n", LogicalValue);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Convert a VMS file specification into a URL-style specification. For example:
"DEVICE:[DIR1.DIR2]FILE.TXT" into "/device/dir1/dir2/file.txt". OSU and Apache
environments require a MFD (i.e. 000000) to remain in a Unix-stlye
specification, whereas with WASD it's optional (and usually not present).
*/
char* VmsToPath
(
char *PathPtr,
char *VmsPtr
)
{
static char Path [ODS_MAX_FILE_NAME_LENGTH+1];
char *pptr, *vptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "VmsToPath() |%s|\n", VmsPtr);
vptr = VmsPtr;
if (!(pptr = PathPtr)) pptr = PathPtr = Path;
*pptr++ = '/';
/* copy the device and directory components */
while (*vptr)
{
if (*vptr == ':' && *(vptr+1) == '[')
{
vptr++;
vptr++;
/* remove any reference to a Master File Directory */
if (WasdEnvironment && strncmp (vptr, "000000", 6) == 0)
vptr += 6;
else
*pptr++ = '/';
}
if (*vptr == '.')
{
if (vptr[1] == '.' && vptr[2] == '.')
{
*pptr++ = '/';
*pptr++ = *vptr++;
*pptr++ = *vptr++;
*pptr++ = *vptr++;
}
else
{
vptr++;
*pptr++ = '/';
}
}
else
if (*vptr == ']')
{
vptr++;
*pptr++ = '/';
break;
}
else
*pptr++ = tolower(*vptr++);
}
/* copy the file component */
while (*vptr) *pptr++ = tolower(*vptr++);
*pptr++ = '\0';
*pptr = '\0';
if (Debug) fprintf (stdout, "PathPtr |%s|\n", PathPtr);
return (PathPtr);
}
/*****************************************************************************/
/*
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, "sys$add_times()");
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, "sys$sub_times()");
return (status);
}
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;
unsigned short Length;
unsigned short NumTime [7] = { 0,0,0,0,0,0,0 };
unsigned long DayOfWeek;
char *tptr;
/*********/
/* 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';
fputs (String, stdout);
}
BinTimePtr[0] = AdjustedTime[0];
BinTimePtr[1] = AdjustedTime[1];
return (status);
}
/****************************************************************************/
/*
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 unsigned 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);
}
/*****************************************************************************/