[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]
/*****************************************************************************/
/*
[WASD]Extract.c
CGI-compliant script (working in concert with QUERY.C) to:
1. extract a specified range of lines from a plain text file
2. anchor hits of the keyword in an HTML file
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 VM syntax file names. If none is
present it supplies URL-encoded file names.
When extracting HTML files it returns the entire document but with each
occurance of the hit enclosed by a '<a name="__hit1__"></a>' anchor that
allows the specific hit to be jumped to with relative document syntax. If an
HTML file is "extracted" without either CGI variable 'form_anchor' or
'form_plain' being non-empty a 302 redirection is generated direct to the
document itself (on the assumption that it is a self-relative link within an
"extract"-anchored document, with the consequent loss of any partial-document
reference (i.e. #blah)). The following tags to not have any content included:
<applet></applet>, <head></head>, <script></script>, <server></server>,
<title></title>.
"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_*").
CGI FORM ELEMENTS
-----------------
form_anchor= introduce "hit" anchors into an HTML file
form_case= was a case sensitive search (Y or N)
form_end= record (line) number to being extract
form_exact= exact number of records (Y or N)
form_extract= number of line to pass to extract utility
form_highlight= the string to be highlighted
form_html= comma-separated list of HTML file extensions
(overrides the /HTML and /ADDHTML qualifiers)
form_plain= treat an HTML file as plain text
form_requery= URI used for the query and for the requery link
form_start= record (line) number to being extract
form_text= comma-separated list of text file extensions
(overrides the /TEXT and /ADDTEXT qualifiers)
Generally these form elements will be generated by QUERY.C but there is no
reasons why they shouldn't come from somewhere else.
LOGICAL NAMES
-------------
EXTRACT$DBUG turns on all "if (Debug)" statements
EXTRACT$PARAM equivalent to (overrides) the command line
parameters/qualifiers (define as a system-wide logical)
QUALIFIERS
----------
/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
/[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
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.
"VANILLA" CGI ENVIRONMENT
-------------------------
Primarily for the likes of Netscape FastTrack. This environment can accomodate
CGI variables that are not prefixed with "WWW_" and do not supply "KEY_xxxxx"
or "FORM_xxxxx" (which must be derived from "QUERY_STRING"). Full HTTP stream
(non-parsed header) is assumed as not supported so all output occurs with a
CGI-compliant header line (e.g. "Status: 200 Success") and record-oriented
output.
BUILD DETAILS
-------------
See BUILD_EXTRACT.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, highlighted hits now using <span id=".."></span>
use "athitof" instead of "__hit__"
bugfix; style tag processing
12-MAR-2020 MGD v4.1.0, ensure CGI response if no extract
04-OCT-2014 MGD v4.0.0, a nod to the twenty-first century
13-NOV-2011 MGD v3.3.3, bugfix; <!-- --> tag counting
10-MAY-2005 MGD v3.3.2, SWS 2.0 ignore query string components supplied as
command-line parameters differently to CSWS 1.2/3
23-DEC-2003 MGD v3.3.1, minor conditional mods to support IA64
23-JUN-2003 MGD v3.3.0, record size increased to maximum (32767 bytes)
12-APR-2003 MGD v3.2.4, link colour changed to 0000cc
15-AUG-2002 MGD v3.2.3, GetParameters() mod for direct CSWS 1.2 support
01-JUL-2001 MGD v3.2.2, add 'SkipParameters' for direct OSU support
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.7.0, use more of the CGILIB functionality
24-APR-1999 MGD v2.6.0, use CGILIB.C,
standard CGI environment (Netscape FastTrack)
20-NOV-1998 MGD v2.5.1, exclude certain content (e.g. <SCRIPT>...</SCRIPT)
07-NOV-1998 MGD v2.5.0, anchor hits within an HTML document
03-OCT-1998 MGD v2.4.0, general maintenance in-line with query.,
provide content-type "; charset=...",
accomodations for OSU environment
24-JUL-1998 MGD v2.3.1, suppress table background colours if empty
20-MAY-1998 MGD v2.3.0, general maintenance,
cosmetic changes
19-SEP-1995 MGD v2.2.1, replace <CR><LF> carriage-control with single <LF>,
still acceptable for HTTP, slightly more efficient;
added 'previous' and 'next' number of lines link
24-MAY-1995 MGD v2.2.0, minor changes for AXP compatibility
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 "EXTRACT"
#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>
/* 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__
/* macro provides NULL pointer if CGI variable does not exist */
#define GetCgiVarIfExists(CharPointer,CgiVariableName) \
CharPointer = getenv(CgiVariableName)
/* macro provides pointer to empty string even if CGI variable does not exist */
#define GetCgiVar(CharPointer,CgiVariableName) \
if ((CharPointer = getenv(CgiVariableName)) == NULL) \
CharPointer = ""; \
if (Debug) fprintf (stdout, "%s |%s|\n", CgiVariableName, CharPointer);
/* use this character to mask out HTML tag characters when searching */
#define MASK_TAG_CHAR '\xff'
char DefaultHtmlTypes [] = DEFAULT_HTML_TYPES,
DefaultStyle [] = DEFAULT_EXTRACT_STYLE,
DefaultTextTypes [] = DEFAULT_TEXT_TYPES,
Utility [] = "EXTRACT";
BOOL Debug,
FormatLikeVms,
ThereHasBeenOutput;
int ExtractNumberOfRecords,
OdsExtended;
char ContentTypeCharset [64],
SoftwareID [48];
char *AboutPathPtr = DEFAULT_ABOUT_PATH,
*CgiEnvironmentPtr,
*CgiFormAnchorPtr,
*CgiFormExactPtr,
*CgiFormCasePtr,
*CgiFormEndPtr,
*CgiFormHighlightPtr,
*CgiFormHtmlPtr,
*CgiFormPlainPtr,
*CgiFormRequeryPtr,
*CgiFormStartPtr,
*CgiFormTextPtr,
*CgiPathInfoPtr,
*CgiPathTranslatedPtr,
*CgiRequestMethodPtr,
*CgiRequestSchemePtr,
*CgiScriptNamePtr,
*CgiServerNamePtr,
*CgiServerSoftwarePtr,
*CgiServerPortPtr,
*CharsetPtr,
*CliCharsetPtr,
*HtmlFileTypesPtr = DefaultHtmlTypes,
*StyleSheetPtr = "",
*TextFileTypesPtr = DefaultTextTypes,
*UrlEncodedPathInfoPtr,
*UrlEncodedRequeryPtr;
/* required prototypes */
char* SearchTextString (char*, char*, BOOL, BOOL, int*);
/*****************************************************************************/
/*
'argc/argv' are only required to support OSU, in particular CgiLibOsuInit().
*/
main
(
int argc,
char *argv[]
)
{
BOOL CaseSensitive = false,
DocumentOnly = false;
int status,
EndRecordNumber,
StartRecordNumber;
char *cptr;
char ServerPort [32],
String [512];
/*********/
/* begin */
/*********/
sprintf (SoftwareID, "%s (%s)", SOFTWAREID, CgiLibEnvironmentVersion());
if (getenv ("EXTRACT$DBUG") != NULL) Debug = true;
CgiLibEnvironmentSetDebug (Debug);
if (Debug) fprintf (stdout, "Content-Type: text/plain\n\n");
CgiLibEnvironmentInit (argc, argv, false);
CgiEnvironmentPtr = CgiLibEnvironmentName ();
GetParameters ();
CgiLibResponseSetCharset (CliCharsetPtr);
CgiLibResponseSetSoftwareID (SoftwareID);
CgiLibResponseSetErrorMessage ("Reported by WASDextract");
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 */
#ifdef ODS_EXTENDED
OdsExtended = (GetVmsVersion() >= 72);
#endif /* ODS_EXTENDED */
if (Debug)
fprintf (stdout, "TextFileTypesPtr |%s|\n", TextFileTypesPtr);
if (!*TextFileTypesPtr)
{
CgiLibResponseError (FI_LI, 0, "Text file extensions not configured.");
exit (SS$_NORMAL);
}
if (Debug)
fprintf (stdout, "HtmlFileTypesPtr |%s|\n", HtmlFileTypesPtr);
if (!*HtmlFileTypesPtr)
{
CgiLibResponseError (FI_LI, 0, "HTML file extensions not configured.");
exit (SS$_NORMAL);
}
CgiServerSoftwarePtr = CgiVar ("WWW_SERVER_SOFTWARE");
CgiRequestMethodPtr = CgiVar ("WWW_REQUEST_METHOD");
if (strcmp (CgiRequestMethodPtr, "GET"))
{
CgiLibResponseHeader (501, "text/html");
fprintf (stdout, "Not implemented!\n");
return;
}
CgiPathInfoPtr = CgiVar ("WWW_PATH_INFO");
CgiPathTranslatedPtr = CgiVar ("WWW_PATH_TRANSLATED");
CgiScriptNamePtr = CgiVar ("WWW_SCRIPT_NAME");
CgiFormAnchorPtr = CgiVar ("WWW_FORM_ANCHOR");
CgiFormCasePtr = CgiVar ("WWW_FORM_CASE");
CgiFormEndPtr = CgiVar ("WWW_FORM_END");
CgiFormExactPtr = CgiVar ("WWW_FORM_EXACT");
CgiFormHighlightPtr = CgiVar ("WWW_FORM_HIGHLIGHT");
CgiFormHtmlPtr = CgiVar ("WWW_FORM_HTML");
CgiFormPlainPtr = CgiVar ("WWW_FORM_PLAIN");
CgiFormRequeryPtr = CgiVar ("WWW_FORM_REQUERY");
CgiFormStartPtr = CgiVar ("WWW_FORM_START");
CgiFormTextPtr = CgiVar ("WWW_FORM_TEXT");
UrlEncodedRequeryPtr = (char*)CgiLibUrlEncode (CgiFormRequeryPtr,
-1, NULL, -1);
if (toupper(CgiFormCasePtr[0]) == 'Y')
CaseSensitive = true;
else
CaseSensitive = false;
CgiFormExactPtr[0] = toupper(CgiFormExactPtr[0]);
StartRecordNumber = atoi (CgiFormStartPtr);
EndRecordNumber = atoi (CgiFormEndPtr);
if (CgiFormHtmlPtr[0]) HtmlFileTypesPtr = CgiFormHtmlPtr;
if (CgiFormTextPtr[0]) TextFileTypesPtr = CgiFormTextPtr;
FormatLikeVms = false;
for (cptr = CgiPathInfoPtr; *cptr; cptr++);
while (cptr > CgiPathInfoPtr && *cptr != '/')
{
if (*cptr == ';') FormatLikeVms = true;
cptr--;
}
#ifdef ODS_EXTENDED
if (OdsExtended)
{
/* re-encode the path in case it's an extended file specification */
UrlEncodedPathInfoPtr = (char*)CgiLibUrlEncode (CgiPathInfoPtr,
-1, NULL, -1);
}
else
#endif /* ODS_EXTENDED */
UrlEncodedPathInfoPtr = CgiPathInfoPtr;
for (cptr = CgiPathTranslatedPtr; *cptr; cptr++);
while (cptr > CgiPathTranslatedPtr && *cptr != '.') cptr--;
if (*cptr == '.') cptr++;
if (SameFileType (HtmlFileTypesPtr, cptr))
{
/*************/
/* HTML file */
/*************/
if (CgiFormAnchorPtr[0])
{
/*******************/
/* provide anchors */
/*******************/
status = AnchorHtmlFile (CgiPathTranslatedPtr,
CgiFormHighlightPtr,
CaseSensitive);
if (VMSnok (status))
CgiLibResponseError (FI_LI, status, UrlEncodedPathInfoPtr);
}
else
if (CgiFormPlainPtr[0])
{
/**************************/
/* treat as if plain text */
/**************************/
status = ExtractTextFile (CgiPathTranslatedPtr,
CgiFormHighlightPtr,
StartRecordNumber, EndRecordNumber,
CaseSensitive);
if (VMSnok (status))
CgiLibResponseError (FI_LI, status, UrlEncodedPathInfoPtr);
}
else
{
/************/
/* redirect */
/************/
CgiLibResponseRedirect (UrlEncodedPathInfoPtr);
}
}
else
if (SameFileType (TextFileTypesPtr, cptr))
{
/*************/
/* text file */
/*************/
status = ExtractTextFile (CgiPathTranslatedPtr,
CgiFormHighlightPtr,
StartRecordNumber, EndRecordNumber,
CaseSensitive);
if (VMSnok (status))
CgiLibResponseError (FI_LI, status, UrlEncodedPathInfoPtr);
}
else
{
/*********************/
/* unknown file type */
/*********************/
/* just return the document/image/file via redirection */
CgiLibResponseRedirect (UrlEncodedPathInfoPtr);
}
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 ("EXTRACT$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())
if (getenv ("WWWEXEC_RUNDOWN_STRING") != NULL)
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, "/ABOUT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
AboutPathPtr = cptr;
continue;
}
if (strsame (aptr, "/APACHE", 4))
{
/* just skip this marker for command-line parameters under SWS 2.0 */
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, "/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 (*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);
}
}
}
/*****************************************************************************/
/*
Extract the specified record (line) range from a plain-text file. If the
search string is supplied then highlight the first matched string in any line.
*/
int ExtractTextFile
(
char *FileName,
char *HighlightString,
int StartRecordNumber,
int EndRecordNumber,
BOOL CaseSensitive
)
{
int status,
NumberOfRecords,
RecordNumber = 0,
HighlightStringLength = 0;
char *rptr, *sptr;
char EscapedPath [ODS_MAX_FILE_NAME_LENGTH+1],
EscHighlightString [256],
ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1],
Record [MAX_RECORD_SIZE+1],
String [MAX_RECORD_SIZE*2],
UrlEncodedHighlightString [256] = "";
struct FAB FileFab;
struct RAB FileRab;
#ifdef ODS_EXTENDED
struct NAML FileNaml;
#endif /* ODS_EXTENDED */
struct NAM FileNam;
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "ExtractTextFile() |%s|%s|\n",
FileName, HighlightString);
if (EndRecordNumber > StartRecordNumber)
NumberOfRecords = EndRecordNumber - StartRecordNumber;
else
NumberOfRecords = 0;
if (HighlightString[0])
{
HighlightStringLength = strlen(HighlightString);
CgiLibUrlEncode (HighlightString, -1, UrlEncodedHighlightString, -1);
}
FileFab = cc$rms_fab;
FileFab.fab$b_fac = FAB$M_GET;
FileFab.fab$b_shr = FAB$M_SHRGET;
#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 = FileName;
FileNaml.naml$l_long_filename_size = strlen(FileName);
FileNaml.naml$l_long_expand = ExpFileName;
FileNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
FileFab.fab$l_fna = FileName;
FileFab.fab$b_fns = strlen(FileName);
FileFab.fab$l_nam = &FileNam;
FileNam = cc$rms_nam;
FileNam.nam$l_esa = ExpFileName;
FileNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
}
if (VMSnok (status = sys$open (&FileFab, 0, 0)))
{
/* if its a search list treat directory not found as if file not found */
#ifdef ODS_EXTENDED
if (OdsExtended)
{
if ((FileNaml.naml$l_fnb & NAM$M_SEARCH_LIST) && status == RMS$_DNF)
status = RMS$_FNF;
}
else
#endif /* ODS_EXTENDED */
{
if ((FileNam.nam$l_fnb & NAM$M_SEARCH_LIST) && status == RMS$_DNF)
status = RMS$_FNF;
}
if (Debug) fprintf (stdout, "sys$open() %%X%08.08X\n", status);
return (status);
}
#ifdef ODS_EXTENDED
if (OdsExtended)
{
/* if explicit version number display in VMS extended file syntax */
if (FormatLikeVms)
UrlEncodedPathInfoPtr = (char*)CgiLibHtmlEscape (CgiPathInfoPtr,
-1, NULL, -1);
}
#endif /* ODS_EXTENDED */
if (FormatLikeVms)
CgiLibHtmlEscape (CgiPathTranslatedPtr, -1,
EscapedPath, sizeof(EscapedPath));
else
CgiLibHtmlEscape (CgiPathInfoPtr, -1, EscapedPath, sizeof(EscapedPath));
CgiLibHtmlEscape (HighlightString, -1,
EscHighlightString, sizeof(EscHighlightString));
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);
}
/**************/
/* begin page */
/**************/
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\
<meta name=\"text-types\" content=\"%s\">\n\
<meta name=\"html-types\" content=\"%s\">\n\
<title>Extract %s of "%s"</title>\n\
<style type=\"text/css\">\n\
%s\
</style>\n\
%s\
</head>\n\
<body>\n",
SoftwareID,
CgiEnvironmentPtr,
TextFileTypesPtr,
HtmlFileTypesPtr,
EscapedPath,
EscHighlightString,
DefaultStyle,
StyleSheetPtr);
fprintf (stdout,
"<div class=\"header\">Extract %s of "%s"</div>\n",
EscapedPath, EscHighlightString);
fflush (stdout);
/*******************/
/* extract records */
/*******************/
while (VMSok (status = sys$get (&FileRab, 0, 0)))
{
RecordNumber++;
Record[FileRab.rab$w_rsz] = '\0';
if (Debug) fprintf (stdout, "Record |%d|%s|\n", RecordNumber, Record);
/* terminate at any carriage control that may be in the record */
for (rptr = Record; *rptr && *rptr != '\r' && *rptr != '\n'; rptr++);
*rptr = '\0';
if (StartRecordNumber && RecordNumber < StartRecordNumber) continue;
if (!ThereHasBeenOutput && !Record[0]) continue;
if (!ThereHasBeenOutput)
{
if (StartRecordNumber)
{
if (EndRecordNumber && StartRecordNumber - NumberOfRecords > 0)
{
fprintf (stdout,
"<div class=\"buttonbar butbartop\">\n\
<div class=\"beginend\">Begins at line %d, retrieve \
<a href=\"%s%s?highlight=%s&start=%d&end=%d&requery=%s\">\
previous %d lines</a> or \
<a href=\"%s%s?highlight=%s&requery=%s\">entire document</a> \
or <a href=\"%s\">file</a></div>\n",
StartRecordNumber,
CgiScriptNamePtr,
UrlEncodedPathInfoPtr,
UrlEncodedHighlightString,
StartRecordNumber-NumberOfRecords-1,
StartRecordNumber-1,
UrlEncodedRequeryPtr,
NumberOfRecords+1,
CgiScriptNamePtr,
UrlEncodedPathInfoPtr,
UrlEncodedHighlightString,
UrlEncodedRequeryPtr,
UrlEncodedPathInfoPtr);
}
else
{
fprintf (stdout,
"<div class=\"buttonbar butbartop\">\n\
<div class=\"beginend\">Begins at line %d, retrieve \
<a href=\"%s%s?highlight=%s&requery=%s\">entire document</a> \
or <a href=\"%s\">file</a></div>\n",
RecordNumber,
CgiScriptNamePtr,
UrlEncodedPathInfoPtr,
UrlEncodedHighlightString,
UrlEncodedRequeryPtr,
UrlEncodedPathInfoPtr);
}
}
else
{
if (EndRecordNumber)
{
fprintf (stdout,
"<div class=\"buttonbar butbartop\">\n\
<div class=\"beginend\">Begins at line %d (start of document), retrieve \
<a href=\"%s%s?highlight=%s&requery=%s\">entire document</a> \
or <a href=\"%s\">file</a></div>\n",
RecordNumber,
CgiScriptNamePtr,
UrlEncodedPathInfoPtr,
UrlEncodedHighlightString,
UrlEncodedRequeryPtr,
UrlEncodedPathInfoPtr);
}
else
fprintf (stdout,
"<div class=\"buttonbar butbartop\">\n\
<div class=\"beginend\">Entire document, retrieve \
<a href=\"%s\">file</a></div>\n",
UrlEncodedPathInfoPtr);
}
fprintf (stdout,
"<div class=\"otherbutton\">\n\
<a %s\"%s\">Requery</a>\n\
<a target=\"_blank\" href=\"%s\">About</a>\n\
</div>\n\
</div>\n",
CgiFormRequeryPtr[0] ? "href=" : "blah=",
CgiFormRequeryPtr,
AboutPathPtr);
fputs ("<pre>\n", stdout);
fflush (stdout);
ThereHasBeenOutput = true;
}
/******************/
/* process record */
/******************/
if (EndRecordNumber && RecordNumber > EndRecordNumber)
{
if (CgiFormExactPtr[0] == 'T' || CgiFormExactPtr[0] == 'Y') break;
/* if this is an empty (blank) line then end-of-section */
if (!FileRab.rab$w_rsz) break;
/* if there is only white-space in this line then end-of-section */
for (rptr = Record; *rptr && isspace(*rptr); rptr++);
if (!*rptr) break;
}
rptr = SearchTextString (Record, HighlightString,
CaseSensitive, true, NULL);
if (rptr != NULL)
{
/***********************************/
/* hit! - Highlight matched string */
/***********************************/
sptr = String;
/* copy the record up to the first character of the search string */
sptr += CgiLibHtmlEscape (Record, rptr-Record, sptr, -1);
/* emphasize the matched search string */
strcpy (sptr, "<span class=\"highlight\">");
sptr += 24;
sptr += CgiLibHtmlEscape (rptr, HighlightStringLength, sptr, -1);
strcpy (sptr, "</span>");
sptr += 7;
/* rest of record after the matched search string */
sptr += CgiLibHtmlEscape (rptr+HighlightStringLength, -1, sptr, -1);
*sptr++ = '\n'; *sptr = '\0';
}
else
{
/**********/
/* no hit */
/**********/
sptr = String;
sptr += CgiLibHtmlEscape (Record, -1, sptr, -1);
*sptr++ = '\n'; *sptr = '\0';
}
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);
/*********************/
/* bottom button bar */
/*********************/
if (ThereHasBeenOutput) fputs ("</pre>\n", stdout);
if (StartRecordNumber)
{
if (EndRecordNumber && RecordNumber > EndRecordNumber)
{
fprintf (stdout,
"<div class=\"buttonbar\">\n\
<div class=\"beginend\">Ends at line %d, \
retrieve <a href=\"%s%s?highlight=%s&start=%d&end=%d&requery=%s\">\
next %d lines</a> or \
<a href=\"%s%s?highlight=%s&start=%d&requery=%s\">rest of document</a> \
or <a href=\"%s\">file</a></div>\n",
RecordNumber-1,
CgiScriptNamePtr,
UrlEncodedPathInfoPtr,
UrlEncodedHighlightString,
RecordNumber,
RecordNumber+NumberOfRecords,
UrlEncodedRequeryPtr,
NumberOfRecords+1,
CgiScriptNamePtr,
UrlEncodedPathInfoPtr,
UrlEncodedHighlightString,
RecordNumber,
UrlEncodedRequeryPtr,
UrlEncodedPathInfoPtr);
}
else
{
fprintf (stdout,
"<div class=\"buttonbar\">\n\
<div class=\"beginend\">Ends at line %d (end of document), \
retrieve <a href=\"%s%s?highlight=%s&requery=%s\">entire document</a> \
or <a href=\"%s\">file</a></div>\n",
RecordNumber,
CgiScriptNamePtr,
UrlEncodedPathInfoPtr,
UrlEncodedHighlightString,
UrlEncodedRequeryPtr,
UrlEncodedPathInfoPtr);
}
}
else
fprintf (stdout, "<div class=\"buttonbar\">\n\
<div class=\"beginend\">Entire document, \
retrieve <a href=\"%s\">file</a></div>\n",
UrlEncodedPathInfoPtr);
fprintf (stdout,
"<div class=\"otherbutton\">\n\
<a %s\"%s\">Requery</a>\n\
<a target=\"_blank\" href=\"%s\">About</a>\n\
</div>\n\
</div>\n",
CgiFormRequeryPtr[0] ? "href=" : "blah=",
CgiFormRequeryPtr,
AboutPathPtr);
fprintf (stdout, "</body>\n</html>\n");
return (status);
}
/*****************************************************************************/
/*
Add an HTML anchor around each highlight string corresonding to the hit number
displayed by query (<a name="athitof1">blah</a>). Due to the way the search
string is located within the HTML tags (by masking them out) it is possible
that search strings containg HTML entities may not be correctly found by this
function. The incidence of this should be quite low so abosulute accuracy has
been sacrificed to ease (and speed) in programming it.
*/
int AnchorHtmlFile
(
char *FileName,
char *HighlightString,
BOOL CaseSensitive
)
{
BOOL InsideApplet = false,
InsideComment = false,
InsideHead = false,
InsideScript = false,
InsideServer = false,
InsideStyle = false,
InsideTitle = false;
int status,
HighlightStringLength = 0,
HitCount = 0,
TagCharCount = 0;
char ch;
char *cptr, *rptr, *sptr, *tptr;
char ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1],
Record [MAX_RECORD_SIZE+1],
String [MAX_RECORD_SIZE*2],
Text [MAX_RECORD_SIZE*2],
UrlEncodedHighlightString [256] = "";
struct FAB FileFab;
struct RAB FileRab;
#ifdef ODS_EXTENDED
struct NAML FileNaml;
#endif /* ODS_EXTENDED */
struct NAM FileNam;
/*********/
/* begin */
/*********/
if (Debug)
fprintf (stdout, "AnchorHtmlFile() |%s|%s|\n",
FileName, HighlightString);
if (HighlightString[0])
{
HighlightStringLength = strlen(HighlightString);
CgiLibUrlEncode (HighlightString, -1, UrlEncodedHighlightString, -1);
}
FileFab = cc$rms_fab;
FileFab.fab$b_fac = FAB$M_GET;
FileFab.fab$b_shr = FAB$M_SHRGET;
#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 = FileName;
FileNaml.naml$l_long_filename_size = strlen(FileName);
FileNaml.naml$l_long_expand = ExpFileName;
FileNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
FileFab.fab$l_fna = FileName;
FileFab.fab$b_fns = strlen(FileName);
FileFab.fab$l_nam = &FileNam;
FileNam = cc$rms_nam;
FileNam.nam$l_esa = ExpFileName;
FileNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
}
if (VMSnok (status = sys$open (&FileFab, 0, 0)))
{
/* if its a search list treat directory not found as if file not found */
#ifdef ODS_EXTENDED
if (OdsExtended)
{
if ((FileNaml.naml$l_fnb & NAM$M_SEARCH_LIST) && status == RMS$_DNF)
status = RMS$_FNF;
}
else
#endif /* ODS_EXTENDED */
{
if ((FileNam.nam$l_fnb & NAM$M_SEARCH_LIST) && status == RMS$_DNF)
status = RMS$_FNF;
}
if (Debug) fprintf (stdout, "sys$open() %%X%08.08X\n", status);
return (status);
}
#ifdef ODS_EXTENDED
if (OdsExtended)
{
/* if explicit version number display in VMS extended file syntax */
if (FormatLikeVms)
UrlEncodedPathInfoPtr = (char*)CgiLibHtmlEscape (CgiPathInfoPtr,
-1, NULL, -1);
}
#endif /* ODS_EXTENDED */
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);
}
/*******************/
/* extract records */
/*******************/
while (VMSok (status = sys$get (&FileRab, 0, 0)))
{
Record[FileRab.rab$w_rsz] = '\0';
if (Debug) fprintf (stdout, "Record |%s|\n", Record);
/* terminate at any carriage control that may be in the record */
for (rptr = Record; *rptr && *rptr != '\r' && *rptr != '\n'; rptr++);
/* add a single new-line carriage-control */
*rptr++ = '\n';
*rptr = '\0';
if (!ThereHasBeenOutput)
{
/**************/
/* begin page */
/**************/
CgiLibResponseHeader (200, "text/html");
ThereHasBeenOutput = true;
}
/**************************************/
/* retrieve text not inside HTML tags */
/**************************************/
tptr = Text;
rptr = Record;
while (*rptr)
{
if (InsideComment)
{
if (rptr[0] == '-' && rptr[1] == '-' && rptr[2] == '>')
{
InsideComment = false;
memset (tptr, MASK_TAG_CHAR, 3);
tptr += 3;
rptr += 3;
TagCharCount++;
}
else
{
*tptr++ = MASK_TAG_CHAR;
rptr++;
}
continue;
}
if (*((USHORTPTR)rptr) == '</')
{
if (InsideApplet)
{
if (strsame (rptr, "</applet>", 9))
{
InsideApplet = false;
memset (tptr, MASK_TAG_CHAR, 9);
tptr += 9;
rptr += 9;
continue;
}
}
if (InsideHead)
{
if (strsame (rptr, "</head>", 7))
{
InsideHead = false;
memset (tptr, MASK_TAG_CHAR, 7);
tptr += 7;
rptr += 7;
continue;
}
}
if (InsideScript)
{
if (strsame (rptr, "</script>", 9))
{
InsideScript = false;
memset (tptr, MASK_TAG_CHAR, 9);
tptr += 9;
rptr += 9;
continue;
}
}
if (InsideServer)
{
if (strsame (rptr, "</server>", 9))
{
InsideServer = false;
memset (tptr, MASK_TAG_CHAR, 9);
tptr += 9;
rptr += 9;
continue;
}
}
if (InsideStyle)
{
if (strsame (rptr, "</style>", 8))
{
InsideStyle = false;
memset (tptr, MASK_TAG_CHAR, 8);
tptr += 8;
rptr += 8;
continue;
}
}
if (InsideTitle)
{
if (strsame (rptr, "</title>", 7))
{
InsideTitle = false;
memset (tptr, MASK_TAG_CHAR, 7);
tptr += 7;
rptr += 7;
continue;
}
}
}
if (*rptr == '<')
{
if (*((ULONGPTR)rptr) == '<!--')
{
InsideComment = true;
memset (tptr, MASK_TAG_CHAR, 4);
tptr += 4;
rptr += 4;
TagCharCount++;
continue;
}
if (strsame (rptr, "<applet>", 8) ||
strsame (rptr, "<applet ", 8))
{
InsideApplet = true;
memset (tptr, MASK_TAG_CHAR, 8);
tptr += 8;
rptr += 7;
TagCharCount++;
continue;
}
if (strsame (rptr, "<body>", 6) ||
strsame (rptr, "<body ", 6))
{
InsideHead = false;
memset (tptr, MASK_TAG_CHAR, 5);
tptr += 6;
rptr += 5;
TagCharCount++;
continue;
}
if (strsame (rptr, "<head>", 6) ||
strsame (rptr, "<head ", 6))
{
InsideHead = true;
memset (tptr, MASK_TAG_CHAR, 6);
tptr += 6;
rptr += 5;
TagCharCount++;
continue;
}
if (strsame (rptr, "<script>", 8) ||
strsame (rptr, "<script ", 8))
{
InsideScript = true;
memset (tptr, MASK_TAG_CHAR, 8);
tptr += 8;
rptr += 7;
TagCharCount++;
continue;
}
if (strsame (rptr, "<server>", 8) ||
strsame (rptr, "<server ", 8))
{
InsideServer = true;
memset (tptr, MASK_TAG_CHAR, 8);
tptr += 8;
rptr += 7;
TagCharCount++;
continue;
}
if (strsame (rptr, "<style>", 7) ||
strsame (rptr, "<style ", 7))
{
InsideStyle = true;
memset (tptr, MASK_TAG_CHAR, 7);
tptr += 7;
rptr += 6;
TagCharCount++;
continue;
}
if (strsame (rptr, "<title>", 7) ||
strsame (rptr, "<title ", 7))
{
InsideTitle = true;
memset (tptr, MASK_TAG_CHAR, 7);
tptr += 7;
rptr += 6;
TagCharCount++;
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++;
*tptr++ = MASK_TAG_CHAR;
}
else
if (InsideApplet || InsideHead || InsideScript ||
InsideServer || InsideStyle || InsideTitle)
{
rptr++;
*tptr++ = MASK_TAG_CHAR;
}
else
{
if (TagCharCount & 1)
{
rptr++;
*tptr++ = MASK_TAG_CHAR;
}
else
{
if (*rptr == '&')
{
if (strsame (rptr, "<", 4))
{
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = '<';
rptr += 4;
}
else
if (strsame (rptr, ">", 4))
{
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = '>';
rptr += 4;
}
else
if (strsame (rptr, "&", 5))
{
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = '&';
rptr += 5;
}
else
if (strsame (rptr, """, 6))
{
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = '\"';
rptr += 6;
}
else
if (strsame (rptr, " ", 6))
{
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
*tptr++ = ' ';
rptr += 6;
}
else
if (*(rptr+1) == '#')
{
*tptr++ = MASK_TAG_CHAR;
*tptr++ = MASK_TAG_CHAR;
for (cptr = rptr+2; *cptr && isdigit(*cptr); cptr++)
*tptr++ = MASK_TAG_CHAR;
if (*cptr == ';')
{
ch = atoi(rptr+2) & 0xff;
*tptr++ = ch;
rptr = cptr + 1;
}
else
*tptr++ = *rptr++;
}
else
*tptr++ = *rptr++;
}
else
*tptr++ = *rptr++;
}
}
} /* while (*rptr) */
*tptr = '\0';
if (!Text[0]) continue;
tptr = SearchTextString (Text, HighlightString,
CaseSensitive, true, NULL);
if (tptr != NULL)
{
/***********************************/
/* hit! - Highlight matched string */
/***********************************/
HitCount++;
/* copy the record up to the first character of the search string */
rptr = Record;
sptr = String;
cptr = Text;
while (cptr < tptr)
{
*sptr++ = *rptr++;
cptr++;
}
/* anchor the matched search string */
sptr += sprintf (sptr, "<span class=\"athitof\" id=\"athitof%d\">",
HitCount);
tptr += HighlightStringLength;
while (cptr < tptr)
{
*sptr++ = *rptr++;
cptr++;
}
strcpy (sptr, "</span>");
sptr += 7;
/* rest of record after the matched search string */
while (*rptr) *sptr++ = *rptr++;
*sptr++ = '\n';
*sptr = '\0';
if (Debug) fprintf (stdout, "String |%s|\n", String);
fputs (String, stdout);
}
else
{
/**********/
/* no hit */
/**********/
if (Debug) fprintf (stdout, "Record |%s|\n", Record);
fputs (Record, stdout);
}
}
/***************/
/* end of file */
/***************/
if (status == RMS$_EOF) status = SS$_NORMAL;
sys$close (&FileFab, 0, 0);
/* CSS often inserts line break before id=".." hence the "display:inline" */
fprintf (stdout,
"<style type=\"text/css\"> \
.athitof { border:1px dotted slategray; \
padding:1px 2px 1px 2px; background-color:yellow; } \
.athitof::before { display:inline; } \
</style>\n\
<!-- hits anchored by: %s -->\n", SoftwareID);
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"). It returns true if the file type is in the list,
false if not.
*/
BOOL SameFileType
(
char *TypeList,
char *FileType
)
{
char ch;
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SameFileType() |%s|%s|\n", FileType, TypeList);
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;
}
}
}
/****************************************************************************/
/*
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);
}
/****************************************************************************/