[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]
/*****************************************************************************
/*
Str[i]ng.c
String support functions for HTTPd.
Traditional U**x regular expressions:
http://en.wikipedia.org/wiki/Regular_expression
VERSION HISTORY
---------------
26-FEB-2021 MGD stristr() case insensitive strstr()
StringReplace() case insensitive string replacement
14-DEC-2018 MGD bugfix; for bugfix StringSliceValue() kludge
allow for DECnet connection string specified username
15-AUG-2018 MGD bugfix; StringSliceValue() kludge for DECnet tasks
(25-MAY-2017 allow quote-delim inside space-delimited)
28-APR-2018 MGD refactor Admin..() AST delivery
25-MAY-2017 MGD StringSliceValue() allow quote-delim inside space-delimited
07-JAN-2016 MGD StringSpanValue() now StringSlice[s]Value() and dices
25-AUG-2015 MGD StringMatchAndRegex() ensure |rqptr| not needed
02-JAN-2011 MGD StringMatchAndRegex() support configurable regex syntax
StringMatchReport() provide configurable regex syntax
14-OCT-2006 MGD bugfix; StringMatchAndRegex() regular expression
'MatchType' detection prior to pre-match
added REG_NEWLINE to REGEX_C_FLAGS so that anchors match
newlines in strings to support 'Request' filter in WATCH
30-JUL-2004 MGD bugfix; StringMatchAndRegex() SMATCH__GREEDY_REGEX
09-SEP-2003 MGD bugfix; StringSpanValue()
06-JUL-2003 MGD StringParseValue() modified to accept a parenthesis
delimited, comma-separated list of quoted strings
03-MAY-2003 MGD StringMatchAndRegex() regular expression support
StringMatchSubstitute() substitute matched strings
StringMatchReport() server admin facility
14-FEB-2003 MGD bugfix; StringParseQuery() loop on string overflow
31-JAN-2003 MGD strzcpy() now returns the length of the source, not
necessarily, the copied string (allows overflow check)
08-NOV-2002 MGD StringSpanValue(), StringParseValue(),
StringStripValue() now terminate on newline
16-OCT-2002 MGD add StringScriptValue(),
refine StringSpanValue(), StringParseValue()
08-AUG-2002 MGD add StringUrlEncodeURL()
12-JAN-2002 MGD added '**' wildcard match to StringMatch(),
bugfix; StringMatch() wildcard matching
13-OCT-2001 MGD uncoupled from SUPPORT.C,
StringMatch() replaces SearchTextString()
for more light-weight text matching,
StringSpanValue(), StringParseValue(),
StringParseNameValue()
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#undef __VMS_VER
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* VMS related header files */
#include <ssdef.h>
#include <stsdef.h>
/* application related header files */
#include "wasd.h"
#define WASD_MODULE "STRNG"
/********************/
/* external storage */
/********************/
#ifdef DBUG
extern BOOL Debug;
#else
#define Debug 0
#endif
extern int ToLowerCase[],
ToUpperCase[];
extern char *FaoUrlEncodeTable[];
extern char ErrorSanityCheck[];
extern CONFIG_STRUCT Config;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Case insensitive wildcard string match or regular expression match.
StringMatch() and StringMatchGreedy() are macros for this function using fixed
values for 'MatchType', and a 'pregptr' and 'pmatchptr' of NULL. StringMatch()
is non-greedy and StringMatchGreedy() the greedy verion (see below). If either
strings is NULL or 'PatternPtr' empty return false.
Start with a light-weight character match. Even if regex is eventually
required this will eliminate many strings on simple character comparison before
more heavy-weight pattern matching needs to be called into play.
If regular expression configuration is enabled, and the 'PatternPtr' string
begins with a REGEX_CHAR ('^'), or a 'pregptr' is supplied, a regex match is
undertaken. 'PregPtr' must have already been compiled or it is ignored and a
scratch 'preg' is compiled and then freed. The regular expression matching is
case-insensitive and takes EGREP style expressions.
If not a regular expression then a string match allowing wildcard "*" (matching
any zero or more characters) and "%" (matching any single character). Matches
the string specified in 'StringPtr' against the pattern supplied in
'PatternPtr'. A double asterisk (i.e. **) makes the match more of a find-in
string search than a pattern match. Due to some pretty mixed past decisions on
how string searching should be conducted there have been two expectations
throughout the HTTPd. The first that a wildcard is "greedy" (making the
longest possible match). This matches up until any string following the
wildcard fails to match, or it encounters another wildcard. The second
"non-greedy" (the first non-match of the character following the wildcard
aborts the match, or it encounters another wildcard). This wildcard match
generates similar information to regex matching using the data in a
'regmatch_t' structure. Each element contains the start and end offsets of
wildcard matched portion of the 'StringPtr' text.
*/
BOOL StringMatchAndRegex
(
REQUEST_STRUCT *rqptr,
char *StringPtr,
char *PatternPtr,
int MatchType,
regex_t *pregptr,
regmatch_t *pmatchptr
)
{
BOOL MetaCharHit,
TwoWild,
WatchThisMatch;
int pidx, retval,
RegexSyntax;
char ch;
char *pptr, *sptr, *tsptr, *tpptr;
char ErrorString [32];
regex_t preg;
regmatch_t pmatch [REGEX_PMATCH_MAX];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER,
"StringMatchAndRegex() !&Z !&Z !UL !&X !&X",
StringPtr, PatternPtr, MatchType, pregptr, pmatchptr);
if (WATCHING (rqptr, WATCH_MATCH))
{
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "!&Z !&?COMPILED:\r\r!&Z",
StringPtr, pregptr && pregptr->buffer, PatternPtr);
WatchThisMatch = true;
}
else
WatchThisMatch = false;
if (!StringPtr) return (false);
if (!PatternPtr) return (false);
/* initialize the match offset buffer */
if (pmatchptr)
{
for (pidx = 0; pidx < REGEX_PMATCH_MAX; pidx++)
pmatchptr[pidx].rm_so = pmatchptr[pidx].rm_eo = -1;
pidx = 1;
}
/**********************/
/* light-weight match */
/**********************/
sptr = StringPtr;
pptr = PatternPtr;
RegexSyntax = 0;
if (Config.cfMisc.RegexSyntax && *pptr == REGEX_CHAR)
{
if (MatchType == SMATCH_STRING_REGEX ||
MatchType == SMATCH_GREEDY_REGEX ||
MatchType == SMATCH_REGEX)
{
/* must be a regex pattern */
RegexSyntax = Config.cfMisc.RegexSyntax;
pptr++;
/* step over any start-of-line anchor seeing we're there already */
if (*pptr == '^')
{
pptr++;
/* if regex for empty string, then it's a match */
if (SAME2(pptr,'$\0') && !*sptr)
{
if (WatchThisMatch)
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "YES prematch");
if (!pmatchptr) return (true);
pmatchptr[0].rm_so = 0;
pmatchptr[0].rm_eo = 1;
return (true);
}
}
}
}
MetaCharHit = false;
while (*pptr && *sptr)
{
switch (*pptr)
{
/* "significant" characters when pattern matching */
case '%' :
if (RegexSyntax) break;
case '*' :
MetaCharHit = true;
break;
case '^' :
case '$' :
case '.' :
case '+' :
case '?' :
case '|' :
case '{' :
case '[' :
case '(' :
case '\\' :
if (!RegexSyntax) break;
MetaCharHit = true;
break;
}
if (MetaCharHit) break;
if (TOLO(*pptr) != TOLO(*sptr) && *pptr != '%') break;
pptr++;
sptr++;
}
if (!*pptr && !*sptr)
{
/* matched exactly */
if (WatchThisMatch) WatchThis (WATCHITM(rqptr), WATCH_MATCH, "YES prematch");
if (!pmatchptr) return (true);
pmatchptr[0].rm_so = 0;
pmatchptr[0].rm_eo = sptr - StringPtr;
return (true);
}
if (SAME2(pptr,'*\0'))
{
/* pattern ended in a trailing wildcard, therefore it matches */
if (WatchThisMatch) WatchThis (WATCHITM(rqptr), WATCH_MATCH, "YES prematch");
if (!pmatchptr) return (true);
pmatchptr[0].rm_so = 0;
pmatchptr[1].rm_so = sptr - StringPtr;
while (*sptr) sptr++;
pmatchptr[0].rm_eo = pmatchptr[1].rm_eo = sptr - StringPtr;
return (true);
}
if (!RegexSyntax && !MetaCharHit)
{
/* didn't match */
if (!WatchThisMatch) return (false);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "NO prematch !&Z", pptr);
return (false);
}
/**********************/
/* heavy-weight match */
/**********************/
switch (MatchType)
{
case SMATCH_STRING : /* non-greedy match - no regex */
case SMATCH_GREEDY : /* greedy match - no regex */
RegexSyntax = 0;
break;
case SMATCH_STRING_REGEX : /* non-greedy match - allow regex */
case SMATCH_GREEDY_REGEX : /* greedy match - allow regex */
if (pregptr && pregptr->buffer)
RegexSyntax = Config.cfMisc.RegexSyntax;
else
if (*PatternPtr == REGEX_CHAR)
RegexSyntax = Config.cfMisc.RegexSyntax;
else
RegexSyntax = 0;
break;
case SMATCH_REGEX : /* regular expression only */
RegexSyntax = Config.cfMisc.RegexSyntax;
break;
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
sptr = StringPtr;
pptr = PatternPtr;
if (RegexSyntax)
{
/**********************/
/* regular expression */
/**********************/
if (!pmatchptr) pmatchptr = &pmatch;
if (rqptr && rqptr->rqPathSet.RegexSyntax)
{
if (MatchType != SMATCH_REGEX) pptr++;
if (WATCHING (rqptr, WATCH_MATCH))
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "REGEX flags !8XL",
rqptr->rqPathSet.RegexSyntax);
retval = regcomp (pregptr = &preg, pptr, rqptr->rqPathSet.RegexSyntax);
}
else
if (pregptr && pregptr->buffer)
retval = 0;
else
{
if (MatchType != SMATCH_REGEX) pptr++;
retval = regcomp (pregptr = &preg, pptr, RegexSyntax);
}
if (!retval)
{
retval = regexec (pregptr, sptr, REGEX_PMATCH_MAX, pmatchptr,
REGEX_E_FLAGS);
if (pregptr == &preg) regfree (pregptr);
if (retval)
{
if (!WatchThisMatch) return (false);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "NO regex");
return (false);
}
else
{
if (!WatchThisMatch) return (true);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "YES regex");
StringWatchPmatch (StringPtr, pmatchptr);
return (true);
}
}
regerror (retval, pregptr, ErrorString, sizeof(ErrorString));
/* always output a regex compile error when WATCHing! */
if (WatchThisMatch)
WatchThis (WATCHITM(rqptr), WATCH_MATCH,
"COMPILE regex !AZ", ErrorString);
else
if (WATCHPNT(rqptr))
WatchThis (WATCHITM(rqptr), WATCH_MATCH,
"COMPILE regex !&Z !AZ", pptr, ErrorString);
ErrorNoticed (rqptr, 0, "regex \"!AZ\" !AZ", FI_LI, pptr, ErrorString);
return (false);
}
/****************/
/* string match */
/****************/
for (;;)
{
while (*pptr && *sptr && *pptr != '*' && *pptr != '%' &&
TOLO(*pptr) == TOLO(*sptr))
{
pptr++;
sptr++;
}
if (!*pptr && !*sptr)
{
if (pmatchptr)
{
pmatchptr[0].rm_so = 0;
pmatchptr[0].rm_eo = sptr - StringPtr;
}
if (!WatchThisMatch) return (true);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "YES wildcard");
if (pmatchptr) StringWatchPmatch (StringPtr, pmatchptr);
return (true);
}
if (*pptr != '*' && *pptr != '%')
{
if (pmatchptr) pmatchptr[0].rm_so = pmatchptr[0].rm_eo = -1;
if (!WatchThisMatch) return (false);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "NO wildcard !&Z", pptr);
return (false);
}
if (*pptr == '%')
{
/* single char wildcard processing */
if (*sptr)
{
if (pmatchptr && pidx < REGEX_PMATCH_MAX)
{
pmatchptr[pidx].rm_so = sptr - StringPtr;
pmatchptr[pidx].rm_eo = pmatchptr[pidx].rm_so + 1;
pidx++;
}
pptr++;
sptr++;
continue;
}
if (pmatchptr) pmatchptr[0].rm_so = pmatchptr[0].rm_eo = -1;
if (!WatchThisMatch) return (false);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "NO wildcard !&Z", pptr);
return (false);
}
TwoWild = SAME2(pptr,'**');
while (*pptr == '*') pptr++;
/* an asterisk wildcard at end matches all following */
if (!*pptr)
{
if (pmatchptr)
{
if (pidx < REGEX_PMATCH_MAX)
{
pmatchptr[pidx].rm_so = sptr - StringPtr;
while (*sptr) sptr++;
pmatchptr[pidx].rm_eo = sptr - StringPtr;
pmatchptr[0].rm_so = 0;
pmatchptr[0].rm_eo = sptr - StringPtr;
}
}
if (!WatchThisMatch) return (true);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "YES wildcard");
if (pmatchptr) StringWatchPmatch (StringPtr, pmatchptr);
return (true);
}
if (TwoWild ||
MatchType == SMATCH_GREEDY ||
MatchType == SMATCH_GREEDY_REGEX)
{
/*****************************/
/* two consecutive asterisks */
/*****************************/
/* note current position in the string (first after the wildcard) */
tpptr = pptr;
if (pmatchptr && pidx < REGEX_PMATCH_MAX)
pmatchptr[pidx].rm_so = sptr - StringPtr;
for (;;)
{
/* find first char in StringPtr matching char after wildcard */
ch = TOLO(*pptr);
while (*sptr && TOLO(*sptr) != ch) sptr++;
if (!*sptr)
{
/* did not find one of those characters */
if (pmatchptr)
{
if (pidx < REGEX_PMATCH_MAX) pmatchptr[pidx].rm_so = -1;
pmatchptr[0].rm_so = pmatchptr[0].rm_eo = -1;
}
if (!WatchThisMatch) return (false);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "NO wildcard !&Z", pptr);
return (false);
}
/* note the current position in StringPtr being searched */
if (pmatchptr && pidx < REGEX_PMATCH_MAX)
pmatchptr[pidx].rm_eo = sptr - StringPtr;
tsptr = sptr;
/* try to match the string trailing the wildcard */
while (*pptr && *sptr && TOLO(*pptr) == TOLO(*sptr))
{
pptr++;
sptr++;
}
if (!*pptr && !*sptr)
{
/* reached the end of both strings - match! */
if (pmatchptr)
{
pmatchptr[0].rm_so = 0;
pmatchptr[0].rm_eo = sptr - StringPtr;
}
if (!WatchThisMatch) return (true);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "YES wildcard");
if (pmatchptr) StringWatchPmatch (StringPtr, pmatchptr);
return (true);
}
/* break to the external loop if encountered another wildcard */
if (*pptr == '*' || *pptr == '%')
{
if (pidx < REGEX_PMATCH_MAX) pidx++;
break;
}
/* another try starting at character following previous attempt */
if (pmatchptr && pidx < REGEX_PMATCH_MAX)
pmatchptr[pidx].rm_eo = -1;
pptr = tpptr;
sptr = tsptr + 1;
}
if (pmatchptr && pidx < REGEX_PMATCH_MAX) pmatchptr[pidx].rm_so = -1;
}
else
{
/****************/
/* one asterisk */
/****************/
if (pmatchptr && pidx < REGEX_PMATCH_MAX)
pmatchptr[pidx].rm_so = sptr - StringPtr;
for (;;)
{
/* find first char in StringPtr matching char after wildcard */
ch = TOLO(*pptr);
while (*sptr && TOLO(*sptr) != ch) sptr++;
if (!*sptr)
{
/* did not find one of those characters */
if (pmatchptr)
{
if (pidx < REGEX_PMATCH_MAX) pmatchptr[pidx].rm_so = -1;
pmatchptr[0].rm_so = pmatchptr[0].rm_eo = -1;
}
if (!WatchThisMatch) return (false);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "NO wildcard !&Z", pptr);
return (false);
}
/* try to match the string trailing the wildcard */
if (pmatchptr && pidx < REGEX_PMATCH_MAX)
pmatchptr[pidx].rm_eo = sptr - StringPtr;
while (*pptr && *sptr && TOLO(*pptr) == TOLO(*sptr))
{
pptr++;
sptr++;
}
if (!*pptr && !*sptr)
{
/* reached the end of both strings - match! */
if (pmatchptr)
{
pmatchptr[0].rm_so = 0;
pmatchptr[0].rm_eo = sptr - StringPtr;
}
if (!WatchThisMatch) return (true);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "YES wildcard");
if (pmatchptr) StringWatchPmatch (StringPtr, pmatchptr);
return (true);
}
/* break to the external loop if encountered another wildcard */
if (*pptr == '*' || *pptr == '%')
{
if (pidx < REGEX_PMATCH_MAX) pidx++;
break;
}
if (pmatchptr)
{
if (pidx < REGEX_PMATCH_MAX) pmatchptr[pidx].rm_so = -1;
pmatchptr[0].rm_so = pmatchptr[0].rm_eo = -1;
}
if (!WatchThisMatch) return (false);
WatchThis (WATCHITM(rqptr), WATCH_MATCH, "NO wildcard !&Z", pptr);
return (false);
}
}
}
}
/*****************************************************************************/
/*
Uses the 'regmatch_t' offset data to populate an output buffer with wildcard
substitutions from the 'regmatch_t' array (as might be generated by regexec()
or StringMatchAndRegex()) according to specification provided in 'Result'.
This is completely backward-compatible with the way the MAPURL.C module has
performed wildcard substitutions from 'template' to 'result' strings. That is,
the result substitutes it's wildcard specified strings out of the source string
in the same order as matched by the pattern (template) specification. If there
was no corresponding wildarded string the substitution is just ignored. With
this new substitution scheme (function) it is also possible to specify which
wildcarded string should be substituted where. This is specified in the result
string using a "*'<n>" sequence, where <n> is a single digit from 0..9 (e.g.
"*'1"). This allows slightly greater flexibility if required. If there is no
digit following the "*'", the substitution is just ignored.
*/
int StringMatchSubstitute
(
REQUEST_STRUCT *rqptr,
char *String,
char *Result,
regmatch_t *pmatchptr,
char *Buffer,
int SizeOfBuffer
)
{
int idx, pidx;
char *cptr, *sptr, *zptr,
*pcptr, *pzptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER,
"StringMatchSubstitute() !&Z !&Z !&X !UL",
String, Result, Buffer, SizeOfBuffer);
pidx = 1;
zptr = (sptr = Buffer) + SizeOfBuffer;
cptr = Result;
while (*cptr && sptr < zptr)
{
if (*cptr != '*')
{
*sptr++ = *cptr++;
continue;
}
while (*cptr && *cptr == '*') cptr++;
if (*cptr != '\'')
{
if (pidx >= REGEX_PMATCH_MAX) continue;
if (pmatchptr[pidx].rm_so != -1 && pmatchptr[pidx].rm_so != -1)
{
pcptr = String + pmatchptr[pidx].rm_so;
pzptr = String + pmatchptr[pidx].rm_eo;
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "!UL {!UL}!-!#AZ",
pidx, pzptr - pcptr, pcptr);
while (pcptr < pzptr && sptr < zptr) *sptr++ = *pcptr++;
}
pidx++;
continue;
}
cptr++;
if (!isdigit(*cptr)) continue;
idx = *cptr++ - '0'; /* i.e. index from 0 to 9 */
if (idx >= REGEX_PMATCH_MAX) continue;
if (pmatchptr[idx].rm_so != -1 && pmatchptr[idx].rm_so != -1)
{
pcptr = String + pmatchptr[idx].rm_so;
pzptr = String + pmatchptr[idx].rm_eo;
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "!UL {!UL}!-!#AZ",
idx, pzptr - pcptr, pcptr);
while (pcptr < pzptr && sptr < zptr) *sptr++ = *pcptr++;
}
}
if (sptr < zptr)
{
*sptr = '\0';
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "!&Z", Buffer);
return (SS$_NORMAL);
}
*Buffer = '\0';
return (SS$_RESULTOVF);
}
/*****************************************************************************/
/*
Compile the supplied regular expression into the supplied 'preg' structure.
Return a NULL if the compile is successful, a pointer to static storage
containing an error message if not.
*/
char* StringRegexCompile
(
char *Pattern,
regex_t *pregptr
)
{
static char ErrorString [64];
int retval,
RegexSyntax;
/*********/
/* begin */
/*********/
if (!(RegexSyntax = Config.cfMisc.RegexSyntax))
RegexSyntax = REGEX_C_FLAGS;
retval = regcomp (pregptr, Pattern, Config.cfMisc.RegexSyntax);
if (!retval) return (NULL);
regerror (retval, pregptr, ErrorString, sizeof(ErrorString));
return (ErrorString);
}
/*****************************************************************************/
/*
Provide a report page which allows the matching or a string with a pattern
(either wildcard or regular expression). This allows these expressions to be
experimentally evaluated from the Servr Administration menu.
*/
StringMatchReport (REQUEST_STRUCT *rqptr)
{
static char BeginPage [] =
"<form method=\"POST\" action=\"!AZ\">\n\
<p><table cellpadding=\"3\" cellspacing=\"0\" border=\"1\">\n\
<tr><td>\n\
<table cellpadding=\"3\" cellspacing=\"0\" border=\"0\">\n";
static char MatchFao [] =
"<tr><th align=\"right\">String:</th><td><tt>!&;AZ</tt></td></tr>\n\
<tr><th align=\"right\">Pattern:</th><td><tt>!&;AZ</tt></td></tr>\n\
<tr><th align=\"right\" valign=\"top\">Match:</th><td>!&;AZ <i>(!AZ)</i>!AZ";
static char MatchEnd [] = "</td></tr>\n";
static char PmatchFao [] =
"<b>!UL.</b> !7<{!UL,!UL}!> <b>|</b>!&;AZ<b>|</b>\n";
static char PmatchEnd [] = "</pre></td></tr>\n";
static char ResultFao [] =
"<tr><th align=\"right\">Result:</th><td>!&@</td></tr>\n\
<tr><th></th><td>!&@</td></tr>\n\
<tr><td></td></tr>\n";
static char EndPageFao [] =
"<tr><th align=\"right\">String:</th>\
<td><input type=\"text\" size=\"80\" name=string value=\"!&;AZ\"></td></tr>\n\
<tr><th align=\"right\">Pattern:</th>\
<td><input type=\"text\" size=\"80\" name=pattern value=\"!&;AZ\"></td></tr>\n\
<tr><th></th><td><font size=\"-1\">\
<input type=\"radio\" name=match value=\"!UL\"!AZ>match \
<input type=\"radio\" name=match value=\"!UL\"!AZ>greedy \
<input type=\"radio\" name=match value=\"!UL\"!AZ>regex \
<input type=\"text\" size=\"1\" name=regex value=\"!&;AZ\"> !8XL (!AZ)\
</font></td></tr>\n\
<tr><th align=\"right\">Result:</th><td>\
<input type=\"text\" size=\"80\" name=result value=\"!&;AZ\"></td></tr>\n\
<tr><th></th><td align=\"left\">\
<input type=\"submit\" value=\"Match\"> \
<input type=reset value=\"Reset\">\
</td></tr>\n\
</table>\n\
</td></tr>\n\
</table>\n\
</form>\n\
<p>[<a href=\"!AZ\">Server Admin</a>]\n\
</body>\n\
</html>\n";
int idx, retval, status,
MatchType,
RegexSyntax;
unsigned long *vecptr;
unsigned long FaoVector [32];
char *cptr, *qptr, *sptr, *zptr;
char FieldName [128],
FieldValue [256],
Pattern [256],
RegEx [256],
Result [256],
Scratch [256],
String [256];
regex_t preg;
regmatch_t pmatch [REGEX_PMATCH_MAX];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "StringMatchReport()");
if (rqptr->rqHeader.Method == HTTP_METHOD_POST)
{
if (!rqptr->rqBody.DataPtr)
{
/* read all the request body (special case) then AST back */
BodyReadBegin (rqptr, &StringMatchReport, &BodyProcessReadAll);
return;
}
qptr = rqptr->rqBody.DataPtr;
}
else
if (rqptr->rqHeader.QueryStringLength)
qptr = rqptr->rqHeader.QueryStringPtr;
else
qptr = "";
MatchType = RegexSyntax = 0;
Pattern[0] = RegEx[0] = Result[0] = String[0] = '\0';
while (*qptr)
{
status = StringParseQuery (&qptr, FieldName, sizeof(FieldName),
FieldValue, sizeof(FieldValue));
if (VMSnok (status))
{
/* error occured */
if (status == SS$_IVCHAR) rqptr->rqResponse.HttpStatus = 400;
rqptr->rqResponse.ErrorTextPtr = "parsing query string";
ErrorVmsStatus (rqptr, status, FI_LI);
AdminEnd (rqptr);
return;
}
if (strsame (FieldName, "match", -1))
MatchType = atoi(FieldValue);
else
if (strsame (FieldName, "pattern", -1))
strzcpy (Pattern, FieldValue, sizeof(Pattern));
else
if (strsame (FieldName, "regex", -1))
strzcpy (RegEx, FieldValue, sizeof(RegEx));
else
if (strsame (FieldName, "result", -1))
strzcpy (Result, FieldValue, sizeof(Result));
else
if (strsame (FieldName, "string", -1))
strzcpy (String, FieldValue, sizeof(String));
else
{
ErrorGeneral (rqptr, "Unknown query field.", FI_LI);
AdminEnd (rqptr);
return;
}
}
if (!MatchType) MatchType = SMATCH_STRING;
if (strsame (RegEx, "AWK", 3))
RegexSyntax = RE_SYNTAX_AWK;
else
if (strsame (RegEx, "ED", 2))
RegexSyntax = RE_SYNTAX_ED;
else
if (strsame (RegEx, "EGREP", 5))
RegexSyntax = RE_SYNTAX_EGREP;
else
if (strsame (RegEx, "GREP", 4))
RegexSyntax = RE_SYNTAX_GREP;
else
if (strsame (RegEx, "POSIX_AWK", 9))
RegexSyntax = RE_SYNTAX_POSIX_AWK;
else
if (strsame (RegEx, "POSIX_BASIC", 11))
RegexSyntax = RE_SYNTAX_POSIX_BASIC;
else
if (strsame (RegEx, "POSIX_EGREP", 11))
RegexSyntax = RE_SYNTAX_POSIX_EGREP;
else
if (strsame (RegEx, "POSIX_EXTENDED", 14))
RegexSyntax = RE_SYNTAX_POSIX_EXTENDED;
else
if (strsame (RegEx, "POSIX_MINIMAL_BASIC", 19))
RegexSyntax = RE_SYNTAX_POSIX_MINIMAL_BASIC;
else
if (strsame (RegEx, "POSIX_MINIMAL_EXTENDED", 22))
RegexSyntax = RE_SYNTAX_POSIX_MINIMAL_EXTENDED;
else
if (strsame (RegEx, "SED", 3))
RegexSyntax = RE_SYNTAX_AWK;
else
if (strsame (RegEx, "WASD", 4))
RegexSyntax = REGEX_C_FLAGS;
else
if (isdigit(RegEx[0]))
RegexSyntax = atoi(RegEx);
else
RegexSyntax = REGEX_C_FLAGS;
AdminPageTitle (rqptr, "String Match Report",
BeginPage, ADMIN_REPORT_MATCH);
if (Pattern[0])
{
if (MatchType == SMATCH_REGEX ||
Pattern[0] == REGEX_CHAR)
{
if (MatchType == SMATCH_REGEX)
retval = regcomp (&preg, Pattern, RegexSyntax);
else
retval = regcomp (&preg, Pattern+1, RegexSyntax);
if (retval)
{
regerror (retval, &preg, Scratch, sizeof(Scratch));
vecptr = FaoVector;
*vecptr++ = String;
*vecptr++ = Pattern;
*vecptr++ = Scratch;
*vecptr++ = "regex";
*vecptr++ = MatchEnd;
status = FaolToNet (rqptr, MatchFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
else
{
retval = regexec (&preg, String, REGEX_PMATCH_MAX, pmatch,
REGEX_E_FLAGS);
regfree (&preg);
vecptr = FaoVector;
*vecptr++ = String;
*vecptr++ = Pattern;
if (!retval)
{
*vecptr++ = "YES";
*vecptr++ = "regex";
*vecptr++ = "<pre>";
}
else
{
*vecptr++ = "NO";
*vecptr++ = "regex";
*vecptr++ = MatchEnd;
}
status = FaolToNet (rqptr, MatchFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
}
else
{
retval = StringMatchAndRegex (rqptr, String, Pattern,
MatchType, NULL, &pmatch);
vecptr = FaoVector;
*vecptr++ = String;
*vecptr++ = Pattern;
if (retval)
{
*vecptr++ = "YES";
*vecptr++ = "wildcard";
*vecptr++ = "<pre>";
}
else
{
*vecptr++ = "NO";
*vecptr++ = "wildcard";
*vecptr++ = MatchEnd;
}
status = FaolToNet (rqptr, MatchFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
retval = !retval;
}
if (!retval)
{
/* success, display the matching offsets (strings) */
for (idx = 0; idx < REGEX_PMATCH_MAX; idx++)
{
if (pmatch[idx].rm_so != -1 || pmatch[idx].rm_eo != -1)
{
zptr = (sptr = Scratch) + sizeof(Scratch)-1;
for (cptr = String + pmatch[idx].rm_so;
cptr < String + pmatch[idx].rm_eo && sptr < zptr;
*sptr++ = *cptr++);
*sptr = '\0';
vecptr = FaoVector;
*vecptr++ = idx;
*vecptr++ = pmatch[idx].rm_so;
*vecptr++ = pmatch[idx].rm_eo ? pmatch[idx].rm_eo - 1 : 0;
*vecptr++ = Scratch;
status = FaolToNet (rqptr, PmatchFao, &FaoVector);
if (VMSnok (status))
ErrorNoticed (rqptr, status, NULL, FI_LI);
}
}
status = FaolToNet (rqptr, PmatchEnd, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
vecptr = FaoVector;
if (Result[0] && !retval)
{
status = StringMatchSubstitute (rqptr, String, Result, &pmatch,
Scratch, sizeof(Scratch));
if (VMSnok (status))
FaoToBuffer (Scratch, sizeof(Scratch), NULL, "!&S", status);
*vecptr++ = "<tt>!&;AZ</tt>";
*vecptr++ = Result;
*vecptr++ = "<tt><b>|</b>!&;AZ<b>|</b></tt>";
*vecptr++ = Scratch;
}
else
{
*vecptr++ = "!AZ";
*vecptr++ = "<i>(none)</i>";
*vecptr++ = "!AZ";
*vecptr++ = "<i>(none)</i>";
}
status = FaolToNet (rqptr, ResultFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
vecptr = FaoVector;
*vecptr++ = String;
*vecptr++ = Pattern;
*vecptr++ = SMATCH_STRING;
if (MatchType == SMATCH_STRING)
*vecptr++ = " CHECKED";
else
*vecptr++ = "";
*vecptr++ = SMATCH_GREEDY;
if (MatchType == SMATCH_GREEDY)
*vecptr++ = " CHECKED";
else
*vecptr++ = "";
*vecptr++ = SMATCH_REGEX;
if (MatchType == SMATCH_REGEX)
*vecptr++ = " CHECKED";
else
*vecptr++ = "";
*vecptr++ = RegEx;
if (RegexSyntax)
*vecptr++ = RegexSyntax;
else
*vecptr++ = Config.cfMisc.RegexSyntax;
switch (RegexSyntax)
{
case 0 : *vecptr++ = "disabled"; break;
case RE_SYNTAX_AWK : *vecptr++ = "AWK"; break;
case RE_SYNTAX_EGREP : *vecptr++ = "EGREP"; break;
case RE_SYNTAX_GREP : *vecptr++ = "GREP"; break;
case RE_SYNTAX_POSIX_AWK : *vecptr++ = "POSIX_AWK"; break;
case RE_SYNTAX_POSIX_BASIC : *vecptr++ = "POSIX_BASIC/ED/SED"; break;
case RE_SYNTAX_POSIX_EGREP : *vecptr++ = "POSIX_EGREP"; break;
case RE_SYNTAX_POSIX_EXTENDED : *vecptr++ = "POSIX_EXTENDED"; break;
case RE_SYNTAX_POSIX_MINIMAL_BASIC :
*vecptr++ = "POSIX_MINIMAL_BASIC"; break;
case RE_SYNTAX_POSIX_MINIMAL_EXTENDED :
*vecptr++ = "POSIX_MINIMAL_EXTENDED"; break;
case REGEX_C_FLAGS : *vecptr++ = "WASD"; break;
default : *vecptr++ = "custom";
}
*vecptr++ = Result;
*vecptr++ = HTTPD_ADMIN;
status = FaolToNet (rqptr, EndPageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
rqptr->rqResponse.PreExpired = PRE_EXPIRE_ADMIN;
ResponseHeader200 (rqptr, "text/html", &rqptr->NetWriteBufferDsc);
AdminEnd (rqptr);
}
/*****************************************************************************/
/*
WATCH each of the valid 'pmatch' offsets.
*/
StringWatchPmatch
(
char *String,
regmatch_t *pmatchptr
)
{
int idx;
char *cptr, *sptr, *zptr;
char Scratch [256];
/*********/
/* begin */
/*********/
for (idx = 0; idx < REGEX_PMATCH_MAX; idx++)
{
if (pmatchptr[idx].rm_so == -1 || pmatchptr[idx].rm_eo == -1) continue;
zptr = (sptr = Scratch) + sizeof(Scratch)-1;
for (cptr = String + pmatchptr[idx].rm_so;
cptr < String + pmatchptr[idx].rm_eo && sptr < zptr;
*sptr++ = *cptr++);
*sptr = '\0';
WatchDataFormatted ("!UL. {!UL,!UL} !AZ\n",
idx, pmatchptr[idx].rm_so,
pmatchptr[idx].rm_eo ? pmatchptr[idx].rm_eo - 1 : 0,
Scratch);
}
}
/*****************************************************************************/
/*
A null terminated string is parsed for the next "fieldname=fieldvalue[&]"
pair. Return an appropriate VMS status code.
*/
int StringParseQuery
(
char **QueryStringPtrPtr,
char *FieldName,
int SizeOfFieldName,
char *FieldValue,
int SizeOfFieldValue
)
{
char *cptr, *qptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringParseQuery() !&Z",
QueryStringPtrPtr ? *QueryStringPtrPtr : NULL);
if (!QueryStringPtrPtr || !*QueryStringPtrPtr || !FieldName || !FieldValue)
return (SS$_BADPARAM);
qptr = *QueryStringPtrPtr;
zptr = (sptr = FieldName) + SizeOfFieldName;
while (*qptr && *qptr != '=' && sptr < zptr)
{
while (*qptr == '\r' || *qptr == '\n') qptr++;
while (*qptr && *qptr != '=' && *qptr != '\r' && *qptr != '\n' &&
sptr < zptr) *sptr++ = *qptr++;
}
if (sptr >= zptr) return (SS$_RESULTOVF);
*sptr = '\0';
if (*qptr++ != '=') return (SS$_IVCHAR);
zptr = (sptr = FieldValue) + SizeOfFieldValue;
while (*qptr && *qptr != '&' && sptr < zptr)
{
while (*qptr == '\r' || *qptr == '\n') qptr++;
while (*qptr && *qptr != '&' && *qptr != '\r' && *qptr != '\n' &&
sptr < zptr) *sptr++ = *qptr++;
}
if (sptr >= zptr) return (SS$_RESULTOVF);
*sptr = '\0';
if (*qptr && *qptr++ != '&') return (SS$_IVCHAR);
if (StringUrlDecode (FieldValue) < 0) return (SS$_IVCHAR);
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"!&Z !&Z", FieldName, FieldValue);
*QueryStringPtrPtr = qptr;
return (SS$_NORMAL);
}
/****************************************************************************/
/*
URL-decodes a string in place (can do this because URL-decoded text is always
the same or less than the length of the original). Returns the number of
characters in the decoded string, or -1 to indicate a URL-encoding error.
*/
int StringUrlDecode (char *String)
{
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringUrlDecode() !&Z", String);
cptr = sptr = String;
while (*cptr)
{
switch (*cptr)
{
case '+' :
*sptr++ = ' ';
cptr++;
break;
case '%' :
cptr++;
if (*cptr >= '0' && *cptr <= '9')
*sptr = ((unsigned char)(*cptr - '0')) << 4;
else
if (TOUP(*cptr) >= 'A' && TOUP(*cptr) <= 'F')
*sptr = ((unsigned char)(TOUP(*cptr) - '7')) << 4;
else
return (-1);
if (*cptr) cptr++;
if (*cptr >= '0' && *cptr <= '9')
*sptr |= *cptr - '0';
else
if (TOUP(*cptr) >= 'A' && TOUP(*cptr) <= 'F')
*sptr |= TOUP(*cptr) - '7';
else
return (-1);
sptr++;
if (*cptr) cptr++;
break;
default :
*sptr++ = *cptr++;
}
}
*sptr = '\0';
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER, "!&Z", String);
return (sptr - String);
}
/*****************************************************************************/
/*
URL-encode a string. Returns the number of characters in the new string.
*/
int StringUrlEncode
(
char *UrlString,
char *EncString,
int SizeOfEncString
)
{
char *cptr, *eptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringUrlEncode() !&Z", UrlString);
zptr = (sptr = EncString) + SizeOfEncString-1;
cptr = UrlString;
while (*cptr && sptr < zptr)
{
eptr = FaoUrlEncodeTable[*(unsigned char*)cptr++];
while (*eptr && sptr < zptr) *sptr++ = *eptr++;
}
*sptr = '\0';
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchDataFormatted ("!&Z\n", UrlString);
return (sptr - EncString);
}
/*****************************************************************************/
/*
Specially URL-encode a URL string. This leaves the 'scheme://the.host/'
portion untouched, URL-encodes the path component, then any query string
component not encoding '+', &' or '=' characters. Returns the number of
characters in the new string.
*/
int StringUrlEncodeURL
(
char *UrlString,
char *EncString,
int SizeOfEncString
)
{
static char HexDigits [] = "0123456789abcdef";
BOOL HitQueryString;
char ch;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringUrlEncodeURL() !&Z", UrlString);
zptr = (sptr = EncString) + SizeOfEncString-1;
cptr = UrlString;
if (*cptr != '/')
{
/* must have a scheme/host component */
while (*cptr && *cptr != ':' && sptr < zptr) *sptr++ = *cptr++;
if (SAME2(cptr,':/'))
{
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (*cptr == '/' && sptr < zptr) *sptr++ = *cptr++;
/* now we've skipped over any 'http://' */
}
/* locate the start of the path */
while (*cptr && *cptr != '/' && sptr < zptr) *sptr++ = *cptr++;
}
/* copy URL-encoding path then query string appropriately */
HitQueryString = false;
while (*cptr && sptr < zptr)
{
ch = *cptr++;
if (isalnum(ch) || ch == '/' || ch == '-' ||
ch == '_' || ch == '$' || ch == '*' ||
ch == ':' || ch == '[' || ch == ']' ||
ch == ';' || ch == '~' || ch == '.')
{
*sptr++ = ch;
continue;
}
if (!HitQueryString && ch == '?')
{
*sptr++ = ch;
HitQueryString = true;
continue;
}
if (HitQueryString && (ch == '+' || ch == '&' || ch == '='))
{
*sptr++ = ch;
continue;
}
if (ch == '%' && ((cptr[0] >= '0' && cptr[0] <= '9') ||
(cptr[0] >= 'A' && cptr[0] <= 'F') ||
(cptr[0] >= 'z' && cptr[0] <= 'f')))
{
/* this looks like an already URL-encoded sequence */
*sptr++ = ch;
continue;
}
/* encode this character */
*sptr++ = '%';
if (sptr < zptr) *sptr++ = HexDigits[(ch & 0xf0) >> 4];
if (sptr < zptr) *sptr++ = HexDigits[ch & 0x0f];
}
*sptr = '\0';
return (sptr - EncString);
}
/*****************************************************************************/
/*
Scan along a (possibly) single or double quoted text from the supplied string,
otherwise white-space delimits the string. White-space is allowed in a quoted
string. The character '\' escapes the following character allowing otherwise
forbidden characters (e.g. quotes) be included in the string. Unquoted text
cannot include a trailing semicolon - it's considered a field separator.
The processed string is terminated with a null character and the length
returned.
*/
int StringSliceValue (char **StringPtrPtr)
{
char *aptr, *bptr, *cptr, *sptr;
/*********/
/* begin */
/*********/
if (!StringPtrPtr || !*StringPtrPtr) return (0);
sptr = bptr = cptr = *StringPtrPtr;
if (*cptr == '\"')
{
if (SAME3(cptr,'\"0='))
{
/* kludge for DECnet scripting in MAPURL.C */
*sptr++ = *cptr++;
while (*cptr && *cptr != '\"')
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) *sptr++ = *cptr++;
}
else
{
for (aptr = cptr + 1; *aptr && *aptr != '\"'; aptr++)
if (*aptr == '\\' && *(aptr+1)) aptr++;
if (SAME4(aptr,'\"::\"'))
{
/* kludge for specified username DECnet scripting in MAPURL.C */
*sptr++ = *cptr++;
while (*cptr && *cptr != '\"')
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) *sptr++ = *cptr++;
}
else
{
/* just another quote */
cptr++;
while (*cptr && *cptr != '\"')
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
}
}
}
else
/* a single leading quote */
if (*cptr == '\'')
{
cptr++;
while (*cptr && *cptr != '\'')
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
}
else
{
/* white-space delimitted */
while (*cptr && !ISLWS(*cptr) && NOTEOL(*cptr))
{
if (*cptr == '\"')
{
/* double-quote delimited portion */
if (SAME3(cptr,'\"0='))
{
/* kludge for DECnet scripting in MAPURL.C */
*sptr++ = *cptr++;
while (*cptr && *cptr != '\"')
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) *sptr++ = *cptr++;
}
else
{
for (aptr = cptr + 1; *aptr && *aptr != '\"'; aptr++)
if (*aptr == '\\' && *(aptr+1)) aptr++;
if (SAME4(aptr,'\"::\"'))
{
/* kludge specified username DECnet scripting in MAPURL.C */
*sptr++ = *cptr++;
while (*cptr && *cptr != '\"')
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) *sptr++ = *cptr++;
}
else
{
/* just another quote */
cptr++;
while (*cptr && *cptr != '\"')
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
}
}
continue;
}
if (*cptr == '\'')
{
/* single-quote delimited portion */
cptr++;
while (*cptr && *cptr != '\'')
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) cptr++;
continue;
}
if (*cptr == ';' && (ISLWS(*(cptr+1)) || ISEOL(*(cptr+1)))) break;
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
}
if (*cptr) cptr++;
*sptr = '\0';
/* skip trailing possible field terminator and white-space */
while (ISLWS(*cptr)) cptr++;
*StringPtrPtr = cptr;
return (sptr - bptr);
}
/*****************************************************************************/
/*
Parse a (possibly) single or double quoted text from the supplied string.
otherwise white-space (or white-space and semicolon) delimits the string.
Single or double quotes may be used around value string. White-space is
allowed in a quoted string. The character '\' escapes the following character
allowing quotes to be included in the value string. Unquoted text cannot
include a trailing semicolon - it's considered a field separator. Returns an
indicative VMS status code.
*/
int StringParseValue
(
char **StringPtrPtr,
char *ValuePtr,
int ValueSize
)
{
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringParseValue() !&Z",
StringPtrPtr ? *StringPtrPtr : NULL);
if (!StringPtrPtr || !*StringPtrPtr || !ValuePtr) return (SS$_BADPARAM);
cptr = *StringPtrPtr;
if (!*cptr) return (SS$_ENDOFFILE);
zptr = (sptr = ValuePtr) + ValueSize;
while (*cptr && !ISLWS(*cptr) && NOTEOL(*cptr))
{
if (SAME2(cptr,'(\"') || SAME2(cptr,'(\'')) cptr++;
if (*cptr == '\"')
{
cptr++;
while (*cptr && *cptr != '\"' && sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) cptr++;
if (*cptr == ',' || *cptr == ')')
{
while (*cptr == ',' || *cptr == ')') cptr++;
break;
}
}
else
if (*cptr == '\'')
{
cptr++;
while (*cptr && *cptr != '\'' && sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) cptr++;
if (*cptr == ',' || *cptr == ')')
{
while (*cptr == ',' || *cptr == ')') cptr++;
break;
}
}
else
{
if (*cptr == ';' && (ISLWS(*(cptr+1)) || ISEOL(*(cptr+1)))) break;
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
}
if (sptr >= zptr) return (SS$_RESULTOVF);
*sptr = '\0';
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchDataFormatted ("!&Z\n", ValuePtr);
/* skip trailing possible field terminator and white-space */
while (*cptr == ';') cptr++;
while (ISLWS(*cptr)) cptr++;
*StringPtrPtr = cptr;
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Parse text from a string. Single or double quotes may be used around value
string otherwise white-spece delimits it. White-space is allowed in a quoted
string. The character '\' escapes the following character allowing quotes to
be included in the value string. Unquoted text is delimited by white-space.
Returns the length of the string or -1 to indicate an error.
*/
int StringParseOnlyValue
(
char **StringPtrPtr,
char *ValuePtr,
int ValueSize
)
{
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringParseOnlyValue() !&Z",
StringPtrPtr ? *StringPtrPtr : NULL);
if (!StringPtrPtr || !*StringPtrPtr || !ValuePtr) return (-1);
cptr = *StringPtrPtr;
zptr = (sptr = ValuePtr) + ValueSize-1;
*sptr = '\0';
if (!*cptr) return (0);
if (*cptr == '\"')
{
cptr++;
while (*cptr && *cptr != '\"' && sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) cptr++;
}
else
if (*cptr == '\'')
{
cptr++;
while (*cptr && *cptr != '\'' && sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) cptr++;
}
else
{
while (*cptr && !(ISLWS(*cptr) || ISEOL(*cptr)) && sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
}
*StringPtrPtr = cptr;
*sptr = '\0';
if (sptr >= zptr) return (-1);
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchDataFormatted ("!&Z\n", ValuePtr);
return (sptr - ValuePtr);
}
/*****************************************************************************/
/*
Parses name=VALUE pairs from a string. The name will be converted to upper
case and contain only alpha-numerics and underscores (i.e. suitable for DCL
symbol names). White-space delimits the string. Single or double quotes may
be used around value string. White-space is allowed in a quoted string. The
character '\' escapes the following character allowing quotes to be included
in the value string. These must be in one of the following formats ...
name=value
name="string with white space"
name='string with \"white\" space and quotes'
(NAME1=value1,NAME2="value \"2\"",NAME3='VALUE 3')
Parameter 'StringPtrPtr' must be the address of a pointer to char, and must be
initialized to the startup of the source string prior to the first call.
Parameter 'NameAlphaNum' controls whether the name should only consist of
alpha-numeric-underscore characters (suitable for DCL symbol name for example).
Returns an indicative VMS status code.
*/
int StringParseNameValue
(
char **StringPtrPtr,
BOOL NameAlphaNum,
char *NamePtr,
int NameSize,
char *ValuePtr,
int ValueSize
)
{
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringParseNameValue() !&Z",
StringPtrPtr ? *StringPtrPtr : NULL);
if (!StringPtrPtr || !*StringPtrPtr || !NamePtr || !ValuePtr)
return (SS$_BADPARAM);
cptr = *StringPtrPtr;
if (!*cptr) return (SS$_ENDOFFILE);
while (*cptr && *cptr == '(') cptr++;
zptr = (sptr = NamePtr) + NameSize;
while (*cptr && *cptr != '=' && sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr)
if (!NameAlphaNum || isalnum(*cptr) || *cptr == '_')
*sptr++ = *cptr++;
else
cptr++;
}
if (sptr >= zptr) return (SS$_RESULTOVF);
*sptr = '\0';
if (!NamePtr[0]) return (SS$_BADPARAM);
if (*cptr) cptr++;
zptr = (sptr = ValuePtr) + ValueSize;
if (*cptr == '\"')
{
cptr++;
while (*cptr && *cptr != '\"' && sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) cptr++;
}
else
if (*cptr == '\'')
{
cptr++;
while (*cptr && *cptr != '\'' && sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr) cptr++;
}
else
{
while (*cptr && *cptr != ',' && *cptr != ')' && !ISLWS(*cptr) &&
sptr < zptr)
{
if (*cptr == '\\') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
}
if (sptr >= zptr) return (SS$_RESULTOVF);
*sptr = '\0';
while (*cptr && *cptr != ',' && *cptr != ')') cptr++;
while (*cptr == ',' || *cptr == ')') cptr++;
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchDataFormatted ("!&Z !&Z\n", NamePtr, ValuePtr);
/* skip trailing white-space */
while (ISLWS(*cptr)) cptr++;
*StringPtrPtr = cptr;
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Parses name=VALUE pairs from a series of back-to-back, null-terminated strings,
terminated by an empty string. The name will be converted to upper case and
contain only alpha-numerics and underscores (i.e. suitable for DCL symbol
names).
Parameter 'StringPtrPtr' must be the address of a pointer to char, and must be
initialized to the startup of the source string prior to the first call.
Parameter 'NameAlphaNum' controls whether the name should only consist of
alpha-numeric-underscore characters (suitable for DCL symbol name for example).
Returns an indicative VMS status code.
*/
int StringParseNullNameValue
(
char **StringPtrPtr,
BOOL NameAlphaNum,
char *NamePtr,
int NameSize,
char *ValuePtr,
int ValueSize
)
{
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringParseNullNameValue() !&Z",
StringPtrPtr ? *StringPtrPtr : NULL);
if (!StringPtrPtr || !NamePtr || !ValuePtr) return (SS$_BADPARAM);
cptr = *StringPtrPtr;
if (!*cptr) return (SS$_ENDOFFILE);
zptr = (sptr = NamePtr) + NameSize;
while (*cptr && *cptr != '=' && sptr < zptr)
{
if (!NameAlphaNum || isalnum(*cptr) || *cptr == '_') *sptr++ = *cptr;
cptr++;
}
if (sptr >= zptr) return (SS$_RESULTOVF);
*sptr = '\0';
if (!NamePtr[0]) return (SS$_BADPARAM);
if (*cptr) cptr++;
zptr = (sptr = ValuePtr) + ValueSize;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr >= zptr) return (SS$_RESULTOVF);
*sptr = '\0';
cptr++;
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchDataFormatted ("!&Z !&Z\n", NamePtr, ValuePtr);
*StringPtrPtr = cptr;
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Maintains a string containing newline-separated text items.
*/
StringListAdd
(
char *cptr,
char **ListPtrPtr,
int *ListLengthPtr
)
{
int NewLength,
ListLength;
char *sptr,
*ListPtr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringListAdd() !&Z !UL !&Z",
cptr, *ListLengthPtr, *ListPtrPtr);
ListPtr = *ListPtrPtr;
ListLength = *ListLengthPtr;
while (*cptr && ISLWS(*cptr)) cptr++;
for (sptr = cptr; *sptr; sptr++);
NewLength = ListLength + (sptr - cptr) + 2;
ListPtr = VmRealloc (ListPtr, NewLength, FI_LI);
sptr = ListPtr + ListLength;
if (ListLength) *sptr++ = STRING_LIST_CHAR;
while (*cptr) *sptr++ = *cptr++;
*sptr = '\0';
*ListPtrPtr = ListPtr;
*ListLengthPtr = sptr - ListPtr;
if (WATCH_MODULE(WATCH_MOD__OTHER) && WATCH_MODULE(WATCH_MOD__DETAIL))
WatchDataFormatted ("!UL !&Z", *ListLengthPtr, *ListPtrPtr);
}
/*****************************************************************************/
/*
With the VmGetHeap()ed string, replace all occurances of |this| with |that|.
Return zero if not change, or the length of the new string.
*/
#pragma message disable (CXXKEYWORD)
int StringReplace
(
REQUEST_STRUCT *rqptr,
char **string,
char *this,
char *that
)
{
int count, len1, len2, size;
char *aptr, *bptr, *cptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD__OTHER))
WatchThis (WATCHALL, WATCH_MOD__OTHER,
"StringReplace() !&Z !&Z", this, that);
/* if does not contain |this| then just return */
if (!stristr (*string, this)) return (0);
len1 = strlen(this);
len2 = strlen(that);
if (len2 > len1)
{
/* need a larger buffer */
cptr = *string;
count = 1;
while (cptr)
{
if (!(cptr = stristr (cptr, this))) break;
count++;
sptr = (cptr += len1);
}
while (*sptr) sptr++;
size = sptr - *string;
size += (len2 - len1) * count;
bptr = VmGetHeap (rqptr, size);
}
else
/* enough space in the current buffer */
bptr = *string;
sptr = bptr;
aptr = *string;
for (;;)
{
if (!(cptr = stristr (aptr, this)))
{
/* copy remainder after last |this| */
while (*aptr) *sptr++ = *aptr++;
break;
}
/* copy intermediate up until start of |this| */
while (aptr < cptr) *sptr++ = *aptr++;
/* step over existing |this| */
aptr += len1;
/* copy in replacement |that| */
for (cptr = that; *cptr; *sptr++ = *cptr++);
}
*sptr = '\0';
/* dispose of the old buffer if possible */
if (*string != bptr)
{
VmFreeFromHeap (rqptr, *string, FI_LI);
*string = bptr;
}
return (sptr - bptr);
}
#pragma message enable (CXXKEYWORD)
/****************************************************************************/
/*
Copies null-terminated string 'SourcePtr' to 'DestinationPtr'. Copies no more
than 'SizeOfDestination'-1 then terminates with a null character, effectively
truncating the string. Returns length of source (not the copied) string.
*/
int strzcpy
(
char *DestinationPtr,
char *SourcePtr,
int SizeOfDestination
)
{
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
zptr = (sptr = DestinationPtr) + SizeOfDestination - 1;
for (cptr = SourcePtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
while (*cptr++) sptr++;
return (sptr - DestinationPtr);
}
/****************************************************************************/
/*
Is |sptr2| contained in |sptr1| - case insensitive.
*/
char* stristr
(
char *sptr1,
char *sptr2
)
{
char *cptr1, *cptr2;
/*********/
/* begin */
/*********/
if (!sptr1 || !sptr2) return (NULL);
while (*sptr1)
{
cptr1 = sptr1;
cptr2 = sptr2;
while (TOLO(*cptr1) == TOLO(*cptr2))
{
cptr1++;
cptr2++;
}
if (!*cptr2) return (sptr1);
sptr1++;
}
return (NULL);
}
/****************************************************************************/
/*
Does a case-insensitive, character-by-character string compare and returns
true if two strings are the same, or false if not. If a maximum number of
characters are specified only those will be compared, if the entire strings
should be compared then specify the number of characters as 0.
*/
BOOL strsame
(
char *sptr1,
char *sptr2,
int count
)
{
/*********/
/* begin */
/*********/
while (*sptr1 && *sptr2)
{
if (TOLO(*sptr1++) != TOLO(*sptr2++)) return (false);
if (count)
if (!--count) return (true);
}
if (*sptr1 || *sptr2)
return (false);
else
return (true);
}
/****************************************************************************/