[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]
/*****************************************************************************/
/*
[WASD]Query.c
A CGI-compliant script to search plain-text and HTML files on ODS-2 and ODS-5
volumes. Extended file specifications may be expressed using either
RMS-escaped ("^_") or URL-escaped ("%nn") forbidden characters. If a version
delimiter (';', with or without version number) is present in the path
specification then this script displays and anchors RMS-escaped and VMS syntax
file names. If none is present it supplies URL-encoded file names.
Query works in concert with EXTRACT.C.
Accepts query-based searches (e.g. "/web/*.*?find+this+phrase") or form-based
fields briefly discussed below. By default searches the URL-supplied path, or
will use a path supplied with the "path=" query form field (via request
redirection to get the server to map the supplied path). A VMS directory
elipsis (i.e. "...") may be supplied in the path to result in a directory tree
search.
Hits in both plain-text files and HTML files provide a link to the extract
script. With plain text files the extract script extracts a section of the
file and presents it with some buttons to allow retrieving other sections or
all the document. When extracting HTML files it returns the entire document
but with each occurance of the hit enclosed by a '<span id="athitof1"></span>'
(yes, an oh not a zero) anchor that allows the specific hit to be jumped to
with relative document syntax. The following tags do not have any content
included: <applet></applet>, <head></head>, <script></script>,
<server></server>, <style></style>, <title></title>.
Using a script-name prefixed path such as "/query/web/.../*.*" returns a simple
form for generating a search.
"Text" file extensions are predefined in the DEFAULT_TEXT_TYPES and
DEFAULT_HTML_TYPES macros. To specify a custom list use /TEXT= and /HTML= or
to add other extensions to be considered text or HTML use /ADDTEXT= and
/ADDHTML= (not this is a comma-separated list with no extension period). File
extensions may contain the asterisk wildcard character, representing zero or
more matching characters (e.g. "REPORT_*").
NOTE ON EXTENDED FILE SPECS
---------------------------
This script is ODS-5 volume compliant and will process extended file naming
(excluding those using Unicode characters).
It's design allows building on VAX VMS (which excludes ODS-5 support) and Alpha
VMS all versions. When building on VAX all extended ODS code is "#ifdef"ed out
for efficiency reasons. If built under an Alpha version that does not support
extended naming the ENAMEL.H header file provides an equivalent
(a build allowed by the bogus NAML created by ENAMEL.H) then it
can only process ODS-2 file names, however if built with VMS 7.2ff it will
process both, and the object module can still be linked and used on an earlier
version (although without ODS-5 capabilities of course).
This Alpha backward/forward compatibility is provided at runtime by checking
the version of VMS it is currently executing under. If extended file
specification compliant then NAML structures are always used, otherwise NAMs.
Hence, a VMS version that doesn't know about extended file specifications (and
doesn't have any ODS-5 volumes of course) never gets passed a NAML!
LOGICAL NAMES
-------------
QUERY$DBUG turns on all "if (Debug)" statements
QUERY$PARAM equivalent to (overrides) the command line
parameters/qualifiers (define as a system-wide logical)
HTML FORM ELEMENTS
------------------
case= case sensitive search (Y or N)
exact= exact number of records (for extract utility, Y or N)
extract= number of line to pass to extract utility
hits= show all hits or document only (D or A)
html= comma-separated list of HTML file extensions
(overrides the /HTML and /ADDHTML qualifiers)
plain= if "yes" then treat HTML files as if plain-text
(i.e. search markup tags, everything!)
path= form supplied path (otherwise URL path)
search= text to search for
target= open new page in (e.g. "_blank", "_self")
text= comma-separated list of text file extensions
(overrides the /TEXT and /ADDTEXT qualifiers)
what= title on search results page
These could be used as in the following example (note that as this is in a
C-language comment "@" has been substituted for "*", they're just wildcards!):
<form action="/web/doc/.../@.@">
<input type="hidden" name="what" value="Example Search of /Web/ Documents">
<input type="submit" value="Search for:">
<input type="text" name="search" size="20">
<input type="reset" value="Reset">
<br>case sensitive?
<input type="radio" name="case" value="N" checked>N
<input type="radio" name="case" value="Y">Y
<br>extract this number of lines around a "hit":
<input type="text" name="extract" value="20" size="3" maxlength="3">
</form>
QUALIFIERS
----------
/ABOUT= synonym for /HELP
/ADDHTML= additional list of comma separated HTML file types
/ADDTEXT= additional list of comma separated TEXT file types
/CHARSET= "Content-Type: text/html; charset=...", empty suppress charset
/DBUG turns on all "if (Debug)" statements
/EXTRACT= path to extract script
/HELP= URL for help on searching
/HTML= complete list of comma separated HTML file types
/[NO]ODS5 control extended file specification (basically for testing)
/STYLE= URL for site CSS style sheet
/TEXT= complete list of comma separated TEXT file types
/TIMEFMT= strftime() format string for last-modified time
BUILD DETAILS
-------------
See BUILD_QUERY.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!)
---------------
28-JUL-2020 MGD v4.2.0, use "athitof" instead of "__hit__"
bugfix; style tag processing
28-JUN-2019 MGD v4.1.0, allow scripts to contain anything but </script>
QueryHtmlEscape() allow HTML entities remain intact
04-OCT-2014 MGD v4.0.0, a nod to the twenty-first century
10-MAY-2005 MGD v3.2.9, SWS 2.0 ignore query string components supplied as
command-line parameters differently to CSWS 1.2/3
23-DEC-2003 MGD v3.2.8, minor conditional mods to support IA64
15-AUG-2003 MGD v3.2.7, bugfix; move fragment *after* query string
23-JUN-2003 MGD v3.2.6, record size increased to maximum (32767 bytes),
ignore RMS$_WLK from sys$open() in line with RMS$_PRV
12-APR-2003 MGD v3.2.5, link colour changed to 0000cc
15-AUG-2002 MGD v3.2.4, GetParameters() mod for direct CSWS 1.2 support
01-JUL-2001 MGD v3.2.3, add 'SkipParameters' for direct OSU support
19-MAY-2001 MGD v3.2.2, remove limitation in SameFileType() preventing
searching of multiple file versions
25-JAN-2001 MGD v3.2.1, use <BODY> to terminate <HEAD> processing
28-OCT-2000 MGD v3.2.0, use CGILIB object module
02-MAR-2000 MGD v3.1.2, bugfix;ed again:^( rework SameFileType()
28-FEB-2000 MGD v3.1.1, bugfix; SameFileType() wildcard processing
15-FEB-2000 MGD v3.1.0, allow wildcarded file types
18-JAN-2000 MGD v3.0.0, support extended file specifications (ODS-5)
07-AUG-1999 MGD v2.9.0, use more of the CGILIB functionality,
plain-text files described using file name
24-APR-1999 MGD v2.8.0, use CGILIB.C,
standard CGI environment (e.g. Netscape FastTrack)
18-FEB-1999 MGD v2.7.2, Search[Text/Html]File() handling of SS$_PRV
(files with protection violations now just ignored)
20-NOV-1998 MGD v2.7.1, exclude certain content (e.g. <SCRIPT>...</SCRIPT)
07-NOV-1998 MGD v2.7.0, anchor hits within an HTML document,
additional information against file name
03-OCT-1998 MGD v2.6.0, remove dependency on MapUrl_Map(),
provide content-type "; charset=...",
accomodations for OSU environment,
more general maintenance
24-JUL-1998 MGD v2.5.1, suppress table background colours if empty
20-MAY-1998 MGD v2.5.0, general maintenance,
cosmetic changes
02-APR-1998 MGD v2.4.0, report file locked against access a non-fatal error,
added form-based path to override path-info,
refined (some might say corrected ;^) HTML tag parsing
19-FEB-1998 MGD v2.3.2, bugfix; "&hits=document" nesting,
modified "?about=search" redirection
19-AUG-1997 MGD v2.3.1, MapUrl() to MapUrl_Map() for conditional mapping
23-MAY-1997 MGD v2.3.0, wildcard search,
un-escape entities (e.g. "<") before match
19-SEP-1995 MGD v2.2.1, replace <CR><LF> carriage-control with single <LF>,
still acceptable for HTTP, slightly more efficient
24-MAY-1995 MGD v2.2.0, minor changes for AXP compatibility
21-APR-1995 MGD v2.1.1, added 'FormWhat'
27-MAR-1995 MGD v2.1.0, modifications to CGI interface
05-DEC-1994 MGD v2.0.0, major revision, URL mapping, CGI-like interface
10-JUN-1994 MGD v1.0.0, initial development
*/
/*****************************************************************************/
#define SOFTWAREVN "4.2.0"
#define SOFTWARENM "QUERY"
#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 <libdef.h>
#include <rmsdef.h>
#include <rms.h>
#include <ssdef.h>
#include <stsdef.h>
#include <syidef.h>
/* application header files */
#include "enamel.h"
#include "query.h"
#include <cgilib.h>
/* mainly to allow easy use of the __unaligned directive */
#define ULONGPTR __unaligned unsigned long*
#define USHORTPTR __unaligned unsigned short*
#define INT64PTR __unaligned __int64*
#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 BOOL 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__
/* convenience macro, returns a pointer to calloc()ed HTML-escaped string */
#define HTMLESC(str) ((char*)CgiLibHtmlEscape(str,-1,NULL,-1))
char DefaultHtmlTypes [] = DEFAULT_HTML_TYPES,
DefaultStyle [] = DEFAULT_QUERY_STYLE,
DefaultTextTypes [] = DEFAULT_TEXT_TYPES,
Utility [] = "QUERY";
BOOL CaseSensitive,
Debug,
DocumentOnly,
ExactNumberOfRecords,
ThereHasBeenOutput,
ListStarted,
TreatHtmlAsPlain,
FormatLikeVms;
int ExtractNumberOfRecords,
KeyCount,
FileCount,
FileHitCount,
ResFileNameLength,
NotSearchedFileCount,
OdsExtended,
TotalHitCount,
RecordCount,
SearchStringLength;
char DocumentName [2048],
ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1],
FileNamePath [ODS_MAX_FILE_NAME_LENGTH+1],
FormHtml [256],
FormPath [256],
FormText [256],
KeyName [16],
ResFileName [ODS_MAX_FILE_NAME_LENGTH+1],
SearchString [256],
SoftwareCopy [] = SOFTWARECR,
SoftwareID [48],
UrlEncodedFileNamePath [ODS_MAX_FILE_NAME_LENGTH+1],
UrlEncodedSearchString [256];
char *AboutPathPtr = DEFAULT_ABOUT_PATH,
*CgiEnvironmentPtr,
*CgiFormAboutPtr,
*CgiFormCasePtr,
*CgiFormExactPtr,
*CgiFormExtractPtr,
*CgiFormHitsPtr,
*CgiFormHtmlPtr,
*CgiFormPathPtr,
*CgiFormPlainPtr,
*CgiFormSearchPtr,
*CgiFormTextPtr,
*CgiFormTargetPtr,
*CgiFormWhatPtr,
*CgiKeyCountPtr,
*CgiKeyValuePtr,
*CgiPathInfoPtr,
*CgiPathTranslatedPtr,
*CgiQueryStringPtr,
*CgiRequestMethodPtr,
*CgiRequestUriPtr,
*CgiScriptNamePtr,
*CgiServerSoftwarePtr,
*CharsetPtr,
*CliCharsetPtr,
*ExtractScriptNamePtr,
*FormPlainPtr,
*HtmlFileTypesPtr = DefaultHtmlTypes,
*LastModifiedTimeFormatPtr = DEFAULT_STRFTIME_FORMAT,
*RequeryPtr,
*StyleSheetPtr = "",
*TargetPtr = "",
*TextFileTypesPtr = DefaultTextTypes;
struct FAB SearchFab;
struct NAM SearchNam;
#ifdef ODS_EXTENDED
struct NAML SearchNaml;
#endif /* ODS_EXTENDED */
/* required prototypes */
int QueryHtmlEscape (char*, int, char*, int);
char* SearchTextString (char*, char*, BOOL, BOOL, int*);
/*****************************************************************************/
/*
'argc/argv' are only required to support OSU, in particular CgiLibOsuInit().
*/
main
(
int argc,
char *argv[]
)
{
int status,
Count;
char *cptr;
/*********/
/* begin */
/*********/
sprintf (SoftwareID, "%s (%s)", SOFTWAREID, CgiLibEnvironmentVersion());
if (getenv ("QUERY$DBUG") != NULL) Debug = true;
if (Debug)
{
CgiLibResponseHeader (200, "text/plain");
CgiLibEnvironmentSetDebug (Debug);
}
CgiLibEnvironmentInit (argc, argv, false);
CgiEnvironmentPtr = CgiLibEnvironmentName ();
GetParameters ();
CgiLibResponseSetCharset (CliCharsetPtr);
CgiLibResponseSetSoftwareID (SoftwareID);
CgiLibResponseSetErrorMessage ("Reported by WASDquery");
if (StyleSheetPtr[0])
{
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 */
CgiServerSoftwarePtr = CgiLibVar ("WWW_SERVER_SOFTWARE");
CgiRequestMethodPtr = CgiLibVar ("WWW_REQUEST_METHOD");
if (strcmp (CgiRequestMethodPtr, "GET"))
{
CgiLibResponseHeader (501, "text/html");
fprintf (stdout, "Not implemented!\n");
return;
}
CgiScriptNamePtr = CgiLibVar ("WWW_SCRIPT_NAME");
CgiPathInfoPtr = CgiLibVar ("WWW_PATH_INFO");
CgiQueryStringPtr = CgiLibVar ("WWW_QUERY_STRING");
if (!CgiQueryStringPtr[0])
{
QueryForm ();
return;
}
/* script name and any path */
CgiRequestUriPtr = CgiLibVar ("WWW_REQUEST_URI");
for (cptr = CgiRequestUriPtr; *cptr && *cptr != '?'; cptr++);
RequeryPtr = calloc (1, cptr - CgiRequestUriPtr + 1);
memcpy (RequeryPtr, CgiRequestUriPtr, cptr - CgiRequestUriPtr);
/* kludge around a path not being MAP=ELLIPSIS */
cptr = CgiPathTranslatedPtr = CgiLibVar ("WWW_PATH_TRANSLATED");
while (*cptr)
{
if (cptr[0] == '|' && cptr[1] == '|' && cptr[2] == '|' && cptr[3] != '|')
{
cptr[0] = cptr[1] = cptr[2] = '.';
break;
}
cptr++;
}
CgiFormAboutPtr = CgiLibVar ("WWW_FORM_ABOUT");
CgiFormCasePtr = CgiLibVar ("WWW_FORM_CASE");
CgiFormExactPtr = CgiLibVar ("WWW_FORM_EXACT");
CgiFormExtractPtr = CgiLibVar ("WWW_FORM_EXTRACT");
CgiFormHitsPtr = CgiLibVar ("WWW_FORM_HITS");
CgiFormHtmlPtr = CgiLibVar ("WWW_FORM_HTML");
CgiFormPathPtr = CgiLibVar ("WWW_FORM_PATH");
CgiFormPlainPtr = CgiLibVar ("WWW_FORM_PLAIN");
CgiFormSearchPtr = CgiLibVar ("WWW_FORM_SEARCH");
CgiFormTargetPtr = CgiLibVar ("WWW_FORM_TARGET");
CgiFormTextPtr = CgiLibVar ("WWW_FORM_TEXT");
CgiFormWhatPtr = CgiLibVar ("WWW_FORM_WHAT");
CgiKeyCountPtr = CgiLibVar ("WWW_KEY_COUNT");
SearchString[0] = '\0';
KeyCount = atoi(CgiKeyCountPtr);
for (Count = 1; Count <= KeyCount; Count++)
{
sprintf (KeyName, "WWW_KEY_%d", Count);
CgiKeyValuePtr = CgiLibVar (KeyName);
if (SearchString[0]) strcat (SearchString, " ");
strcat (SearchString, CgiKeyValuePtr);
}
if (SearchString[0])
CgiFormSearchPtr = SearchString;
else
strcpy (SearchString, CgiFormSearchPtr);
if (strsame (CgiFormAboutPtr, "SEARCH", 6))
{
CgiLibResponseRedirect (AboutPathPtr);
exit (SS$_NORMAL);
}
if (CgiFormPathPtr[0])
{
/* path supplied indirectly via form field, redirect to translate */
CgiScriptNamePtr = CgiLibVar ("WWW_SCRIPT_NAME");
CgiQueryStringPtr = CgiLibVar ("WWW_QUERY_STRING");
CgiLibResponseRedirect ("%s%s%s%s",
CgiScriptNamePtr, CgiFormPathPtr,
CgiQueryStringPtr[0] ? "?" : "", CgiQueryStringPtr);
exit (SS$_NORMAL);
}
if (!CgiPathTranslatedPtr[0])
{
CgiLibResponseError (FI_LI, 0, "Search path not supplied.");
exit (SS$_NORMAL);
}
if (!CgiFormSearchPtr[0])
{
CgiLibResponseError (FI_LI, 0, "Search string not supplied.");
exit (SS$_NORMAL);
}
if (CgiFormExtractPtr[0] && !isdigit(CgiFormExtractPtr[0]))
{
CgiLibResponseError (FI_LI, 0, "Invalid number of lines to extract.");
exit (SS$_NORMAL);
}
ExtractNumberOfRecords = atoi(CgiFormExtractPtr);
if (!ExtractNumberOfRecords)
ExtractNumberOfRecords = DEFAULT_EXTRACT_RECORDS;
if (toupper(CgiFormExactPtr[0]) == 'Y')
ExactNumberOfRecords = true;
else
ExactNumberOfRecords = false;
if (toupper(CgiFormCasePtr[0]) == 'Y')
CaseSensitive = true;
else
CaseSensitive = false;
if (toupper(CgiFormHitsPtr[0]) == 'D')
DocumentOnly = true;
else
DocumentOnly = false;
if (toupper(CgiFormPlainPtr[0]) == 'Y')
{
TreatHtmlAsPlain = true;
FormPlainPtr = "&plain=yes";
}
else
{
TreatHtmlAsPlain = false;
FormPlainPtr = "";
}
if (CgiFormHtmlPtr[0])
{
HtmlFileTypesPtr = CgiFormHtmlPtr;
sprintf (FormHtml, "&html=%s", CgiFormHtmlPtr);
}
if (CgiFormTextPtr[0])
{
TextFileTypesPtr = CgiFormTextPtr;
sprintf (FormText, "&text=%s", CgiFormTextPtr);
}
if (ExtractScriptNamePtr == NULL)
{
if (CgiLibEnvironmentIsWasd() ||
CgiLibEnvironmentIsCgiPlus())
ExtractScriptNamePtr = DEFAULT_WASD_EXTRACT;
else
if (CgiLibEnvironmentIsOsu())
ExtractScriptNamePtr = DEFAULT_OSU_EXTRACT;
else
ExtractScriptNamePtr = DEFAULT_CGI_EXTRACT;
}
if (CgiFormTargetPtr[0])
{
TargetPtr = calloc (1, 32+strlen(CgiFormTargetPtr));
sprintf (TargetPtr, " target=\"%s\"", CgiFormTargetPtr);
}
SearchFiles ();
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 ("QUERY$PARAM")) == NULL)
{
/* 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 != NULL) *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, "/ABOUT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
AboutPathPtr = cptr;
continue;
}
if (strsame (aptr, "/ADDHTML=", 7))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
sptr = malloc (strlen(HtmlFileTypesPtr)+strlen(cptr)+2);
strcpy (sptr, HtmlFileTypesPtr);
strcat (sptr, ",");
strcat (sptr, cptr);
HtmlFileTypesPtr = sptr;
continue;
}
if (strsame (aptr, "/ADDTEXT=", 7))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
sptr = malloc (strlen(TextFileTypesPtr)+strlen(cptr)+2);
strcpy (sptr, TextFileTypesPtr);
strcat (sptr, ",");
strcat (sptr, cptr);
TextFileTypesPtr = sptr;
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, "/EXTRACT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
ExtractScriptNamePtr = cptr;
continue;
}
if (strsame (aptr, "/HTML=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
HtmlFileTypesPtr = cptr;
continue;
}
if (strsame (aptr, "/ODS5", 5))
{
OdsExtended = true;
continue;
}
if (strsame (aptr, "/NOODS5", 7))
{
OdsExtended = false;
continue;
}
if (strsame (aptr, "/STYLE=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
StyleSheetPtr = cptr;
continue;
}
if (strsame (aptr, "/TEXT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
TextFileTypesPtr = cptr;
continue;
}
if (strsame (aptr, "/TIMEFMT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
LastModifiedTimeFormatPtr = 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);
}
}
}
/*****************************************************************************/
/*
Search files in specification for specified string. Unless a file type
(extension) matches an HTML type then consider the file to be a plain-text
file. The two need to searched differently because of the HTML markup tags
compsrising an HTML file.
*/
SearchFiles ()
{
static int TimerElapsed = 1,
TimerCpu = 2,
TimerBio = 3,
TimerDio = 4;
static $DESCRIPTOR (ElapsedTimeFaoDsc, "!%T");
static $DESCRIPTOR (StatisticsFaoDsc,
"Elapsed: !AZ CPU: !2ZL:!2ZL.!2ZL I/O: !UL Disk: !UL \
Records (lines): !UL");
int status,
BioCount,
CpuTime,
DioCount,
ExpandedNameOffset,
ResultVersionLength;
unsigned long ResultFnb;
unsigned long ElapsedTime [2];
unsigned short Length;
char *cptr, *sptr,
*FilePtr,
*FileHitPtr,
*FileNamePathPtr,
*ResultNamePtr,
*ResultTypePtr,
*ResultVersionPtr,
*TotalHitPtr;
char ElapsedString [32],
EscapedPath [ODS_MAX_FILE_NAME_LENGTH+1],
EscapedSearchString [256],
NotSearchedString [32],
Statistics [256],
String [1024];
$DESCRIPTOR (ElapsedStringDsc, ElapsedString);
$DESCRIPTOR (StatisticsDsc, Statistics);
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "SearchFiles() |%s|%s|\n",
CgiPathTranslatedPtr, SearchString);
lib$init_timer (0);
ListStarted = false;
FormatLikeVms = false;
for (cptr = CgiPathInfoPtr; *cptr; cptr++);
while (cptr > CgiPathInfoPtr && *cptr != '/')
{
if (*cptr == ';')
{
FormatLikeVms = true;
break;
}
cptr--;
}
if (FormatLikeVms)
CgiLibHtmlEscape (CgiPathTranslatedPtr, -1,
EscapedPath, sizeof(EscapedPath));
else
{
if (!CgiPathInfoPtr[0]) CgiPathInfoPtr = "/";
CgiLibHtmlEscape (CgiPathInfoPtr, -1, EscapedPath, sizeof(EscapedPath));
}
if (SearchString[0])
{
SearchStringLength = strlen(SearchString);
CgiLibUrlEncode (SearchString, -1, UrlEncodedSearchString, -1);
CgiLibHtmlEscape (SearchString, -1,
EscapedSearchString, sizeof(EscapedSearchString));
}
else
{
SearchStringLength = 0;
EscapedSearchString[0] = UrlEncodedSearchString[0] = '\0';
}
sptr = String;
if (CgiFormWhatPtr[0])
sptr += sprintf (sptr, "Search %s for "%s"",
CgiFormWhatPtr, EscapedSearchString);
else
sptr += sprintf (sptr, "Search %s for "%s"",
EscapedPath, EscapedSearchString);
SearchFab = cc$rms_fab;
SearchFab.fab$l_dna = "*.*;0";
SearchFab.fab$b_dns = 5;
#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 = CgiPathTranslatedPtr;
SearchNaml.naml$l_long_filename_size = strlen(CgiPathTranslatedPtr);
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 = CgiPathTranslatedPtr;
SearchFab.fab$b_fns = strlen(CgiPathTranslatedPtr);
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)))
{
CgiLibResponseError (FI_LI, status, HTMLESC(CgiPathInfoPtr));
return (status);
}
if (Debug) fprintf (stdout, "ExpFileName |%s|\n", ExpFileName);
/* establish the base for generated file name used in the file path */
#ifdef ODS_EXTENDED
if (OdsExtended)
sptr = SearchNaml.naml$l_long_name - 1;
else
#endif /* ODS_EXTENDED */
sptr = SearchNam.nam$l_name - 1;
cptr = ExpFileName;
while (cptr < sptr)
{
if (*cptr == '*' || *cptr == '%' ||
(cptr[0] == '.' && cptr[1] == '.' && cptr[2] == '.'))
{
if (cptr[0] != '.' || cptr[1] != '.' || cptr[2] != '.') cptr--;
break;
}
cptr++;
}
while (cptr > ExpFileName && *cptr != '[' && *cptr != '.' && *cptr != ']')
cptr--;
ExpandedNameOffset = cptr - ExpFileName + 1;
/* establish the base for generated file path */
sptr = FileNamePath;
cptr = CgiPathInfoPtr;
while (*cptr)
{
if (*cptr == '*' || *cptr == '%')
{
cptr--;
sptr--;
break;
}
if (cptr[0] == '.' && cptr[1] == '.' && cptr[2] == '.') break;
*sptr++ = *cptr++;
}
if ((cptr[0] == '.' && cptr[1] == '.' && cptr[2] == '.') &&
sptr[-1] != '/' && sptr[-1] != '*' && sptr[-1] != '%')
*sptr++ = '/';
else
{
while (sptr > FileNamePath && *sptr != '/') sptr--;
*sptr++;
}
*sptr = '\0';
FileNamePathPtr = sptr;
if (Debug) fprintf (stdout, "FileNamePath |%s|\n", FileNamePath);
/*************************/
/* begin the page output */
/*************************/
CgiLibResponseHeader (200, "text/html");
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=\"text-types\" content=\"%s\">\n\
<meta name=\"html-types\" content=\"%s\">\n\
<title>%s</title>\n\
<style type=\"text/css\">\n\
%s\
</style>\n\
%s\
</head>\n\
<body>\n",
SoftwareID, SoftwareCopy,
CgiEnvironmentPtr,
TextFileTypesPtr,
HtmlFileTypesPtr,
String,
DefaultStyle,
StyleSheetPtr);
fprintf (stdout, "<div class=\"header\">%s</div>\n", String);
fflush (stdout);
ThereHasBeenOutput = true;
/***************/
/* file search */
/***************/
for (;;)
{
status = sys$search (&SearchFab, 0, 0);
if (Debug) fprintf (stdout, "sys$search() %%X%08.08X\n", status);
if (status == RMS$_PRV) continue;
if (VMSnok (status)) break;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
ResultFnb = SearchNaml.naml$l_fnb;
ResultNamePtr = SearchNaml.naml$l_long_name;
ResultTypePtr = SearchNaml.naml$l_long_type;
ResultVersionPtr = SearchNaml.naml$l_long_ver;
ResultVersionLength = SearchNaml.naml$l_long_ver_size;
ResFileNameLength = SearchNaml.naml$l_long_ver -
SearchNaml.naml$l_long_result;
}
else
#endif /* ODS_EXTENDED */
{
ResultFnb = SearchNam.nam$l_fnb;
ResultNamePtr = SearchNam.nam$l_name;
ResultTypePtr = SearchNam.nam$l_type;
ResultVersionPtr = SearchNam.nam$l_ver;
ResultVersionLength = SearchNam.nam$b_ver;
ResFileNameLength = SearchNam.nam$l_ver -
SearchNam.nam$l_rsa;
}
if (FormatLikeVms)
{
ResultVersionPtr[ResultVersionLength] = '\0';
ResFileNameLength += ResultVersionLength;
}
else
ResultVersionPtr[0] = '\0';
if (Debug)
fprintf (stdout, "ResFileName %d |%s|\n",
ResFileNameLength, ResFileName);
/* generate a file path from the base file path and base file name */
sptr = FileNamePathPtr;
cptr = ResFileName + ExpandedNameOffset;
while (*cptr && *cptr != ']' && cptr < ResultNamePtr)
{
if (CgiLibEnvironmentIsWasd() &&
!memcmp (cptr, "000000.", 7) ||
!memcmp (cptr, "000000]", 7)) cptr += 7;
if (*cptr == '.')
{
*sptr++ = '/';
cptr++;
}
else
*sptr++ = tolower(*cptr++);
}
if (*cptr == ']')
{
cptr++;
*sptr++ = '/';
}
while (*cptr) *sptr++ = tolower(*cptr++);
*sptr = '\0';
if (Debug) fprintf (stdout, "FileNamePath |%s|\n", FileNamePath);
if (SameFileType (HtmlFileTypesPtr, ResultTypePtr+1))
{
/* if HTML document's <title> can't be resolved then use file name */
#ifdef ODS_EXTENDED
if (OdsExtended)
cptr = (char*)CgiLibUrlEncodeFileName (ResultNamePtr, NULL, 0,
FormatLikeVms,
!FormatLikeVms);
else
#endif /* ODS_EXTENDED */
cptr = ResultNamePtr;
sprintf (DocumentName,
"%s <span class=\"filename\">[file name]</span>",
cptr);
if (TreatHtmlAsPlain)
{
if (VMSok (status = SearchTextFile ()))
FileCount++;
else
if (status != RMS$_PRV &&
status != RMS$_WLK)
{
CgiLibResponseError (FI_LI, status, FileNamePath);
return (SS$_NORMAL);
}
}
else
{
if (VMSok (status = SearchHtmlFile ()))
FileCount++;
else
if (status != RMS$_PRV &&
status != RMS$_WLK)
{
CgiLibResponseError (FI_LI, status, FileNamePath);
return (SS$_NORMAL);
}
}
}
else
if (SameFileType (TextFileTypesPtr, ResultTypePtr+1))
{
#ifdef ODS_EXTENDED
if (OdsExtended)
cptr = (char*)CgiLibUrlEncodeFileName (ResultNamePtr, NULL, 0,
FormatLikeVms,
!FormatLikeVms);
else
#endif /* ODS_EXTENDED */
cptr = ResultNamePtr;
strcpy (DocumentName, cptr);
if (VMSok (status = SearchTextFile ()))
FileCount++;
else
if (status != RMS$_PRV &&
status != RMS$_WLK)
{
CgiLibResponseError (FI_LI, status, FileNamePath);
return (SS$_NORMAL);
}
}
else
NotSearchedFileCount++;
if (!FormatLikeVms)
{
/* restore the version delimiter */
ResultVersionPtr[0] = ';';
}
}
if (Debug) fprintf (stdout, "sys$search() %%X%08.08X\n", status);
/*******************/
/* end file search */
/*******************/
/* if its a search list treat directory not found as if file not found */
if ((ResultFnb & NAM$M_SEARCH_LIST) && status == RMS$_DNF)
status = RMS$_FNF;
if (status == RMS$_FNF || status == RMS$_NMF) status = SS$_NORMAL;
if (VMSnok (status))
{
CgiLibResponseError (FI_LI, status, HTMLESC(CgiPathInfoPtr));
return (SS$_NORMAL);
}
/*********************/
/* results of search */
/*********************/
lib$stat_timer (&TimerElapsed, &ElapsedTime, 0);
lib$stat_timer (&TimerCpu, &CpuTime, 0);
lib$stat_timer (&TimerBio, &BioCount, 0);
lib$stat_timer (&TimerDio, &DioCount, 0);
sys$fao (&ElapsedTimeFaoDsc, &Length, &ElapsedStringDsc, &ElapsedTime);
ElapsedString[Length] = '\0';
sys$fao (&StatisticsFaoDsc, &Length, &StatisticsDsc,
ElapsedString+3, CpuTime/6000, CpuTime/100, CpuTime%100,
BioCount, DioCount, RecordCount);
Statistics[Length] = '\0';
if (!NotSearchedFileCount)
NotSearchedString[0] = '\0';
else
if (NotSearchedFileCount == 1)
strcpy (NotSearchedString, " (1 not)");
else
sprintf (NotSearchedString, " (%d not)", NotSearchedFileCount);
if (ListStarted) fputs ("</ol>\n", stdout);
fputs ("<div class=\"footer\">\n\
<div class=\"summary\">", stdout);
if (TotalHitCount)
{
if (FileCount == 1) FilePtr = "file"; else FilePtr = "files";
if (FileHitCount == 1) FileHitPtr = "file"; else FileHitPtr = "files";
if (TotalHitCount == 1) TotalHitPtr = "hit"; else TotalHitPtr = "hits";
if (DocumentOnly)
{
fprintf (stdout, "%d %s searched%s with %d %s hit.",
FileCount, FilePtr, NotSearchedString, FileHitCount,
FileHitPtr);
}
else
{
fprintf (stdout,
"%d %s searched%s with %d %s hit, for a total of %d %s.",
FileCount, FilePtr, NotSearchedString, FileHitCount,
FileHitPtr, TotalHitCount, TotalHitPtr);
}
}
else
{
if (FileCount)
{
if (FileCount == 1) FilePtr = "file"; else FilePtr = "files";
fprintf (stdout, "%d %s searched%s, string not found.",
FileCount, FilePtr, NotSearchedString);
}
else
fprintf (stdout, "No files found!");
}
fprintf (stdout,
"</div>\n\
<div class=\"otherbutton\">\n\
<a href=\"%s\">Requery</a>\n\
<a target=\"_blank\" href=\"%s\">About</a>\n\
</div>\n\
<div class=\"statistics\">%s</div>\n\
</div>\n",
RequeryPtr, AboutPathPtr, Statistics);
if (VMSnok (status))
{
CgiLibResponseError (FI_LI, status, HTMLESC(CgiPathInfoPtr));
return (SS$_NORMAL);
}
fprintf (stdout, "</body>\n</html>\n");
return (status);
}
/*****************************************************************************/
/*
This function accepts a comma-separated list of (possibly wildcarded) file
types (extensions, e.g. "TXT,TEXT,COM,C,PAS,FOR,RPT*") and a VMS file type
(e.g. ".TXT;", ".TXT", "TXT"). Returns true if the file type is in the list,
false if not.
*/
BOOL SameFileType
(
char *TypeList,
char *TypePtr
)
{
char ch;
char *cptr, *sptr, *zptr;
char FileType [256];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SameFileType() |%s|%s|\n", FileType, TypeList);
zptr = (sptr = FileType) + sizeof(FileType)-1;
for (cptr = TypePtr;
*cptr && *cptr != ';' && sptr < zptr;
*sptr++ = *cptr++);
*sptr = '\0';
cptr = TypeList;
while (*cptr)
{
for (sptr = cptr; *sptr && *sptr != ','; sptr++);
ch = *sptr;
*sptr = '\0';
if (Debug) fprintf (stdout, "|%s|%s|\n", FileType, cptr);
if ((SearchTextString (FileType, cptr, false, false, NULL)) != NULL)
{
*sptr = ch;
return (true);
}
if (*sptr = ch) sptr++;
cptr = sptr;
}
return (false);
}
/*****************************************************************************/
/*
String search allowing wildcard "*" (matching any multiple characters) and "%"
(matching any single character). Returns NULL if not found or a pointer to
start of matched string. Setting 'ImpliedWildcards' means the 'SearchFor'
string is processed as if enclosed by '*' wildcard characters.
*/
char* SearchTextString
(
char *SearchIn,
char *SearchFor,
BOOL CaseSensitive,
BOOL ImpliedWildcards,
int *MatchedLengthPtr
)
{
char *cptr, *sptr, *inptr,
*RestartCptr,
*RestartInptr,
*MatchPtr;
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "SearchTextString() |%s|%s|\n", SearchIn, SearchFor);
if (MatchedLengthPtr != NULL) *MatchedLengthPtr = 0;
if (!*(cptr = SearchFor)) return (NULL);
inptr = MatchPtr = SearchIn;
if (ImpliedWildcards)
{
/* skip leading text up to first matching character (if any!) */
if (*cptr != '*' && *cptr != '%')
{
if (CaseSensitive)
while (*inptr && *inptr != *cptr) inptr++;
else
while (*inptr && toupper(*inptr) != toupper(*cptr)) inptr++;
if (Debug && !*inptr) fprintf (stdout, "1. NOT matched!\n");
if (!*inptr) return (NULL);
cptr++;
MatchPtr = inptr++;
}
}
for (;;)
{
if (CaseSensitive)
{
while (*cptr && *inptr && *cptr == *inptr)
{
cptr++;
inptr++;
}
}
else
{
while (*cptr && *inptr && toupper(*cptr) == toupper(*inptr))
{
cptr++;
inptr++;
}
}
if (ImpliedWildcards)
{
if (!*cptr)
{
if (Debug) fprintf (stdout, "1. matched!\n");
if (MatchedLengthPtr != NULL) *MatchedLengthPtr = inptr - MatchPtr;
return (MatchPtr);
}
}
else
{
if (!*cptr && !*inptr)
{
if (Debug) fprintf (stdout, "2. matched!\n");
if (MatchedLengthPtr != NULL) *MatchedLengthPtr = inptr - MatchPtr;
return (MatchPtr);
}
if (*cptr != '*' && *cptr != '%')
{
if (Debug && !*inptr) fprintf (stdout, "3. NOT matched!\n");
return (NULL);
}
}
if (*cptr != '*' && *cptr != '%')
{
if (!*inptr)
{
if (Debug) fprintf (stdout, "4. NOT matched!\n");
return (NULL);
}
cptr = SearchFor;
MatchPtr = ++inptr;
continue;
}
if (*cptr == '%')
{
/* single char wildcard processing */
if (!*inptr) break;
cptr++;
inptr++;
continue;
}
/* asterisk wildcard matching */
while (*cptr == '*') cptr++;
/* an asterisk wildcard at end matches all following */
if (!*cptr)
{
if (Debug) fprintf (stdout, "5. matched!\n");
while (*inptr) inptr++;
if (MatchedLengthPtr != NULL) *MatchedLengthPtr = inptr - MatchPtr;
return (MatchPtr);
}
/* note the current position in the string (first after the wildcard) */
RestartCptr = cptr;
for (;;)
{
/* find first char in SearchIn matching char after wildcard */
if (CaseSensitive)
while (*inptr && *cptr != *inptr) inptr++;
else
while (*inptr && toupper(*cptr) != toupper(*inptr)) inptr++;
/* if did not find matching char in SearchIn being searched */
if (Debug && !*inptr) fprintf (stdout, "6. NOT matched!\n");
if (!*inptr) return (NULL);
/* note the current position in SearchIn being searched */
RestartInptr = inptr;
/* try to match the remainder of the string and SearchIn */
if (CaseSensitive)
{
while (*cptr && *inptr && *cptr == *inptr)
{
cptr++;
inptr++;
}
}
else
{
while (*cptr && *inptr && toupper(*cptr) == toupper(*inptr))
{
cptr++;
inptr++;
}
}
/* if reached the end of both string and SearchIn - match! */
if (ImpliedWildcards)
{
if (!*cptr)
{
if (Debug) fprintf (stdout, "7. matched!\n");
if (MatchedLengthPtr != NULL)
*MatchedLengthPtr = inptr - MatchPtr;
return (MatchPtr);
}
}
else
{
if (!*cptr && !*inptr)
{
if (Debug) fprintf (stdout, "8. matched!\n");
if (MatchedLengthPtr != NULL)
*MatchedLengthPtr = inptr - MatchPtr;
return (MatchPtr);
}
}
/* break to the external loop if we encounter another wildcard */
if (*cptr == '*' || *cptr == '%') break;
/* lets have another go */
cptr = RestartCptr;
/* starting the character following the previous attempt */
inptr = MatchPtr = RestartInptr + 1;
}
}
}
/*****************************************************************************/
/*
Search an HTML marked up file. Simply count the number of '<' and '>'
characters, which should be balanced, and when not inside an HTML markup tag
search the text. As HTML files cannot easily have text extracted from within
them without the results being unpredictable simply return the document as
having the search string hit. The HTML <title> tag (if present) is used as
the document name.
*/
SearchHtmlFile ()
{
BOOL InsideApplet = false,
InsideComment = false,
InsideHead = false,
InsideScript = false,
InsideServer = false,
InsideStyle = false,
InsideTitle = false;
int status,
ByteCount,
HitCount = 0,
MatchedLength,
RecordNumber = 0,
TagCharCount = 0;
unsigned long UnixTime;
char ch;
char *cptr, *dptr, *rptr, *sptr, *tptr,
*CaseSensitivePtr = "",
*FileNamePathPtr;
char FileSize [32],
LastModifiedTime [64],
Record [MAX_RECORD_SIZE+1],
String [MAX_RECORD_SIZE*2],
Text [MAX_RECORD_SIZE*2];
struct tm *UnixTmPtr;
struct FAB FileFab;
#ifdef ODS_EXTENDED
struct NAML FileNaml;
#endif /* ODS_EXTENDED */
struct RAB FileRab;
struct XABDAT FileXabDat;
struct XABFHC FileXabFhc;
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "SearchHtmlFile() |%s|%s|\n", ResFileName, SearchString);
FileFab = cc$rms_fab;
FileFab.fab$b_fac = FAB$M_GET;
FileFab.fab$b_shr = FAB$M_SHRGET | FAB$M_SHRPUT;
FileFab.fab$l_xab = &FileXabDat;
FileFab.fab$l_fop = FAB$M_NAM;
FileXabDat = cc$rms_xabdat;
FileXabDat.xab$l_nxt = &FileXabFhc;
FileXabFhc = cc$rms_xabfhc;
#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 = ResFileName;
FileNaml.naml$l_long_filename_size = ResFileNameLength;
}
else
#endif /* ODS_EXTENDED */
{
FileFab.fab$l_fna = ResFileName;
FileFab.fab$b_fns = ResFileNameLength;
}
status = sys$open (&FileFab, 0, 0);
if (Debug) fprintf (stdout, "sys$open() %%X%08.08X\n", status);
if (VMSnok (status))
{
if (status == RMS$_PRV) return (status);
if (!ListStarted)
{
ListStarted = true;
fputs ("<ol>\n", stdout);
}
fprintf (stdout,
"<li><span class=\"hit\">ERROR opening file (%%X%08.08X) \
%s <!-- %s --></span>\n",
status,
FileNamePath,
ResFileName);
return (SS$_NORMAL);
}
FileRab = cc$rms_rab;
FileRab.rab$l_fab = &FileFab;
/* 2 buffers and read ahead performance option */
FileRab.rab$b_mbf = 2;
FileRab.rab$l_rop = RAB$M_RAH;
FileRab.rab$l_ubf = Record;
FileRab.rab$w_usz = sizeof(Record)-1;
if (VMSnok (status = sys$connect (&FileRab, 0, 0)))
{
if (Debug) fprintf (stdout, "sys$connect() %%X%08.08X\n", status);
sys$close (&FileFab, 0, 0);
return (status);
}
if (CaseSensitive) CaseSensitivePtr = "&case=yes";
/**********************/
/* search all records */
/**********************/
if (Debug) fprintf (stdout, "+++++0 %d\n", TagCharCount);
while (VMSok (status = sys$get (&FileRab, 0, 0)))
{
RecordNumber++;
if (!FileRab.rab$w_rsz) continue;
Record[FileRab.rab$w_rsz] = '\0';
if (Debug)
fprintf (stdout, "Record |%s|\n%d %d %d %d %d %d %d %d\n",
Record, TagCharCount, InsideApplet, InsideComment,
InsideHead, InsideScript, InsideServer, InsideStyle,
InsideTitle);
if (Debug) fprintf (stdout, "+++++1 %d\n", TagCharCount);
/* terminate on any carriage control that may be in the record */
for (rptr = Record; *rptr && *rptr != '\r' && *rptr != '\n'; rptr++);
*rptr = '\0';
/* continue if empty line */
if (!Record[0]) continue;
/**************************************/
/* retrieve text not inside HTML tags */
/**************************************/
tptr = Text;
rptr = Record;
while (*rptr)
{
if (InsideComment)
{
if (rptr[0] == '-' && rptr[1] == '-' && rptr[2] == '>')
{
InsideComment = false;
rptr += 3;
}
else
rptr++;
continue;
}
if (*rptr == '<' && *(ULONGPTR)rptr == '<!--')
{
InsideComment = true;
rptr += 4;
continue;
}
if (InsideScript)
{
/* pretty much anything goes except... */
if (strsame (rptr, "</script>", 9))
{
rptr += 8;
InsideScript = false;
}
else
rptr++;
continue;
}
if (InsideStyle)
{
/* pretty much anything goes except... */
if (strsame (rptr, "</style>", 8))
{
rptr += 7;
InsideStyle = false;
}
else
rptr++;
continue;
}
/* less-thans are forbidden inside tags! */
if ((TagCharCount & 1) && rptr[0] == '<') break;
/* consider adjacent white-space when determining what is a tag */
if ((rptr[0] == '<' && rptr[1] && !isspace(rptr[1])) ||
((TagCharCount & 1) && rptr[0] == '>'))
{
TagCharCount++;
rptr++;
if (TagCharCount & 1)
{
/* checks to detect start and end of some tags */
if (tolower(*rptr) == 'a' &&
(strsame (rptr, "applet>", 7) ||
strsame (rptr, "applet ", 7)))
{
rptr += 6;
InsideApplet = true;
}
else
if (strsame (rptr, "body>", 5) ||
strsame (rptr, "body ", 4))
{
rptr += 4;
InsideHead = false;
}
else
if (tolower(*rptr) == 'h' && strsame (rptr, "head>", 5))
{
rptr += 4;
InsideHead = true;
}
else
if (tolower(*rptr) == 's')
{
if (strsame (rptr, "script>", 7) ||
strsame (rptr, "script ", 7))
{
rptr += 6;
InsideScript = true;
}
else
if (strsame (rptr, "server>", 7) ||
strsame (rptr, "server ", 7))
{
rptr += 6;
InsideServer = true;
}
if (strsame (rptr, "style>", 6) ||
strsame (rptr, "style ", 6))
{
rptr += 5;
InsideStyle = true;
}
}
else
if (tolower(*rptr) == 't' && strsame (rptr, "title>", 6))
{
rptr += 5;
dptr = DocumentName;
InsideTitle = true;
}
else
if (*rptr == '/')
{
if (strsame (rptr, "/applet>", 8))
{
rptr += 7;
InsideApplet = false;
}
else
if (strsame (rptr, "/head>", 6))
{
rptr += 5;
InsideHead = false;
}
else
if (strsame (rptr, "/script>", 8))
{
rptr += 7;
InsideScript = false;
}
else
if (strsame (rptr, "/style>", 7))
{
rptr += 6;
InsideStyle = false;
}
else
if (strsame (rptr, "/server>", 8))
{
rptr += 7;
InsideServer = false;
}
else
if (strsame (rptr, "/title>", 7))
{
rptr += 6;
*dptr = '\0';
InsideTitle = false;
}
}
}
}
else
{
if (InsideTitle)
{
if (dptr < DocumentName+255)
*dptr++ = *rptr++;
else
rptr++;
}
else
if (InsideApplet ||
InsideHead ||
InsideScript ||
InsideServer ||
InsideStyle)
{
rptr++;
}
else
if (TagCharCount & 1)
rptr++;
else
{
if (*rptr == '&')
{
if (strsame (rptr, "<", 4))
{
*tptr++ = '<';
rptr += 4;
}
else
if (strsame (rptr, ">", 4))
{
*tptr++ = '>';
rptr += 4;
}
else
if (strsame (rptr, "&", 5))
{
*tptr++ = '&';
rptr += 5;
}
else
if (strsame (rptr, """, 6))
{
*tptr++ = '\"';
rptr += 6;
}
else
if (strsame (rptr, " ", 6))
{
*tptr++ = ' ';
rptr += 6;
}
else
if (*(rptr+1) == '#')
{
for (cptr = rptr+2; *cptr && isdigit(*cptr); cptr++);
if (*cptr == ';')
{
ch = atoi(rptr+2) & 0xff;
*tptr++ = ch;
rptr = cptr + 1;
}
else
*tptr++ = *rptr++;
}
else
*tptr++ = *rptr++;
}
else
*tptr++ = *rptr++;
}
}
} /* while (*rptr) */
if (Debug) fprintf (stdout, "+++++2 %d\n", TagCharCount);
*tptr = '\0';
if (!Text[0]) continue;
tptr = SearchTextString (Text, SearchString,
CaseSensitive, true,
&MatchedLength);
if (tptr != NULL)
{
/********/
/* hit! */
/********/
if (Debug) fprintf (stdout, "Hit |%s|\n", tptr);
TotalHitCount++;
#ifdef ODS_EXTENDED
if (OdsExtended)
FileNamePathPtr =
(char*)CgiLibUrlEncodeFileName (FileNamePath, NULL, 0,
FormatLikeVms, !FormatLikeVms);
else
#endif /* ODS_EXTENDED */
FileNamePathPtr = FileNamePath;
if (!HitCount++)
{
/*************************************/
/* first hit, entire document anchor */
/*************************************/
UnixTime = decc$fix_time (&FileXabDat.xab$q_rdt);
UnixTmPtr = localtime (&UnixTime);
if (!strftime (LastModifiedTime, sizeof(LastModifiedTime),
LastModifiedTimeFormatPtr, UnixTmPtr))
strcpy (LastModifiedTime, "**ERROR**");
/* true for non-VAR record formats, almost true for those :^) */
if (FileXabFhc.xab$l_ebk)
ByteCount = ((FileXabFhc.xab$l_ebk - 1) * 512) +
FileXabFhc.xab$w_ffb;
else
ByteCount = FileXabFhc.xab$w_ffb;
if (ByteCount < 1000)
sprintf (FileSize, "%d bytes", ByteCount);
else
if (ByteCount % 1000 < 500)
sprintf (FileSize, "%d kB", ByteCount/1000);
else
sprintf (FileSize, "%d kB", (ByteCount/1000)+1);
if (!ListStarted)
{
ListStarted = true;
fputs ("<ol>\n", stdout);
}
fprintf (stdout,
"<li><span class=\"hit\"><a%s href=\"%s\">%s</a> \
<span class=\"document\">HTML %s %s</span></span>\n",
TargetPtr, FileNamePathPtr, DocumentName,
LastModifiedTime, FileSize);
if (DocumentOnly) break;
fprintf (stdout, "<ol>\n");
}
/***********************/
/* file extract anchor */
/***********************/
sptr = String;
strcpy (sptr, "<li><span class=\"ishtml\">");
sptr += 25;
/* absorb leading white-space */
for (cptr = Text; *cptr && (*cptr == ' ' || *cptr == '\t'); cptr++);
/* copy the record up to the first character of the search string */
sptr += QueryHtmlEscape (cptr, tptr-cptr, sptr, -1);
/* add the HTML anchor */
sptr += sprintf (sptr,
"<a%s href=\"%s%s?highlight=%s&anchor=yes%s%s%s#athitof%d\">",
TargetPtr, ExtractScriptNamePtr, FileNamePathPtr,
UrlEncodedSearchString, FormText, FormHtml,
FormPlainPtr, HitCount);
/* matched string, highlighted within the anchor */
sptr += QueryHtmlEscape (tptr, MatchedLength, sptr, -1);
strcpy (sptr, "</a>");
sptr += 4;
/* rest of record after the matched search string */
sptr += QueryHtmlEscape (tptr+MatchedLength, -1, sptr, -1);
strcpy (sptr, "</span>\n");
sptr += 8;
if (Debug) fprintf (stdout, "String |%s|\n", String);
fputs (String, stdout);
}
}
if (Debug) fprintf (stdout, "+++++3 %d\n", TagCharCount);
/***************/
/* end of file */
/***************/
if (status == RMS$_EOF) status = SS$_NORMAL;
sys$close (&FileFab, 0, 0);
if (VMSnok (status))
{
if (!ListStarted)
{
ListStarted = true;
fputs ("<ol>\n", stdout);
}
fprintf (stdout,
"<li><span class=\"hit\">ERROR reading file (%%X%08.08X) \
%s <!-- %s --></span>\n",
status, FileNamePath, ResFileName);
}
if (HitCount)
{
if (!DocumentOnly) fputs ("</ol>\n", stdout);
fflush (stdout);
FileHitCount++;
}
if (Debug) fprintf (stdout, "+++++4 %d\n", TagCharCount);
if (TagCharCount & 1)
{
/* must have encountered an opening '<' without a closing '>' */
if (!ListStarted)
{
ListStarted = true;
fputs ("<ol>\n", stdout);
}
fprintf (stdout,
"<li><span class=\"hit\">HTML unbalanced <> in \
<a%s href=\"%s\">%s</a> <!-- %s --></span>\n",
TargetPtr, FileNamePath, FileNamePath, ResFileName);
}
RecordCount += RecordNumber;
return (status);
}
/*****************************************************************************/
/*
Search each record of what is presumed to be a plain-text file for the
supplied string. When the first hit occurs output an HTML anchor for
retrieving the entire file. For each hit output an HTML anchor to extract a
specified range of record (lines) from the file. This search only checks for
at least one match in a line before considering it a hit.
*/
SearchTextFile ()
{
int idx,
status,
LastSectionRecordNumber = 1,
RecordNumber = 0,
ByteCount,
HitCount = 0,
MatchedLength;
unsigned long UnixTime;
char *cptr, *rptr, *sptr, *tptr,
*CaseSensitivePtr = "",
*FileNamePathPtr;
char FileSize [32],
LastModifiedTime [64],
Record [MAX_RECORD_SIZE+1],
String [MAX_RECORD_SIZE*2];
struct tm *UnixTmPtr;
struct FAB FileFab;
#ifdef ODS_EXTENDED
struct NAML FileNaml;
#endif /* ODS_EXTENDED */
struct RAB FileRab;
struct XABDAT FileXabDat;
struct XABFHC FileXabFhc;
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "SearchTextFile() |%s|%s|\n", ResFileName, SearchString);
FileFab = cc$rms_fab;
FileFab.fab$b_fac = FAB$M_GET;
FileFab.fab$b_shr = FAB$M_SHRGET | FAB$M_SHRPUT;
FileFab.fab$l_xab = &FileXabDat;
FileXabDat = cc$rms_xabdat;
FileXabDat.xab$l_nxt = &FileXabFhc;
FileXabFhc = cc$rms_xabfhc;
#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 = ResFileName;
FileNaml.naml$l_long_filename_size = ResFileNameLength;
}
else
#endif /* ODS_EXTENDED */
{
FileFab.fab$l_fna = ResFileName;
FileFab.fab$b_fns = ResFileNameLength;
}
status = sys$open (&FileFab, 0, 0);
if (Debug) fprintf (stdout, "sys$open() %%X%08.08X\n", status);
if (VMSnok (status))
{
if (status == RMS$_PRV) return (status);
if (!ListStarted)
{
ListStarted = true;
fputs ("<ol>\n", stdout);
}
fprintf (stdout,
"<li><span class=\"hit\">ERROR opening file (%%X%08.08X) \
%s <!-- %s --></span>\n",
status, FileNamePath, ResFileName);
return (SS$_NORMAL);
}
FileRab = cc$rms_rab;
FileRab.rab$l_fab = &FileFab;
/* 2 buffers and read ahead performance option */
FileRab.rab$b_mbf = 2;
FileRab.rab$l_rop = RAB$M_RAH;
FileRab.rab$l_ubf = Record;
FileRab.rab$w_usz = sizeof(Record)-1;
if (VMSnok (status = sys$connect (&FileRab, 0, 0)))
{
if (Debug) fprintf (stdout, "sys$connect() %%X%08.08X\n", status);
sys$close (&FileFab, 0, 0);
return (status);
}
if (CaseSensitive) CaseSensitivePtr = "&case=yes";
/**********************/
/* search all records */
/**********************/
while (VMSok (status = sys$get (&FileRab, 0, 0)))
{
RecordNumber++;
Record[FileRab.rab$w_rsz] = '\0';
/* terminate on any carriage control that may be in the record */
for (rptr = Record; *rptr && *rptr != '\r' && *rptr != '\n'; rptr++);
*rptr = '\0';
/* if necessary generate document name from first non-blank line */
if (!DocumentName[0]) GenerateDocumentName (Record, DocumentName);
if (*(rptr = Record))
while (*rptr && isspace(*rptr)) rptr++;
if (!*rptr)
{
/* the line contained none, or only white-space characters */
LastSectionRecordNumber = RecordNumber + 1;
continue;
}
tptr = SearchTextString (Record, SearchString,
CaseSensitive, true,
&MatchedLength);
if (tptr != NULL)
{
/********/
/* hit! */
/********/
if (Debug) fprintf (stdout, "Hit |%s|\n", tptr);
TotalHitCount++;
#ifdef ODS_EXTENDED
if (OdsExtended)
FileNamePathPtr =
(char*)CgiLibUrlEncodeFileName (FileNamePath, NULL, 0,
FormatLikeVms, !FormatLikeVms);
else
#endif /* ODS_EXTENDED */
FileNamePathPtr = FileNamePath;
if (!HitCount++)
{
/*************************************/
/* first hit, entire document anchor */
/*************************************/
UnixTime = decc$fix_time (&FileXabDat.xab$q_rdt);
UnixTmPtr = localtime (&UnixTime);
if (!strftime (LastModifiedTime, sizeof(LastModifiedTime),
LastModifiedTimeFormatPtr, UnixTmPtr))
strcpy (LastModifiedTime, "**ERROR**");
/* true for non-VAR record formats, almost true for those :^) */
if (FileXabFhc.xab$l_ebk)
ByteCount = ((FileXabFhc.xab$l_ebk - 1) * 512) +
FileXabFhc.xab$w_ffb;
else
ByteCount = FileXabFhc.xab$w_ffb;
if (ByteCount < 1000)
sprintf (FileSize, "%d bytes", ByteCount);
else
if (ByteCount % 1000 < 500)
sprintf (FileSize, "%d kB", ByteCount/1000);
else
sprintf (FileSize, "%d kB", (ByteCount/1000)+1);
if (!ListStarted)
{
ListStarted = true;
fputs ("<ol>\n", stdout);
}
fprintf (stdout,
"<li><span class=\"hit\">\
<a%s href=\"%s%s?highlight=%s%s%s%s&requery=%s\">%s</a> \
<span class=\"document\">TEXT %s %s</span></span>\n",
TargetPtr, ExtractScriptNamePtr, FileNamePathPtr,
UrlEncodedSearchString,
CaseSensitivePtr, FormText, FormHtml,
RequeryPtr,
DocumentName, LastModifiedTime, FileSize);
if (DocumentOnly) break;
fprintf (stdout, "<ol>\n");
}
/***********************/
/* file extract anchor */
/***********************/
sptr = String;
strcpy (sptr, "<li><span class=\"istext\">");
sptr += 25;
/* absorb leading white-space */
for (cptr = Record; *cptr && (*cptr == ' ' || *cptr == '\t'); cptr++);
/* copy the record up to the first character of the search string */
sptr += CgiLibHtmlEscape (cptr, tptr-cptr, sptr, -1);
/* add the HTML anchor */
sptr += sprintf (sptr, "<a%s href=\"%s%s?highlight=%s&requery=%s",
TargetPtr, ExtractScriptNamePtr, FileNamePathPtr,
UrlEncodedSearchString, RequeryPtr);
if (ExactNumberOfRecords)
sptr += sprintf (sptr, "&start=%d&end=%d&exact=true%s%s\">",
RecordNumber,
RecordNumber+ExtractNumberOfRecords-1,
FormText, FormHtml);
else
sptr += sprintf (sptr, "&start=%d&end=%d%s%s\">",
LastSectionRecordNumber,
RecordNumber+ExtractNumberOfRecords-1,
FormText, FormHtml);
/* matched string, highlighted within the anchor */
sptr += CgiLibHtmlEscape (tptr, MatchedLength, sptr, -1);
strcpy (sptr, "</a>");
sptr += 4;
/* rest of record after the matched search string */
sptr += CgiLibHtmlEscape (tptr+MatchedLength, -1, sptr, -1);
strcpy (sptr, "</span>\n");
sptr += 8;
if (Debug) fprintf (stdout, "String |%s|\n", String);
fputs (String, stdout);
}
}
/***************/
/* end of file */
/***************/
if (status == RMS$_EOF) status = SS$_NORMAL;
sys$close (&FileFab, 0, 0);
if (VMSnok (status))
{
if (!ListStarted)
{
ListStarted = true;
fputs ("<ol>\n", stdout);
}
fprintf (stdout,
"<li><span class=\"hit\">ERROR reading file (%%X%08.08X) \
%s <!-- %s --></span>\n",
status, FileNamePath, ResFileName);
}
if (HitCount)
{
if (!DocumentOnly) fputs ("</ol>\n", stdout);
fflush (stdout);
FileHitCount++;
}
RecordCount += RecordNumber;
return (status);
}
/*****************************************************************************/
/*
Escape HTML forbidden characters such as '<', '>' and '&' - except when the '&'
is the introducer for an HTML entity. Leave the entity intact.
*/
int QueryHtmlEscape
(
char *string,
int length,
char *buf,
int size
)
{
char *aptr, *cptr, *czptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "QueryHtmlEscape() |%s|\n", string);
if (size < 0) size = 1024; /* somewhat arbitrary */
zptr = (sptr = buf) + size;
if (length < 0)
for (cptr = czptr = string; *czptr; czptr++);
else
czptr = (cptr = string) + length;
for (; *cptr && cptr < czptr && sptr < zptr; cptr++)
{
if (*cptr == '&')
{
aptr = cptr + 1;
if (*aptr == '#') aptr++;
while (*aptr && !isspace(*aptr) && !ispunct(*aptr)) aptr++;
if (*aptr == ';')
{
while (cptr < aptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr;
}
else
for (aptr = "&"; *aptr && sptr < zptr; *sptr++ = *aptr++);
}
else
if (*cptr == '<')
for (aptr = "<"; *aptr && sptr < zptr; *sptr++ = *aptr++);
else
if (*cptr == '>')
for (aptr = ">"; *aptr && sptr < zptr; *sptr++ = *aptr++);
else
*sptr++ = *cptr;
}
*sptr = '\0';
length = sptr - buf;
if (sptr >= zptr && length > 10) memcpy (buf, "[OVERFLOW]", 10);
return (length);
}
/*****************************************************************************/
/*
This function serves to generate a document name string (for use in the HTML
<TITLE> tag) for a plain-text file from the first line containing alpha-
numeric characters. Copy the string pointed to by 'sptr' into the string
pointed to by 'NamePtr', compressing white-space.
*/
GenerateDocumentName
(
char *sptr,
char *nptr
)
{
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "GenerateDocumentName() |%s|\n", sptr);
/* skip leading non-alphanumerics */
while (*sptr && !isalnum(*sptr)) sptr++;
while (*sptr)
{
/* copy alphanumeric element */
while (*sptr && !isspace(*sptr) && isalnum(*sptr)) *nptr++ = *sptr++;
if (!*sptr) break;
/* skip intervening/trailing non-alphanumerics */
while (*sptr && !isalnum(*sptr)) sptr++;
if (!*sptr) break;
/* add a single space between alphanumeric elements */
*nptr++ = ' ';
}
*nptr = '\0';
}
/*****************************************************************************/
/*
*/
QueryForm ()
{
char *cptr;
char EscapedPath [ODS_MAX_FILE_NAME_LENGTH+1];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "QueryForm()\n");
FormatLikeVms = false;
for (cptr = CgiPathInfoPtr; *cptr; cptr++);
while (cptr > CgiPathInfoPtr && *cptr != '/')
{
if (*cptr == ';') FormatLikeVms = true;
cptr--;
}
if (FormatLikeVms)
CgiLibHtmlEscape (CgiPathTranslatedPtr, -1,
EscapedPath, sizeof(EscapedPath));
else
CgiLibHtmlEscape (CgiPathInfoPtr, -1,
EscapedPath, sizeof(EscapedPath));
CgiLibResponseHeader (200, "text/html");
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=\"environment\" content=\"%s\">\n\
<title>Search %s</title>\n\
<style type=\"text/css\">\n\
%s\
</style>\n\
%s\
</head>\n\
<body>\n",
SoftwareID,
CgiEnvironmentPtr,
EscapedPath,
DefaultStyle,
StyleSheetPtr);
fprintf (stdout, "<div class=\"header\">Search %s</div>\n", EscapedPath);
fprintf (stdout,
"<div class=\"query\">\n\
<form action=\"%s%s\">\n\
<input type=\"submit\" value=\"Search for:\"> \n\
<input type=\"text\" name=\"search\" size=\"20\"> \n\
<input type=\"reset\" value=\"reset\">\n\
<p>Case sensitive? \n\
<input type=\"radio\" name=\"case\" value=\"N\" checked>No\n\
<input type=\"radio\" name=\"case\" value=\"Y\">Yes\n\
<br>Treat HTML as if plain-text? \n\
<input type=\"radio\" name=\"plain\" value=\"N\" checked>No\n\
<input type=\"radio\" name=\"plain\" value=\"Y\">Yes\n\
<br>Open hit in new page? \n\
<input type=\"radio\" name=\"target\" value=\"_self\" checked>No\n\
<input type=\"radio\" name=\"target\" value=\"_blank\">Yes\n\
<br>Extract this number of lines around a plain-text "hit": \n\
<input type=\"text\" name=\"extract\" value=\"25\" size=\"3\" maxlength=\"3\">\n\
</form>\n\
</div>\n",
CgiScriptNamePtr, CgiPathInfoPtr);
fprintf (stdout,
"<div class=\"footer\">\n\
<div class=\"rfoot\">\n\
<span class=\"about\"><a target=\"_blank\" href=\"%s\">about</a></span>\n\
</div>\n\
</div>\n",
AboutPathPtr);
fprintf (stdout, "</body>\n</html>\n");
}
/****************************************************************************/
/*
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 */
/*****************************************************************************/
/*
Does a case-insensitive, character-by-character string compare and returns
true if two strings are the same, or false if not. If a maximum number of
characters are specified only those will be compared, if the entire strings
should be compared then specify the number of characters as 0.
*/
BOOL strsame
(
char *sptr1,
char *sptr2,
int count
)
{
while (*sptr1 && *sptr2)
{
if (toupper (*sptr1++) != toupper (*sptr2++)) return (false);
if (count)
if (!--count) return (true);
}
if (*sptr1 || *sptr2)
return (false);
else
return (true);
}
/*****************************************************************************/