[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
[1230]
[1231]
[1232]
[1233]
[1234]
[1235]
[1236]
[1237]
[1238]
[1239]
[1240]
[1241]
[1242]
[1243]
[1244]
[1245]
[1246]
[1247]
[1248]
[1249]
[1250]
[1251]
[1252]
[1253]
[1254]
[1255]
[1256]
[1257]
[1258]
[1259]
[1260]
[1261]
[1262]
[1263]
[1264]
[1265]
[1266]
[1267]
[1268]
[1269]
[1270]
[1271]
[1272]
[1273]
[1274]
[1275]
[1276]
[1277]
[1278]
[1279]
[1280]
[1281]
[1282]
[1283]
[1284]
[1285]
[1286]
[1287]
[1288]
[1289]
[1290]
[1291]
[1292]
[1293]
[1294]
[1295]
[1296]
[1297]
[1298]
[1299]
[1300]
[1301]
[1302]
[1303]
[1304]
[1305]
[1306]
[1307]
[1308]
[1309]
[1310]
[1311]
[1312]
[1313]
[1314]
[1315]
[1316]
[1317]
[1318]
[1319]
[1320]
[1321]
[1322]
[1323]
[1324]
[1325]
[1326]
[1327]
[1328]
[1329]
[1330]
[1331]
[1332]
[1333]
[1334]
[1335]
[1336]
[1337]
[1338]
[1339]
[1340]
[1341]
[1342]
[1343]
[1344]
[1345]
[1346]
[1347]
[1348]
[1349]
[1350]
[1351]
[1352]
[1353]
[1354]
[1355]
[1356]
[1357]
[1358]
[1359]
[1360]
[1361]
[1362]
[1363]
[1364]
[1365]
[1366]
[1367]
[1368]
[1369]
[1370]
[1371]
[1372]
[1373]
[1374]
[1375]
[1376]
[1377]
[1378]
[1379]
[1380]
[1381]
[1382]
[1383]
[1384]
[1385]
[1386]
[1387]
[1388]
[1389]
[1390]
[1391]
[1392]
[1393]
[1394]
[1395]
[1396]
[1397]
[1398]
[1399]
[1400]
[1401]
[1402]
[1403]
[1404]
[1405]
[1406]
[1407]
[1408]
[1409]
[1410]
[1411]
[1412]
[1413]
[1414]
[1415]
[1416]
[1417]
[1418]
[1419]
[1420]
[1421]
[1422]
[1423]
[1424]
[1425]
[1426]
[1427]
[1428]
[1429]
[1430]
[1431]
[1432]
[1433]
[1434]
[1435]
[1436]
[1437]
[1438]
[1439]
[1440]
[1441]
[1442]
[1443]
[1444]
[1445]
[1446]
[1447]
[1448]
[1449]
[1450]
[1451]
[1452]
[1453]
[1454]
[1455]
[1456]
[1457]
[1458]
[1459]
[1460]
[1461]
[1462]
[1463]
[1464]
[1465]
[1466]
[1467]
[1468]
[1469]
[1470]
[1471]
[1472]
[1473]
[1474]
[1475]
[1476]
[1477]
[1478]
[1479]
[1480]
[1481]
[1482]
[1483]
[1484]
[1485]
[1486]
[1487]
[1488]
[1489]
[1490]
[1491]
[1492]
[1493]
[1494]
[1495]
[1496]
[1497]
[1498]
[1499]
[1500]
[1501]
[1502]
[1503]
[1504]
[1505]
[1506]
[1507]
[1508]
[1509]
[1510]
[1511]
[1512]
[1513]
[1514]
[1515]
[1516]
[1517]
[1518]
[1519]
[1520]
[1521]
[1522]
[1523]
[1524]
[1525]
[1526]
[1527]
[1528]
[1529]
[1530]
[1531]
[1532]
[1533]
[1534]
[1535]
[1536]
[1537]
[1538]
[1539]
[1540]
[1541]
[1542]
[1543]
[1544]
[1545]
[1546]
[1547]
[1548]
[1549]
[1550]
[1551]
[1552]
[1553]
[1554]
[1555]
[1556]
[1557]
[1558]
[1559]
[1560]
[1561]
[1562]
[1563]
[1564]
[1565]
[1566]
[1567]
[1568]
[1569]
[1570]
[1571]
[1572]
[1573]
[1574]
[1575]
[1576]
[1577]
[1578]
[1579]
[1580]
[1581]
[1582]
[1583]
[1584]
[1585]
[1586]
[1587]
[1588]
[1589]
[1590]
[1591]
[1592]
[1593]
[1594]
[1595]
[1596]
[1597]
[1598]
[1599]
[1600]
[1601]
[1602]
[1603]
[1604]
[1605]
[1606]
[1607]
[1608]
[1609]
[1610]
[1611]
[1612]
[1613]
[1614]
[1615]
[1616]
[1617]
[1618]
[1619]
[1620]
[1621]
[1622]
[1623]
[1624]
[1625]
[1626]
[1627]
[1628]
[1629]
[1630]
[1631]
[1632]
[1633]
[1634]
[1635]
[1636]
[1637]
[1638]
[1639]
[1640]
[1641]
[1642]
[1643]
[1644]
[1645]
[1646]
[1647]
[1648]
[1649]
[1650]
[1651]
[1652]
[1653]
[1654]
[1655]
[1656]
[1657]
[1658]
[1659]
[1660]
[1661]
[1662]
[1663]
[1664]
[1665]
[1666]
[1667]
[1668]
[1669]
[1670]
[1671]
[1672]
[1673]
[1674]
[1675]
[1676]
[1677]
[1678]
[1679]
[1680]
[1681]
[1682]
[1683]
[1684]
[1685]
[1686]
[1687]
[1688]
[1689]
[1690]
[1691]
[1692]
[1693]
[1694]
[1695]
[1696]
[1697]
[1698]
[1699]
[1700]
[1701]
[1702]
[1703]
[1704]
[1705]
[1706]
[1707]
[1708]
[1709]
[1710]
[1711]
[1712]
[1713]
[1714]
[1715]
[1716]
[1717]
[1718]
[1719]
[1720]
[1721]
[1722]
[1723]
[1724]
[1725]
[1726]
[1727]
[1728]
[1729]
[1730]
[1731]
[1732]
[1733]
[1734]
[1735]
[1736]
[1737]
[1738]
[1739]
[1740]
[1741]
[1742]
[1743]
[1744]
[1745]
[1746]
[1747]
[1748]
[1749]
[1750]
[1751]
[1752]
[1753]
[1754]
[1755]
[1756]
[1757]
[1758]
[1759]
[1760]
[1761]
[1762]
[1763]
[1764]
[1765]
[1766]
[1767]
[1768]
[1769]
[1770]
[1771]
[1772]
[1773]
[1774]
[1775]
[1776]
[1777]
[1778]
[1779]
[1780]
[1781]
[1782]
[1783]
[1784]
[1785]
[1786]
[1787]
[1788]
[1789]
[1790]
[1791]
[1792]
[1793]
[1794]
[1795]
[1796]
[1797]
[1798]
[1799]
[1800]
[1801]
[1802]
[1803]
[1804]
[1805]
[1806]
[1807]
[1808]
[1809]
[1810]
[1811]
[1812]
[1813]
[1814]
[1815]
[1816]
[1817]
[1818]
[1819]
[1820]
[1821]
[1822]
[1823]
[1824]
[1825]
[1826]
[1827]
[1828]
[1829]
[1830]
[1831]
[1832]
[1833]
[1834]
[1835]
[1836]
[1837]
[1838]
[1839]
[1840]
[1841]
[1842]
[1843]
[1844]
[1845]
[1846]
[1847]
[1848]
[1849]
[1850]
[1851]
[1852]
[1853]
[1854]
[1855]
[1856]
[1857]
[1858]
[1859]
[1860]
[1861]
[1862]
[1863]
[1864]
[1865]
[1866]
[1867]
[1868]
[1869]
[1870]
[1871]
[1872]
[1873]
[1874]
[1875]
[1876]
[1877]
[1878]
[1879]
[1880]
[1881]
[1882]
[1883]
[1884]
[1885]
[1886]
[1887]
[1888]
[1889]
[1890]
[1891]
[1892]
[1893]
[1894]
[1895]
[1896]
[1897]
[1898]
[1899]
[1900]
[1901]
[1902]
[1903]
[1904]
[1905]
[1906]
[1907]
[1908]
[1909]
[1910]
[1911]
[1912]
[1913]
[1914]
[1915]
[1916]
[1917]
[1918]
[1919]
[1920]
[1921]
[1922]
[1923]
[1924]
[1925]
[1926]
[1927]
[1928]
[1929]
[1930]
[1931]
[1932]
[1933]
[1934]
[1935]
[1936]
[1937]
[1938]
[1939]
[1940]
[1941]
[1942]
[1943]
[1944]
[1945]
[1946]
[1947]
[1948]
[1949]
[1950]
[1951]
[1952]
[1953]
[1954]
[1955]
[1956]
[1957]
[1958]
[1959]
[1960]
[1961]
[1962]
[1963]
[1964]
[1965]
[1966]
[1967]
[1968]
[1969]
[1970]
[1971]
[1972]
[1973]
[1974]
[1975]
[1976]
[1977]
[1978]
[1979]
[1980]
[1981]
[1982]
[1983]
[1984]
[1985]
[1986]
[1987]
[1988]
[1989]
[1990]
[1991]
[1992]
[1993]
[1994]
[1995]
[1996]
[1997]
[1998]
[1999]
[2000]
[2001]
[2002]
[2003]
[2004]
[2005]
[2006]
[2007]
[2008]
[2009]
[2010]
[2011]
[2012]
[2013]
[2014]
[2015]
[2016]
[2017]
[2018]
[2019]
[2020]
[2021]
[2022]
[2023]
[2024]
[2025]
[2026]
[2027]
[2028]
[2029]
[2030]
[2031]
[2032]
[2033]
[2034]
[2035]
[2036]
[2037]
[2038]
[2039]
[2040]
[2041]
[2042]
[2043]
[2044]
[2045]
[2046]
[2047]
[2048]
[2049]
[2050]
[2051]
[2052]
[2053]
[2054]
[2055]
[2056]
[2057]
[2058]
[2059]
[2060]
[2061]
[2062]
[2063]
[2064]
[2065]
[2066]
[2067]
[2068]
[2069]
[2070]
[2071]
[2072]
[2073]
[2074]
[2075]
[2076]
[2077]
[2078]
[2079]
[2080]
[2081]
[2082]
[2083]
[2084]
[2085]
[2086]
[2087]
[2088]
[2089]
[2090]
[2091]
[2092]
[2093]
[2094]
[2095]
[2096]
[2097]
[2098]
[2099]
[2100]
[2101]
[2102]
[2103]
[2104]
[2105]
[2106]
[2107]
[2108]
[2109]
[2110]
[2111]
[2112]
[2113]
[2114]
[2115]
[2116]
[2117]
[2118]
[2119]
[2120]
[2121]
[2122]
[2123]
[2124]
[2125]
[2126]
[2127]
[2128]
[2129]
[2130]
[2131]
[2132]
[2133]
[2134]
[2135]
[2136]
[2137]
[2138]
[2139]
[2140]
[2141]
[2142]
[2143]
[2144]
[2145]
[2146]
[2147]
[2148]
[2149]
[2150]
[2151]
[2152]
[2153]
[2154]
[2155]
[2156]
[2157]
[2158]
[2159]
[2160]
[2161]
[2162]
[2163]
[2164]
[2165]
[2166]
[2167]
[2168]
[2169]
[2170]
[2171]
[2172]
[2173]
[2174]
[2175]
[2176]
[2177]
[2178]
[2179]
[2180]
[2181]
[2182]
[2183]
[2184]
[2185]
[2186]
[2187]
[2188]
[2189]
[2190]
[2191]
[2192]
[2193]
[2194]
[2195]
[2196]
[2197]
[2198]
[2199]
[2200]
[2201]
[2202]
[2203]
[2204]
[2205]
[2206]
[2207]
[2208]
[2209]
[2210]
[2211]
[2212]
[2213]
[2214]
[2215]
[2216]
[2217]
[2218]
[2219]
[2220]
[2221]
[2222]
[2223]
[2224]
[2225]
[2226]
[2227]
[2228]
[2229]
[2230]
[2231]
[2232]
[2233]
[2234]
[2235]
[2236]
[2237]
[2238]
[2239]
[2240]
[2241]
[2242]
[2243]
[2244]
[2245]
[2246]
[2247]
[2248]
[2249]
[2250]
[2251]
[2252]
[2253]
[2254]
[2255]
[2256]
[2257]
[2258]
[2259]
[2260]
[2261]
[2262]
[2263]
[2264]
[2265]
[2266]
[2267]
[2268]
[2269]
[2270]
[2271]
[2272]
[2273]
[2274]
[2275]
[2276]
[2277]
[2278]
[2279]
[2280]
[2281]
[2282]
[2283]
[2284]
[2285]
[2286]
[2287]
[2288]
[2289]
[2290]
[2291]
[2292]
[2293]
[2294]
[2295]
[2296]
[2297]
[2298]
[2299]
[2300]
[2301]
[2302]
[2303]
[2304]
[2305]
[2306]
[2307]
[2308]
[2309]
[2310]
[2311]
[2312]
[2313]
[2314]
[2315]
[2316]
[2317]
[2318]
[2319]
[2320]
[2321]
[2322]
[2323]
[2324]
[2325]
[2326]
[2327]
[2328]
[2329]
[2330]
[2331]
[2332]
[2333]
[2334]
[2335]
[2336]
[2337]
[2338]
[2339]
[2340]
[2341]
[2342]
[2343]
[2344]
[2345]
[2346]
[2347]
[2348]
[2349]
[2350]
[2351]
[2352]
[2353]
[2354]
[2355]
[2356]
[2357]
[2358]
[2359]
[2360]
[2361]
[2362]
[2363]
[2364]
[2365]
[2366]
[2367]
[2368]
[2369]
[2370]
[2371]
[2372]
[2373]
[2374]
[2375]
[2376]
[2377]
[2378]
[2379]
[2380]
[2381]
[2382]
[2383]
[2384]
[2385]
[2386]
[2387]
[2388]
[2389]
[2390]
[2391]
[2392]
[2393]
[2394]
[2395]
[2396]
[2397]
[2398]
[2399]
[2400]
[2401]
[2402]
[2403]
[2404]
[2405]
[2406]
[2407]
[2408]
[2409]
[2410]
[2411]
[2412]
[2413]
[2414]
[2415]
[2416]
[2417]
[2418]
[2419]
[2420]
[2421]
[2422]
[2423]
[2424]
[2425]
[2426]
[2427]
[2428]
[2429]
[2430]
[2431]
[2432]
[2433]
[2434]
[2435]
[2436]
[2437]
[2438]
[2439]
[2440]
[2441]
[2442]
[2443]
[2444]
[2445]
[2446]
[2447]
[2448]
[2449]
[2450]
[2451]
[2452]
[2453]
[2454]
[2455]
[2456]
[2457]
[2458]
[2459]
[2460]
[2461]
[2462]
[2463]
[2464]
[2465]
[2466]
[2467]
[2468]
[2469]
[2470]
[2471]
[2472]
[2473]
[2474]
[2475]
[2476]
[2477]
[2478]
[2479]
[2480]
[2481]
[2482]
[2483]
[2484]
[2485]
[2486]
[2487]
[2488]
[2489]
[2490]
[2491]
[2492]
[2493]
[2494]
[2495]
[2496]
[2497]
[2498]
[2499]
[2500]
[2501]
[2502]
[2503]
[2504]
[2505]
[2506]
[2507]
[2508]
[2509]
[2510]
[2511]
[2512]
[2513]
[2514]
[2515]
[2516]
[2517]
[2518]
[2519]
[2520]
[2521]
[2522]
[2523]
[2524]
[2525]
[2526]
[2527]
[2528]
[2529]
[2530]
[2531]
[2532]
[2533]
[2534]
[2535]
[2536]
[2537]
[2538]
[2539]
[2540]
[2541]
[2542]
[2543]
[2544]
[2545]
[2546]
[2547]
[2548]
[2549]
[2550]
[2551]
[2552]
[2553]
[2554]
[2555]
[2556]
[2557]
[2558]
[2559]
[2560]
[2561]
[2562]
[2563]
[2564]
[2565]
[2566]
[2567]
[2568]
[2569]
[2570]
[2571]
[2572]
[2573]
[2574]
[2575]
[2576]
[2577]
[2578]
[2579]
[2580]
[2581]
[2582]
[2583]
[2584]
[2585]
[2586]
[2587]
[2588]
[2589]
[2590]
[2591]
[2592]
[2593]
[2594]
[2595]
[2596]
[2597]
[2598]
[2599]
[2600]
[2601]
[2602]
[2603]
[2604]
[2605]
[2606]
[2607]
[2608]
[2609]
[2610]
[2611]
[2612]
[2613]
[2614]
[2615]
[2616]
[2617]
[2618]
[2619]
[2620]
[2621]
[2622]
[2623]
[2624]
[2625]
[2626]
[2627]
[2628]
[2629]
[2630]
[2631]
[2632]
[2633]
[2634]
[2635]
[2636]
[2637]
[2638]
[2639]
[2640]
[2641]
[2642]
[2643]
[2644]
[2645]
[2646]
[2647]
[2648]
[2649]
[2650]
[2651]
[2652]
[2653]
[2654]
[2655]
[2656]
[2657]
[2658]
[2659]
[2660]
[2661]
[2662]
[2663]
[2664]
[2665]
[2666]
[2667]
[2668]
[2669]
[2670]
[2671]
[2672]
[2673]
[2674]
[2675]
[2676]
[2677]
[2678]
[2679]
[2680]
[2681]
[2682]
[2683]
[2684]
[2685]
[2686]
[2687]
[2688]
[2689]
[2690]
[2691]
[2692]
[2693]
[2694]
[2695]
[2696]
[2697]
[2698]
[2699]
[2700]
[2701]
[2702]
[2703]
[2704]
[2705]
[2706]
[2707]
[2708]
[2709]
[2710]
[2711]
[2712]
[2713]
[2714]
[2715]
[2716]
[2717]
[2718]
[2719]
[2720]
[2721]
[2722]
[2723]
[2724]
[2725]
[2726]
[2727]
[2728]
[2729]
[2730]
[2731]
[2732]
[2733]
[2734]
[2735]
[2736]
[2737]
[2738]
[2739]
[2740]
[2741]
[2742]
[2743]
[2744]
[2745]
[2746]
[2747]
[2748]
[2749]
[2750]
[2751]
[2752]
[2753]
[2754]
[2755]
[2756]
[2757]
[2758]
[2759]
[2760]
[2761]
[2762]
[2763]
[2764]
[2765]
[2766]
[2767]
[2768]
[2769]
[2770]
[2771]
[2772]
[2773]
[2774]
[2775]
[2776]
[2777]
[2778]
[2779]
[2780]
[2781]
[2782]
[2783]
[2784]
[2785]
[2786]
[2787]
[2788]
[2789]
[2790]
[2791]
[2792]
[2793]
[2794]
[2795]
[2796]
[2797]
[2798]
[2799]
[2800]
[2801]
[2802]
[2803]
[2804]
[2805]
[2806]
[2807]
[2808]
[2809]
[2810]
[2811]
[2812]
[2813]
[2814]
[2815]
[2816]
[2817]
[2818]
[2819]
[2820]
[2821]
[2822]
[2823]
[2824]
[2825]
[2826]
[2827]
[2828]
[2829]
[2830]
[2831]
[2832]
[2833]
[2834]
[2835]
[2836]
[2837]
[2838]
[2839]
[2840]
[2841]
[2842]
[2843]
[2844]
[2845]
[2846]
[2847]
[2848]
[2849]
[2850]
[2851]
[2852]
[2853]
[2854]
[2855]
[2856]
[2857]
[2858]
[2859]
[2860]
[2861]
[2862]
[2863]
[2864]
[2865]
[2866]
[2867]
[2868]
[2869]
[2870]
[2871]
[2872]
[2873]
[2874]
[2875]
[2876]
[2877]
[2878]
[2879]
[2880]
[2881]
[2882]
[2883]
[2884]
[2885]
[2886]
[2887]
[2888]
[2889]
[2890]
[2891]
[2892]
[2893]
[2894]
[2895]
[2896]
[2897]
[2898]
[2899]
[2900]
[2901]
[2902]
[2903]
[2904]
[2905]
[2906]
[2907]
[2908]
[2909]
[2910]
[2911]
[2912]
[2913]
[2914]
[2915]
[2916]
[2917]
[2918]
[2919]
[2920]
[2921]
[2922]
[2923]
[2924]
[2925]
[2926]
[2927]
[2928]
[2929]
[2930]
[2931]
[2932]
[2933]
[2934]
[2935]
[2936]
[2937]
[2938]
[2939]
[2940]
[2941]
[2942]
[2943]
[2944]
[2945]
[2946]
[2947]
[2948]
[2949]
[2950]
[2951]
[2952]
[2953]
[2954]
[2955]
[2956]
[2957]
[2958]
[2959]
[2960]
[2961]
[2962]
[2963]
[2964]
[2965]
[2966]
[2967]
[2968]
[2969]
[2970]
[2971]
[2972]
[2973]
[2974]
[2975]
[2976]
[2977]
[2978]
[2979]
[2980]
[2981]
[2982]
[2983]
[2984]
[2985]
[2986]
[2987]
[2988]
[2989]
[2990]
[2991]
[2992]
[2993]
[2994]
[2995]
[2996]
[2997]
[2998]
[2999]
[3000]
[3001]
[3002]
[3003]
[3004]
[3005]
[3006]
[3007]
[3008]
[3009]
[3010]
[3011]
[3012]
[3013]
[3014]
[3015]
[3016]
[3017]
[3018]
[3019]
[3020]
[3021]
[3022]
[3023]
[3024]
[3025]
[3026]
[3027]
[3028]
[3029]
[3030]
[3031]
[3032]
[3033]
[3034]
[3035]
[3036]
[3037]
[3038]
[3039]
[3040]
[3041]
[3042]
[3043]
[3044]
[3045]
[3046]
[3047]
[3048]
[3049]
[3050]
[3051]
[3052]
[3053]
[3054]
[3055]
[3056]
[3057]
[3058]
[3059]
[3060]
[3061]
[3062]
[3063]
[3064]
[3065]
[3066]
[3067]
[3068]
[3069]
[3070]
[3071]
[3072]
[3073]
[3074]
[3075]
[3076]
[3077]
[3078]
[3079]
[3080]
[3081]
[3082]
[3083]
[3084]
[3085]
[3086]
[3087]
[3088]
[3089]
[3090]
[3091]
[3092]
[3093]
[3094]
[3095]
[3096]
[3097]
[3098]
[3099]
[3100]
[3101]
[3102]
[3103]
[3104]
[3105]
[3106]
[3107]
[3108]
[3109]
[3110]
[3111]
[3112]
[3113]
[3114]
[3115]
[3116]
[3117]
[3118]
[3119]
[3120]
[3121]
[3122]
[3123]
[3124]
[3125]
[3126]
[3127]
[3128]
[3129]
[3130]
[3131]
[3132]
[3133]
[3134]
[3135]
[3136]
[3137]
[3138]
[3139]
[3140]
[3141]
[3142]
[3143]
[3144]
[3145]
[3146]
[3147]
[3148]
[3149]
[3150]
[3151]
[3152]
[3153]
[3154]
[3155]
[3156]
[3157]
[3158]
[3159]
[3160]
[3161]
[3162]
[3163]
[3164]
[3165]
[3166]
[3167]
[3168]
[3169]
[3170]
[3171]
[3172]
[3173]
[3174]
[3175]
[3176]
[3177]
[3178]
[3179]
[3180]
[3181]
[3182]
[3183]
[3184]
[3185]
[3186]
[3187]
[3188]
[3189]
[3190]
[3191]
[3192]
[3193]
[3194]
[3195]
[3196]
[3197]
[3198]
[3199]
[3200]
[3201]
[3202]
[3203]
[3204]
[3205]
[3206]
[3207]
[3208]
[3209]
[3210]
[3211]
[3212]
[3213]
[3214]
[3215]
[3216]
[3217]
[3218]
[3219]
[3220]
[3221]
[3222]
[3223]
[3224]
[3225]
[3226]
[3227]
[3228]
[3229]
[3230]
[3231]
[3232]
[3233]
[3234]
[3235]
[3236]
[3237]
[3238]
[3239]
[3240]
[3241]
[3242]
[3243]
[3244]
[3245]
[3246]
[3247]
[3248]
[3249]
[3250]
[3251]
[3252]
[3253]
[3254]
[3255]
[3256]
[3257]
[3258]
[3259]
[3260]
[3261]
[3262]
[3263]
[3264]
[3265]
[3266]
[3267]
[3268]
[3269]
[3270]
[3271]
[3272]
[3273]
[3274]
[3275]
[3276]
[3277]
[3278]
[3279]
[3280]
[3281]
[3282]
[3283]
[3284]
[3285]
[3286]
[3287]
[3288]
[3289]
[3290]
[3291]
[3292]
[3293]
[3294]
[3295]
[3296]
[3297]
[3298]
[3299]
[3300]
[3301]
[3302]
[3303]
[3304]
[3305]
[3306]
[3307]
[3308]
[3309]
[3310]
[3311]
[3312]
[3313]
[3314]
[3315]
[3316]
[3317]
[3318]
[3319]
[3320]
[3321]
[3322]
[3323]
[3324]
[3325]
[3326]
[3327]
[3328]
[3329]
[3330]
[3331]
[3332]
[3333]
[3334]
[3335]
[3336]
[3337]
[3338]
[3339]
[3340]
[3341]
[3342]
[3343]
[3344]
[3345]
[3346]
[3347]
[3348]
[3349]
[3350]
[3351]
[3352]
[3353]
[3354]
[3355]
[3356]
[3357]
[3358]
[3359]
[3360]
[3361]
[3362]
[3363]
[3364]
[3365]
[3366]
[3367]
[3368]
[3369]
[3370]
[3371]
[3372]
[3373]
[3374]
[3375]
[3376]
[3377]
[3378]
[3379]
[3380]
[3381]
[3382]
[3383]
[3384]
[3385]
[3386]
[3387]
[3388]
[3389]
[3390]
[3391]
[3392]
[3393]
[3394]
[3395]
[3396]
[3397]
[3398]
[3399]
[3400]
[3401]
[3402]
[3403]
[3404]
[3405]
[3406]
[3407]
[3408]
[3409]
[3410]
[3411]
[3412]
[3413]
[3414]
[3415]
[3416]
[3417]
[3418]
[3419]
[3420]
[3421]
[3422]
[3423]
[3424]
[3425]
[3426]
[3427]
[3428]
[3429]
[3430]
[3431]
[3432]
[3433]
[3434]
[3435]
[3436]
[3437]
[3438]
[3439]
[3440]
[3441]
[3442]
[3443]
[3444]
[3445]
[3446]
[3447]
[3448]
[3449]
[3450]
[3451]
[3452]
[3453]
[3454]
[3455]
[3456]
[3457]
[3458]
[3459]
[3460]
[3461]
[3462]
[3463]
[3464]
[3465]
[3466]
[3467]
[3468]
[3469]
[3470]
[3471]
[3472]
[3473]
[3474]
[3475]
[3476]
[3477]
[3478]
[3479]
[3480]
[3481]
[3482]
[3483]
[3484]
[3485]
[3486]
[3487]
[3488]
[3489]
[3490]
[3491]
[3492]
[3493]
[3494]
[3495]
[3496]
[3497]
[3498]
[3499]
[3500]
[3501]
[3502]
[3503]
[3504]
[3505]
[3506]
[3507]
[3508]
[3509]
[3510]
[3511]
[3512]
[3513]
[3514]
[3515]
[3516]
[3517]
[3518]
[3519]
[3520]
[3521]
[3522]
[3523]
[3524]
[3525]
[3526]
[3527]
[3528]
[3529]
[3530]
[3531]
[3532]
[3533]
[3534]
[3535]
[3536]
[3537]
[3538]
[3539]
[3540]
[3541]
[3542]
[3543]
[3544]
[3545]
[3546]
[3547]
/*****************************************************************************/
/*
ODS.c
Module supports file system access for both ODS-2 and where appropriate (Alpha
VMS v7.2ff) ODS-5. This supports transparent access to ODS-5 file system
structure for the serving of data from the file-system. (The WASD package
files however must still be supported inside of ODS-2 conventions.)
Basically it does this by abstracting the NAM block so that either the standard
or long formats may be used without other modules needing to be aware of the
underlying structure. The VAX version does not need to know about long NAMs,
or extended file specifications in general (excluded for code compactness and
minor efficiency reasons using the ODS_EXTENDED macro). Alpha versions prior
to 7.2 do not know about NAMLs and so for compilation in these environments a
compatible NAML is provided (ENAMEL.H header file), allowing extended file
specification compliant code to be compiled and linked on pre-v7.2 systems.
Runtime decision structures based on the VMS version, device ACP type, etc.,
must be used if pre-v7.2 systems are to avoid using the NAML structure with RMS
(which would of course result in runtime errors). In this way a single set of
base-level Alpha object modules, built in either environment, will support both
pre and post 7.2 environments.
The essential accessability to and functionality of RMS is not buried too
deeply by this wrapping. File operations are still performed using RMS data
structures and services wherever possible, only those that process using NAM
structures are, and need to be, abstracted in this way (i.e. sys$open(),
sys$parse(), sys$search()). ASTs are called using the same conventions as the
RMS service counterpart (i.e. with a pointer to the same data structure), and
success should be checked using the same mechanisms, etc.
Even when not supplying an AST address it is advised to supply the AST
parameter (usually a request or task pointer). The reason? Well this is often
placed into the FAB or RAB context storage for retrieval by an AST routine
subsequently and explicitly called by the code. Experience has shown it's easy
to forget to set up this context in the non-AST instance ;^)
ATR$C_MODDATE vs. ATR$C_REVDATE
-------------------------------
Fairly late in the piece (see version log) it was reported that the classic
ATR$C_REVDATE also reflected changes to file attributes (e.g. an ACL modified)
as well as to data. For ODS-5 volumes the ATR$C_MODDATE attribute was added to
record exclusively when file *data* was modified. It was suggested that this
better represents the state for directory listings and certainly for WebDAV.
So, as of the version log, for extended file processing (ODS-5), the
ATR$C_MODDATE will be used by default. When present, this value is retrieved
from the attributes and automatically copied onto the ATR$C_REVDATE structure
item, meaning no downstream changes. To disable this behaviour and return a
server to providing the ATR$C_REVDATE define the logical name WASD_ODS_REVDATE
before server startup.
DISPLAYING FILE SPECIFICATIONS
------------------------------
As there are a number of ways of displaying VMS file names in mixed ODS-2 and
ODS-5 environments this module seemed the appropriate place to discuss the WASD
approach (although much of this processing is distributed through the MAPURL.C,
DIR.C and UPD.C modules).
Prior to the extended file specifications of VMS V7.2 and following WASD tended
to default all file and directory paths to lower case (as this is commonly
considered more aesthetically pleasing - and to the author). This is obvious
in directory listings but may also be seen in UPD.C and SSI.C file naming.
Optionally then DIR.C module would display specification in upper case (for
instance if a semicolon was used in the URL path).
Now that extended file specifications exist in Alpha VMS V7.2 and following
there exist a number of methods of displaying file names. Files on ODS-2
volumes continue to be treated as described above. Files from ODS-5 volumes
become more complex as a number of options are available. As ODS-5 supports a
mixed upper and lower case character set WASD no longer forces case, names are
displayed as stored on-disk. RMS displays many non-alpha-numeric characters
using escape sequences, of which some have multiple, possible representations
(e.g. the space, "^ ", "^_", "^20", and other possibles).
In addition, a Web URL has it's own escape syntax for forbidden characters, the
"%xx" hexadecimal representation. WASD attempts to accept file specifications
in either RMS-escape syntax or URL-escape syntax. Presentation is most
commonly done using URL-escape syntax, but may in directory listing be
optionally displayed in RMS ("^_") and even on-disk format (" ") (see the DIR.C
module).
16 BIT (UNICODE) FILE NAMES ARE NOT SUPPORTED!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VERSION HISTORY
---------------
14-OCT-2020 MGD OdsFileAcpInfo() ATR$C_MODDATE (date-time *data* modified)
supplements ATR$C_REVDATE (classic revision date-time)
25-SEP-2020 MGD bugfix; OdsDirectSearch() appending the resultant file name
to the pre-filled expanded name
11-AUG-2020 MGD bugfix; OdsDirectSearch() if wildcard specification
return RMS$_NMF, otherwise RMS$_FNF (seems so elementary)
30-JUN-2020 MGD expand WASD_ODS_NODIRECT for comma-separated device names
28-NOV-2019 MGD bugfix; OdsDirectSearch() RMS$_FNF not RMS$_NMF (per JPP)
04-AUG-2019 MGD bugfix; OdsDirectSearch() only if not already on the block
boundary add one to get to next, otherwise already there!
08-JAN-2019 MGD bugfix; OdsDirectSearch() (uint)0xffff && rlen < 508)
05-MAY-2018 MGD OdsDirectSearch() et.al. directory parse
disabled by $ DEFINE /SYSTEM WASD_ODS_NODIRECT *
OdsStructInit() formalises initialisation of ODS structure
25-JUN-2014 MGD bugfix; enabling SYSPRV ensure it is only disabled
afterwards when it wasn't previously enabled
27-SEP-2013 MGD OdsNamBlockAst() on non-ODS_EXTENDED platforms (i.e. VAX)
add Nam.nam$l_ver to Nam.nam$l_type and Nam.nam$l_name
06-JUN-2013 MGD OdsNamBlockAst() on non-ODS_EXTENDED platforms (i.e. VAX)
tease-out system file name from Nam.nam$l_name and
Nam.nam$l_type into odsptr->SysFileName buffer
historically used by ODS-5 and munge for ODS-2 as well
bugfix; OdsParseTerminate() on non-ODS_EXTENDED platforms
(i.e. VAX) reset .nam$b_esl to changed expanded length
or it can generate RMS$_ESL errors - check it out!
30-SEP-2011 MGD bugfix; OdsFileExists() parse NAM$M_NOCONCEAL in case of
multi-valued, concealed logical devices and then convert
returned status DNF into the functional equivalent FNF
13-MAR-2011 MGD OdsLoadTextFile() transmogrify embedded null char to space
23-JUN-2010 MGD bugfix; OdsNamBlockAst() odsptr->NamFileSysNamePtr
always set to odsptr->SysFileName in case RMS$_FNF, etc.
08-JUN-2010 MGD OdsParseTerminate() allow for trailing period(s)
bugfix; OdsNameOfDirectoryFile() allow for '^[' and '^]'
13-JUN-2009 MGD OdsNameOfDirectoryFile() delay return argument reset
make cached name comparison case-sensitive (WebDAV)
18-JAN-2008 MGD OdsOpen() and OdsCreate() support STR_DSC
OdsClose() refine FAB$M_DLT and FAB$M_TEF handling
10-AUG-2007 MGD OdsReallyADir()
25-MAY-2007 MGD OdsNameOfDirectoryFile() no longer mandatory that a
directory file actually exists to generate the name
OdsFileAcpInfo() add ATR$C_UCHAR to attributes retrieved
bugfix; OdsNamBlockAst() deliver AST with 'AstParam'
(requiring parameter changes to *lots* of AST functions
called by use of OdsParse() and OdsSearch() - bugga!)
24-APR-2007 MGD OdsCreate() to allow explicit file creation
bugfix; OdsNameOfDirectoryFile() allow for '^.'
02-OCT-2006 MGD OdsVolumeStructure() originally MapOdsVolumeStruct()
07-DEC-2002 MGD bugfix; in OdsNameOfDirectoryFile() use SYSPRV
around sys$parse() to ensure access to directory
05-OCT-2002 MGD make OdsFileExists() a little more flexible
03-JUN-2002 MGD bugfix; ensure when OdsParse() is used successively with
the same ODS structure that previous resources are first
released (can present a problem unique to search lists)
05-JAN-2002 MGD bugfix; VAX OdsSearchNoConceal() expanded buffer
17-NOV-2001 MGD OdsSearchNoConceal() and modifications to OdsNamBlockAst()
to support "charset=(file,charset)" processing
10-OCT-2001 MGD bugfix; sys$close() in OdsLoadTextFile()
04-AUG-2001 MGD OdsCopyStructure(), OdsFreeTextFile(),
support module WATCHing,
bugfix; NamFileSysNamePtr/Length in OdsFileAcpInfo()
28-FEB-2001 MGD OdsLoadTextFile(), OdsParseTextFile()
09-JUN-2000 MGD search-list processing refined
26-DEC-1999 MGD initial
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
/* VMS related header files */
#include <descrip.h>
#include <devdef.h>
#include <dvidef.h>
#include <iodef.h>
#include <prvdef.h>
#include <rmsdef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application related header files */
#include "wasd.h"
#define WASD_MODULE "ODS"
#define ODS_PARSE_IN_USE_PATTERN 0xa5a55a5a
/******************/
/* global storage */
/******************/
BOOL OdsUseModDate;
#if ODS_DIRECT
BOOL OdsDirect,
OdsExtended;
char *OdsNoDirect;
#else
BOOL OdsExtended;
#endif
/********************/
/* external storage */
/********************/
extern int EfnWait,
EfnNoWait,
OpcomMessages;
extern int ToLowerCase[],
ToUpperCase[];
extern unsigned long SysPrvMask[];
extern ACCOUNTING_STRUCT *AccountingPtr;
extern MSG_STRUCT Msgs;
extern SYS_INFO SysInfo;
extern WATCH_STRUCT Watch;
/****************************************************************************/
/*
Set the ODS extended flag (i.e. supports ODS-5) if the architecture is not VAX
and the VMS version is 7.2ff and not explicitly disabled at the command line.
Check whether any ENAMEL.H NAML structure basically looks ok.
*/
OdsSetExtended ()
{
char *cptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsSetExtended()");
#ifdef ODS_EXTENDED
#ifdef ENAMEL_NAML
/* just a check for stupid errors on compilations using ENAMEL.H NAML */
if (sizeof(struct NAML) != NAML$C_BLN)
{
FaoToStdout ("%HTTPD-W-ENAMEL, NAML problem, \
extended file specifications not supported\n");
if (OpcomMessages & OPCOM_HTTPD)
FaoToOpcom ("%HTTPD-W-ENAMEL, NAML problem, \
extended file specifications not supported\n");
OdsExtended = false;
return;
}
#endif /* ENAMEL_NAML */
#endif /* ODS_EXTENDED */
if (SysInfo.VersionInteger >= 720) OdsExtended = true;
FaoToStdout ("%HTTPD-I-ODS5, !AZsupported by !AZ VMS !AZ\n",
OdsExtended ? "" : "not ",
#ifdef __ALPHA
"Alpha",
#endif
#ifdef __ia64
"IA64",
#endif
#ifdef __x86_64
"x86-64",
#endif
SysInfo.Version);
if (OdsExtended)
{
OdsUseModDate = (SysTrnLnm(WASD_ODS_REVDATE) == NULL);
if (!OdsUseModDate) FaoToStdout ("%HTTPD-I-ODS, using ATR$C_REVDATE\n");
}
#if ODS_DIRECT
OdsDirect = true;
OdsNoDirect = SysTrnLnm(WASD_ODS_NODIRECT);
if (OdsNoDirect)
if (OdsNoDirect[0] == '*')
OdsDirect = false;
else
OdsNoDirect = strdup (OdsNoDirect);
FaoToStdout ("%HTTPD-I-ODS, directory parser !AZ\n",
OdsDirect ? "enabled" : "disabled");
if (OdsDirect && OdsNoDirect)
FaoToStdout ("-HTTPD-I-ODS, exclude !AZ\n", OdsNoDirect);
#endif /* ODS_DIRECT */
}
/*****************************************************************************/
/*
Initialise an ODS structure. If on the stack then zero the memory. Otherwise
assume the structure is already in zero-allocated memory or equivalent.
*/
void OdsStructInit
(
ODS_STRUCT *odsptr,
BOOL OnStack
)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsStructInit() !&B", OnStack);
if (OnStack) memset (odsptr, 0, sizeof(ODS_STRUCT));
}
/****************************************************************************/
/*
Generic open for read. Intended for configuration files, etc., but also used to
read the raw content of a file in block mode. Completely synchronous with a RAB
connected for sequential read.
*/
int OdsOpenReadOnly
(
ODS_STRUCT *odsptr,
char *FileSpec,
BOOL BlockIO
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsOpenReadOnly() !&B !&B !&Z",
OdsExtended, BlockIO, FileSpec);
OdsStructInit (odsptr, true);
odsptr->Fab = cc$rms_fab;
if (BlockIO)
odsptr->Fab.fab$b_fac = FAB$M_GET | FAB$M_BIO;
else
odsptr->Fab.fab$b_fac = FAB$M_GET;
odsptr->Fab.fab$b_shr = FAB$M_SHRGET;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
odsptr->Fab.fab$l_fna = -1;
odsptr->Fab.fab$b_fns = 0;
odsptr->Fab.fab$l_nam = &odsptr->Naml;
odsptr->NamlInUse = true;
ENAMEL_RMS_NAML(odsptr->Naml)
odsptr->Naml.naml$l_long_filename = FileSpec;
odsptr->Naml.naml$l_long_filename_size = strlen(FileSpec);
odsptr->Naml.naml$l_long_expand = odsptr->ExpFileName;
odsptr->Naml.naml$l_long_expand_alloc = sizeof(odsptr->ExpFileName)-1;
odsptr->Naml.naml$l_long_result = odsptr->ResFileName;
odsptr->Naml.naml$l_long_result_alloc = sizeof(odsptr->ResFileName)-1;
odsptr->Naml.naml$l_filesys_name = odsptr->SysFileName;
odsptr->Naml.naml$l_filesys_name_alloc = sizeof(odsptr->SysFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
odsptr->Fab.fab$l_fna = FileSpec;
odsptr->Fab.fab$b_fns = strlen(FileSpec);
odsptr->Fab.fab$l_nam = &odsptr->Nam;
odsptr->NamlInUse = false;
odsptr->Nam = cc$rms_nam;
odsptr->Nam.nam$l_esa = odsptr->ExpFileName;
odsptr->Nam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
odsptr->Nam.nam$l_rsa = odsptr->ResFileName;
odsptr->Nam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
/* initialize the date, header and protection extended attribute blocks */
odsptr->Fab.fab$l_xab = &odsptr->XabDat;
odsptr->XabDat = cc$rms_xabdat;
odsptr->XabDat.xab$l_nxt = &odsptr->XabFhc;
odsptr->XabFhc = cc$rms_xabfhc;
odsptr->XabFhc.xab$l_nxt = &odsptr->XabPro;
odsptr->XabPro = cc$rms_xabpro;
odsptr->Fab.fab$l_fop &= ~FAB$M_ASY;
status = sys$open (&odsptr->Fab, 0, 0);
if (VMSnok (status) || VMSnok (status = odsptr->Fab.fab$l_sts))
return (status);
/* set up the generic information from the NAM(L) block */
odsptr->Fab.fab$l_ctx = odsptr;
OdsNamBlockAst (&odsptr->Fab);
/* record access block */
odsptr->Rab = cc$rms_rab;
odsptr->Rab.rab$l_fab = &odsptr->Fab;
/* 2 buffers of six blocks each */
odsptr->Rab.rab$b_mbc = 6;
odsptr->Rab.rab$b_mbf = 2;
/* read ahead performance option */
odsptr->Rab.rab$l_rop = RAB$M_RAH;
/* all synchronous (for now anyway) */
odsptr->Rab.rab$l_rop &= ~FAB$M_ASY;
if (BlockIO)
{
/* sequentially by block */
odsptr->Rab.rab$l_rop |= RAB$M_BIO;
odsptr->Rab.rab$l_bkt = 0;
}
status = sys$connect (&odsptr->Rab, 0, 0);
if (VMSnok (status) || VMSnok (status = odsptr->Rab.rab$l_sts))
{
sys$close (&odsptr->Fab, 0, 0);
return (status);
}
return (status);
}
/****************************************************************************/
/*
RMS open the supplied file specification (using appropriate standard or long
NAM structure). OdsNamBlockAst() is always called, which sets a number of
pointers and other data from the NAM block so that calling functions do not
need to know which was used.
*/
int OdsOpen
(
ODS_STRUCT *odsptr,
char *FileSpec,
int FileSpecLength,
char *DefaultSpec,
int DefaultSpecLength,
int FabFac,
int FabFop,
int FabShr,
GENERAL_AST AstFunction,
unsigned long AstParam
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsOpen() !&B !AZ !AZ !&A(!&X)",
OdsExtended,
FileSpecLength == -1 ?
STR_DSC_PTR((STR_DSC*)FileSpec) : FileSpec,
DefaultSpecLength == -1 ?
STR_DSC_PTR((STR_DSC*)DefaultSpec) : DefaultSpec,
AstFunction, AstParam);
OdsStructInit (odsptr, true);
odsptr->AstFunction = AstFunction;
odsptr->AstParam = AstParam;
if (FabFop & FAB$M_DLT)
odsptr->DeleteOnClose = true;
else
odsptr->DeleteOnClose = false;
if (FileSpecLength == -1)
{
/* use the WASD descriptor */
FileSpecLength = STR_DSC_LEN((STR_DSC*)FileSpec);
FileSpec = STR_DSC_PTR((STR_DSC*)FileSpec);
}
else
if (!FileSpecLength && FileSpec)
FileSpecLength = strlen(FileSpec);
if (DefaultSpecLength == -1)
{
/* use the WASD descriptor */
DefaultSpecLength = STR_DSC_LEN((STR_DSC*)DefaultSpec);
DefaultSpec = STR_DSC_PTR((STR_DSC*)DefaultSpec);
}
else
if (!DefaultSpecLength && DefaultSpec)
DefaultSpecLength = strlen(DefaultSpec);
odsptr->Fab = cc$rms_fab;
odsptr->Fab.fab$l_ctx = odsptr;
odsptr->Fab.fab$b_fac = FabFac;
odsptr->Fab.fab$l_fop = FabFop;
odsptr->Fab.fab$b_shr = FabShr;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
odsptr->Fab.fab$l_fna = -1;
odsptr->Fab.fab$b_fns = 0;
odsptr->Fab.fab$l_nam = &odsptr->Naml;
odsptr->NamlInUse = true;
ENAMEL_RMS_NAML(odsptr->Naml)
odsptr->Naml.naml$l_long_defname = DefaultSpec;
odsptr->Naml.naml$l_long_defname_size = DefaultSpecLength;
odsptr->Naml.naml$l_long_filename = FileSpec;
odsptr->Naml.naml$l_long_filename_size = FileSpecLength;
odsptr->Naml.naml$l_long_expand = odsptr->ExpFileName;
odsptr->Naml.naml$l_long_expand_alloc = sizeof(odsptr->ExpFileName)-1;
odsptr->Naml.naml$l_long_result = odsptr->ResFileName;
odsptr->Naml.naml$l_long_result_alloc = sizeof(odsptr->ResFileName)-1;
odsptr->Naml.naml$l_filesys_name = odsptr->SysFileName;
odsptr->Naml.naml$l_filesys_name_alloc = sizeof(odsptr->SysFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
odsptr->Fab.fab$l_dna = DefaultSpec;
odsptr->Fab.fab$b_dns = DefaultSpecLength;
odsptr->Fab.fab$l_fna = FileSpec;
odsptr->Fab.fab$b_fns = FileSpecLength;
odsptr->Fab.fab$l_nam = &odsptr->Nam;
odsptr->NamlInUse = false;
odsptr->Nam = cc$rms_nam;
odsptr->Nam.nam$l_esa = odsptr->ExpFileName;
odsptr->Nam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
odsptr->Nam.nam$l_rsa = odsptr->ResFileName;
odsptr->Nam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
/* initialize the date, header and protection extended attribute blocks */
odsptr->Fab.fab$l_xab = &odsptr->XabDat;
odsptr->XabDat = cc$rms_xabdat;
odsptr->XabDat.xab$l_nxt = &odsptr->XabFhc;
odsptr->XabFhc = cc$rms_xabfhc;
odsptr->XabFhc.xab$l_nxt = &odsptr->XabPro;
odsptr->XabPro = cc$rms_xabpro;
if (!AstFunction)
{
/* synchronous service */
odsptr->Fab.fab$l_fop &= ~FAB$M_ASY;
status = sys$open (&odsptr->Fab, 0, 0);
OdsNamBlockAst (&odsptr->Fab);
if (VMSok (status)) status = odsptr->Fab.fab$l_sts;
return (status);
}
else
{
/* asynchronous service */
odsptr->Fab.fab$l_fop |= FAB$M_ASY;
status = sys$open (&odsptr->Fab, &OdsNamBlockAst, &OdsNamBlockAst);
return (status);
}
}
/****************************************************************************/
/*
RMS create the supplied file specification (using appropriate standard or long
NAM structure). OdsNamBlockAst() is always called, which sets a number of
pointers and other data from the NAM block so that calling functions do not
need to know which was used. If 'FabPtr' is supplied this function attempts to
clove the file attributes of the pointed to FAB.
*/
int OdsCreate
(
ODS_STRUCT *odsptr,
char *FileSpec,
int FileSpecLength,
char *DefaultSpec,
int DefaultSpecLength,
int FabFac,
int FabFop,
int FabShr,
int FabRfm,
int FabRat,
struct FAB *FabPtr,
GENERAL_AST AstFunction,
unsigned long AstParam
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsCreate() !&B !AZ !AZ !&A(!&X)",
OdsExtended,
FileSpecLength == -1 ?
STR_DSC_PTR((STR_DSC*)FileSpec) : FileSpec,
DefaultSpecLength == -1 ?
STR_DSC_PTR((STR_DSC*)DefaultSpec) : DefaultSpec,
AstFunction, AstParam);
OdsStructInit (odsptr, true);
odsptr->AstFunction = AstFunction;
odsptr->AstParam = AstParam;
if (FabFop & FAB$M_DLT)
odsptr->DeleteOnClose = true;
else
odsptr->DeleteOnClose = false;
if (FileSpecLength == -1)
{
/* use the WASD descriptor */
FileSpecLength = STR_DSC_LEN((STR_DSC*)FileSpec);
FileSpec = STR_DSC_PTR((STR_DSC*)FileSpec);
}
else
if (!FileSpecLength && FileSpec)
FileSpecLength = strlen(FileSpec);
if (DefaultSpecLength == -1)
{
/* use the WASD descriptor */
DefaultSpecLength = STR_DSC_LEN((STR_DSC*)DefaultSpec);
DefaultSpec = STR_DSC_PTR((STR_DSC*)DefaultSpec);
}
else
if (!DefaultSpecLength && DefaultSpec)
DefaultSpecLength = strlen(DefaultSpec);
odsptr->Fab = cc$rms_fab;
if (FabPtr)
{
/* 'clone' from supplied FAB */
odsptr->Fab.fab$l_alq = FabPtr->fab$l_alq;
odsptr->Fab.fab$w_deq = FabPtr->fab$w_deq;
odsptr->Fab.fab$b_bks = FabPtr->fab$b_bks;
odsptr->Fab.fab$b_fac = FabPtr->fab$b_fac;
odsptr->Fab.fab$l_fop = FabPtr->fab$l_fop;
odsptr->Fab.fab$b_fsz = FabPtr->fab$b_fsz;
odsptr->Fab.fab$w_gbc = FabPtr->fab$w_gbc;
odsptr->Fab.fab$l_mrn = FabPtr->fab$l_mrn;
odsptr->Fab.fab$w_mrs = FabPtr->fab$w_mrs;
odsptr->Fab.fab$b_org = FabPtr->fab$b_org;
odsptr->Fab.fab$b_rat = FabPtr->fab$b_rat;
odsptr->Fab.fab$b_rfm = FabPtr->fab$b_rfm;
odsptr->Fab.fab$b_shr = FabPtr->fab$b_shr;
}
if (FabFac) odsptr->Fab.fab$b_fac = FabFac;
if (FabFop) odsptr->Fab.fab$l_fop = FabFop;
if (FabShr) odsptr->Fab.fab$b_shr = FabShr;
if (FabRfm) odsptr->Fab.fab$b_rfm = FabRfm;
if (FabRat) odsptr->Fab.fab$b_rat = FabRat;
odsptr->Fab.fab$l_ctx = odsptr;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
odsptr->Fab.fab$l_fna = -1;
odsptr->Fab.fab$b_fns = 0;
odsptr->Fab.fab$l_nam = &odsptr->Naml;
odsptr->NamlInUse = true;
ENAMEL_RMS_NAML(odsptr->Naml)
odsptr->Naml.naml$l_long_defname = DefaultSpec;
odsptr->Naml.naml$l_long_defname_size = DefaultSpecLength;
odsptr->Naml.naml$l_long_filename = FileSpec;
odsptr->Naml.naml$l_long_filename_size = FileSpecLength;
odsptr->Naml.naml$l_long_expand = odsptr->ExpFileName;
odsptr->Naml.naml$l_long_expand_alloc = sizeof(odsptr->ExpFileName)-1;
odsptr->Naml.naml$l_long_result = odsptr->ResFileName;
odsptr->Naml.naml$l_long_result_alloc = sizeof(odsptr->ResFileName)-1;
odsptr->Naml.naml$l_filesys_name = odsptr->SysFileName;
odsptr->Naml.naml$l_filesys_name_alloc = sizeof(odsptr->SysFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
odsptr->Fab.fab$l_dna = DefaultSpec;
odsptr->Fab.fab$b_dns = DefaultSpecLength;
odsptr->Fab.fab$l_fna = FileSpec;
odsptr->Fab.fab$b_fns = FileSpecLength;
odsptr->Fab.fab$l_nam = &odsptr->Nam;
odsptr->NamlInUse = false;
odsptr->Nam = cc$rms_nam;
odsptr->Nam.nam$l_esa = odsptr->ExpFileName;
odsptr->Nam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
odsptr->Nam.nam$l_rsa = odsptr->ResFileName;
odsptr->Nam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
/* initialize the date, header and protection extended attribute blocks */
odsptr->Fab.fab$l_xab = &odsptr->XabDat;
odsptr->XabDat = cc$rms_xabdat;
odsptr->XabDat.xab$l_nxt = &odsptr->XabFhc;
odsptr->XabFhc = cc$rms_xabfhc;
odsptr->XabFhc.xab$l_nxt = &odsptr->XabPro;
odsptr->XabPro = cc$rms_xabpro;
if (!AstFunction)
{
/* synchronous service */
odsptr->Fab.fab$l_fop &= ~FAB$M_ASY;
status = sys$create (&odsptr->Fab, 0, 0);
OdsNamBlockAst (&odsptr->Fab);
if (VMSok (status)) status = odsptr->Fab.fab$l_sts;
return (status);
}
else
{
/* asynchronous service */
odsptr->Fab.fab$l_fop |= FAB$M_ASY;
status = sys$create (&odsptr->Fab, &OdsNamBlockAst, &OdsNamBlockAst);
return (status);
}
}
/****************************************************************************/
/*
Close the currently open file (with delete if required). If an AST function is
supplied this is called regardless.
*/
int OdsClose
(
ODS_STRUCT *odsptr,
REQUEST_AST AstFunction,
unsigned long AstParam
)
{
int status;
unsigned long PrvPrv [2];
FAB_AST FabAstFunction;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsClose() !&B !&A(!&X)",
odsptr->DeleteOnClose ||
odsptr->Fab.fab$l_fop & FAB$M_DLT,
AstFunction, AstParam);
odsptr->Fab.fab$l_ctx = AstParam;
if (odsptr->DeleteOnClose ||
odsptr->Fab.fab$l_fop & FAB$M_DLT)
{
odsptr->Fab.fab$l_fop |= FAB$M_DLT;
/* use SYSPRV to ensure deletion-on-close of file */
sys$setprv (1, &SysPrvMask, 0, &PrvPrv);
}
else
if (odsptr->Fab.fab$l_fop & FAB$M_TEF)
{
/* use SYSPRV to ensure file truncate */
sys$setprv (1, &SysPrvMask, 0, &PrvPrv);
}
if (AstFunction)
odsptr->Fab.fab$l_fop |= FAB$M_ASY;
else
odsptr->Fab.fab$l_fop &= ~FAB$M_ASY;
status = sys$close (&odsptr->Fab, AstFunction, AstFunction);
if (odsptr->Fab.fab$l_fop & FAB$M_DLT ||
odsptr->Fab.fab$l_fop & FAB$M_TEF)
if (!(PrvPrv[0] & PRV$M_SYSPRV))
sys$setprv (0, &SysPrvMask, 0, 0);
return (status);
}
/****************************************************************************/
/*
RMS parse the supplied file specification into an appropriate standard or long
NAM structure. OdsNamBlockAst() is always called, which sets a number of
pointers and other data from the NAM block so that calling functions do not
need to know which was used.
*/
int OdsParse
(
ODS_STRUCT *odsptr,
char *FileSpec,
int FileSpecLength,
char *DefaultSpec,
int DefaultSpecLength,
int NamNop,
GENERAL_AST AstFunction,
unsigned long AstParam
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsParse() !&B !&Z !&Z !&A(!&X)",
OdsExtended, FileSpec, DefaultSpec, AstFunction, AstParam);
/* ensure for successive parses any previous resources are released */
OdsParseRelease (odsptr);
OdsStructInit (odsptr, true);
odsptr->AstFunction = AstFunction;
odsptr->AstParam = AstParam;
/* a pattern allows for less frequent false releases on uninited structs */
odsptr->ParseInUse = ODS_PARSE_IN_USE_PATTERN;
if (!FileSpecLength && FileSpec)
FileSpecLength = strlen(FileSpec);
if (!DefaultSpecLength && DefaultSpec)
DefaultSpecLength = strlen(DefaultSpec);
odsptr->Fab = cc$rms_fab;
odsptr->Fab.fab$l_ctx = odsptr;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
odsptr->Fab.fab$l_fna = odsptr->Fab.fab$l_dna = -1;
odsptr->Fab.fab$b_fns = odsptr->Fab.fab$b_dns = 0;
odsptr->Fab.fab$l_nam = &odsptr->Naml;
odsptr->NamlInUse = true;
ENAMEL_RMS_NAML(odsptr->Naml)
odsptr->Naml.naml$l_long_filename = FileSpec;
odsptr->Naml.naml$l_long_filename_size = FileSpecLength;
odsptr->Naml.naml$l_long_defname = DefaultSpec;
odsptr->Naml.naml$l_long_defname_size = DefaultSpecLength;
odsptr->Naml.naml$l_long_expand = odsptr->ExpFileName;
odsptr->Naml.naml$l_long_expand_alloc = sizeof(odsptr->ExpFileName)-1;
odsptr->Naml.naml$l_filesys_name = odsptr->SysFileName;
odsptr->Naml.naml$l_filesys_name_alloc = sizeof(odsptr->SysFileName)-1;
odsptr->Naml.naml$b_nop = NamNop;
}
else
#endif /* ODS_EXTENDED */
{
odsptr->Fab.fab$l_fna = FileSpec;
odsptr->Fab.fab$b_fns = FileSpecLength;
odsptr->Fab.fab$l_dna = DefaultSpec;
odsptr->Fab.fab$b_dns = DefaultSpecLength;
odsptr->Fab.fab$l_nam = &odsptr->Nam;
odsptr->NamlInUse = false;
odsptr->Nam = cc$rms_nam;
odsptr->Nam.nam$l_esa = odsptr->ExpFileName;
odsptr->Nam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
odsptr->Nam.nam$b_nop = NamNop;
}
if (!AstFunction)
{
/* synchronous service */
odsptr->Fab.fab$l_fop &= ~FAB$M_ASY;
status = sys$parse (&odsptr->Fab, 0, 0);
OdsNamBlockAst (&odsptr->Fab);
if (VMSok (status)) status = odsptr->Fab.fab$l_sts;
return (status);
}
else
{
/* asynchronous service */
odsptr->Fab.fab$l_fop |= FAB$M_ASY;
status = sys$parse (&odsptr->Fab, &OdsNamBlockAst, &OdsNamBlockAst);
return (status);
}
}
/****************************************************************************/
/*
Do an RMS sys$search(). OdsNamBlockAst() is always called to set up generic
pointers and other data of the various components of interest regardless of
whether a standard or long NAM structure is in use.
*** THIS FUNCTION IS (NO LONGER) SIGNIFICANTLY BROKEN ***
It does not use the 'AstParam' parameter as was intended. It always delivers
with a pointer to FAB. It should be fixed one day. (MGD 05-DEC-2000)
FIXED 25-MAY-2007!!
*/
int OdsSearch
(
ODS_STRUCT *odsptr,
GENERAL_AST AstFunction,
unsigned long AstParam
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsSearch() !&B !AZ !&A(!&X)",
OdsExtended, odsptr->ExpFileName, AstFunction, AstParam);
odsptr->AstFunction = AstFunction;
odsptr->AstParam = AstParam;
odsptr->Fab.fab$l_ctx = odsptr;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
odsptr->Naml.naml$l_long_result = odsptr->ResFileName;
odsptr->Naml.naml$l_long_result_alloc = sizeof(odsptr->ResFileName)-1;
odsptr->Naml.naml$l_filesys_name = odsptr->SysFileName;
odsptr->Naml.naml$l_filesys_name_alloc = sizeof(odsptr->SysFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
odsptr->Nam.nam$l_rsa = odsptr->ResFileName;
odsptr->Nam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
if (!AstFunction)
{
/* synchronous service */
odsptr->Fab.fab$l_fop &= ~FAB$M_ASY;
#if ODS_DIRECT
if (OdsDirect && !odsptr->DirectRetry)
{
status = OdsDirectSearch (odsptr);
if (status == SS$_RETRY)
{
/* status to indicate the directory parser declines the call */
status = sys$search (&odsptr->Fab, 0, 0);
OdsNamBlockAst (&odsptr->Fab);
if (VMSok (status)) status = odsptr->Fab.fab$l_sts;
}
}
else
#endif /* ODS_DIRECT */
{
status = sys$search (&odsptr->Fab, 0, 0);
OdsNamBlockAst (&odsptr->Fab);
if (VMSok (status)) status = odsptr->Fab.fab$l_sts;
}
return (status);
}
else
{
/* asynchronous service */
odsptr->Fab.fab$l_fop |= FAB$M_ASY;
#if ODS_DIRECT
if (OdsDirect && !odsptr->DirectRetry)
{
status = OdsDirectSearch (odsptr);
if (status == SS$_RETRY)
status = sys$search (&odsptr->Fab, &OdsNamBlockAst,
&OdsNamBlockAst);
}
else
#endif /* ODS_DIRECT */
status = sys$search (&odsptr->Fab, &OdsNamBlockAst, &OdsNamBlockAst);
return (status);
}
}
/****************************************************************************/
/*
Performs the same functionality as OdsSearch() but using the NOCONCEAL option.
This results in a concealed device/search list being resolved into actual file
name in the result file name storage, but leave the expanded file untouched.
OdsNamBlockAst() detects the absence of expanded file name storage and adjusts
behaviour for terminating the result file name only.
*/
int OdsSearchNoConceal
(
ODS_STRUCT *odsptr,
GENERAL_AST AstFunction,
unsigned long AstParam
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsSearchNoConceal() !&B !AZ !&A(!&X)",
OdsExtended, odsptr->ExpFileName, AstFunction, AstParam);
odsptr->AstFunction = AstFunction;
odsptr->AstParam = AstParam;
odsptr->Fab.fab$l_ctx = odsptr;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
odsptr->Naml.naml$b_nop |= NAM$M_NOCONCEAL;
odsptr->Naml.naml$l_long_result = odsptr->ResFileName;
odsptr->Naml.naml$l_long_result_alloc = sizeof(odsptr->ResFileName)-1;
odsptr->Naml.naml$l_filesys_name = odsptr->SysFileName;
odsptr->Naml.naml$l_filesys_name_alloc = sizeof(odsptr->SysFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
odsptr->Nam.nam$b_nop |= NAM$M_NOCONCEAL;
odsptr->Nam.nam$l_rsa = odsptr->ResFileName;
odsptr->Nam.nam$b_rss = ODS2_MAX_FILE_NAME_LENGTH;
}
if (!AstFunction)
{
/* synchronous service */
odsptr->Fab.fab$l_fop &= ~FAB$M_ASY;
#if ODS_DIRECT
if (OdsDirect && !odsptr->DirectRetry)
{
status = OdsDirectSearch (odsptr);
if (status == SS$_RETRY)
{
/* status to indicate the directory parser declines the call */
status = sys$search (&odsptr->Fab, 0, 0);
OdsNamBlockAst (&odsptr->Fab);
if (VMSok (status)) status = odsptr->Fab.fab$l_sts;
}
}
else
#endif /* ODS_DIRECT */
{
status = sys$search (&odsptr->Fab, 0, 0);
OdsNamBlockAst (&odsptr->Fab);
if (VMSok (status)) status = odsptr->Fab.fab$l_sts;
}
return (status);
}
else
{
/* asynchronous service */
odsptr->Fab.fab$l_fop |= FAB$M_ASY;
#if ODS_DIRECT
if (OdsDirect && !odsptr->DirectRetry)
{
status = OdsDirectSearch (odsptr);
if (status == SS$_RETRY)
status = sys$search (&odsptr->Fab, &OdsNamBlockAst,
&OdsNamBlockAst);
}
else
#endif /* ODS_DIRECT */
status = sys$search (&odsptr->Fab, &OdsNamBlockAst, &OdsNamBlockAst);
return (status);
}
}
/****************************************************************************/
/*
Open/Parse/Search is complete. If successful set the generic pointers to the
various NAM components of interest. If an AST has been provided declare that
(can be called as an AST or directly).
*/
void OdsNamBlockAst (struct FAB *FabPtr)
{
int status;
FAB_AST AstFunction;
ODS_STRUCT *odsptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsNamBlockAst() !&F !&B !&S",
&OdsNamBlockAst, OdsExtended, FabPtr->fab$l_sts);
odsptr = (ODS_STRUCT*)FabPtr->fab$l_ctx;
FabPtr->fab$l_ctx = odsptr->AstParam;
if (VMSok (FabPtr->fab$l_sts) ||
FabPtr->fab$l_sts == RMS$_FNF ||
FabPtr->fab$l_sts == RMS$_DNF ||
FabPtr->fab$l_sts == RMS$_DEV)
{
/* file name has been parsed under these status */
#ifdef ODS_EXTENDED
if (OdsExtended)
{
if (odsptr->Naml.naml$l_filesys_name &&
odsptr->Naml.naml$l_filesys_name != odsptr->SysFileName)
ErrorNoticed (NULL, FabPtr->fab$l_sts,
"naml$l_filesys_name", FI_LI);
odsptr->NamNodePtr = odsptr->Naml.naml$l_long_node;
odsptr->NamNodeLength = odsptr->Naml.naml$l_long_node_size;
odsptr->NamDevicePtr = odsptr->Naml.naml$l_long_dev;
odsptr->NamDeviceLength = odsptr->Naml.naml$l_long_dev_size;
odsptr->NamDirectoryPtr = odsptr->Naml.naml$l_long_dir;
odsptr->NamDirectoryLength = odsptr->Naml.naml$l_long_dir_size;
odsptr->NamNamePtr = odsptr->Naml.naml$l_long_name;
odsptr->NamNameLength = odsptr->Naml.naml$l_long_name_size;
odsptr->NamTypePtr = odsptr->Naml.naml$l_long_type;
odsptr->NamTypeLength = odsptr->Naml.naml$l_long_type_size;
odsptr->NamVersionPtr = odsptr->Naml.naml$l_long_ver;
odsptr->NamVersionLength = odsptr->Naml.naml$l_long_ver_size;
odsptr->ExpFileNameLength = odsptr->Naml.naml$l_long_expand_size;
odsptr->ResFileNameLength = odsptr->Naml.naml$l_long_result_size;
odsptr->Nam_fnb = odsptr->Naml.naml$l_fnb;
odsptr->NamFileSysNamePtr = odsptr->SysFileName;
odsptr->NamFileSysNameLength = odsptr->Naml.naml$l_filesys_name_size;
odsptr->NamFileSysNamePtr[odsptr->NamFileSysNameLength] = '\0';
odsptr->ExpFileName[odsptr->ExpFileNameLength] = '\0';
odsptr->ResFileName[odsptr->ResFileNameLength] = '\0';
}
else
#endif /* ODS_EXTENDED */
{
odsptr->NamNodePtr = odsptr->Nam.nam$l_node;
odsptr->NamNodeLength = odsptr->Nam.nam$b_node;
odsptr->NamDevicePtr = odsptr->Nam.nam$l_dev;
odsptr->NamDeviceLength = odsptr->Nam.nam$b_dev;
odsptr->NamDirectoryPtr = odsptr->Nam.nam$l_dir;
odsptr->NamDirectoryLength = odsptr->Nam.nam$b_dir;
odsptr->NamNamePtr = odsptr->Nam.nam$l_name;
odsptr->NamNameLength = odsptr->Nam.nam$b_name;
odsptr->NamTypePtr = odsptr->Nam.nam$l_type;
odsptr->NamTypeLength = odsptr->Nam.nam$b_type;
odsptr->NamVersionPtr = odsptr->Nam.nam$l_ver;
odsptr->NamVersionLength = odsptr->Nam.nam$b_ver;
odsptr->ExpFileNameLength = odsptr->Nam.nam$b_esl;
odsptr->ResFileNameLength = odsptr->Nam.nam$b_rsl;
odsptr->Nam_fnb = odsptr->Nam.nam$l_fnb;
odsptr->NamFileSysNamePtr = odsptr->SysFileName;
odsptr->NamFileSysNameLength = odsptr->Nam.nam$b_name +
odsptr->Nam.nam$b_type +
odsptr->Nam.nam$b_ver;
memcpy (odsptr->NamFileSysNamePtr,
odsptr->Nam.nam$l_name,
odsptr->NamFileSysNameLength);
odsptr->NamFileSysNamePtr[odsptr->NamFileSysNameLength] = '\0';
odsptr->ExpFileName[odsptr->ExpFileNameLength] = '\0';
odsptr->ResFileName[odsptr->ResFileNameLength] = '\0';
}
}
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"!&Z !&Z !&Z", odsptr->ExpFileName,
odsptr->ResFileName, odsptr->NamFileSysNamePtr);
if (!odsptr->AstFunction) return;
AstFunction = odsptr->AstFunction;
odsptr->AstFunction = NULL;
(AstFunction)(odsptr->AstParam);
}
/****************************************************************************/
/*
Ensure parse internal data structures are released.
*/
OdsParseRelease (ODS_STRUCT *odsptr)
{
int status;
char ExpFileName [16];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsParseRelease() !&B !8XL",
OdsExtended, odsptr->ParseInUse);
if (odsptr->ParseInUse != ODS_PARSE_IN_USE_PATTERN) return;
odsptr->ParseInUse = 0;
/* synchronous service */
odsptr->Fab.fab$l_fop &= ~FAB$M_ASY;
odsptr->Fab.fab$l_fna = "a:[b]c.d;";
odsptr->Fab.fab$b_fns = 9;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
odsptr->Naml.naml$l_long_defname_size = 0;
odsptr->Naml.naml$b_nop = NAM$M_SYNCHK;
}
else
#endif /* ODS_EXTENDED */
{
odsptr->Fab.fab$b_dns = 0;
odsptr->Nam.nam$b_nop = NAM$M_SYNCHK;
}
status = sys$parse (&odsptr->Fab, 0, 0);
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "!&S", status);
#if ODS_DIRECT
/* release any directory file (global) memory */
if (odsptr->DataPtr)
{
if (WATCH_CATEGORY(WATCH_INTERNAL))
WatchThis (WATCHALL, WATCH_INTERNAL, "DIRECTory called:!UL",
odsptr->DirectCallCount);
VmFree (odsptr->DataPtr, FI_LI);
odsptr->DataPtr = NULL;
odsptr->DataLength = 0;
}
#endif /* ODS_DIRECT */
}
/****************************************************************************/
/*
Place a terminating null in the 'ExpFileName' appropriate to whether it is a
directory specific, file specification without version, or with version, and
adjust '...Length's as necessary. This function can only be used after parse
using OdsParse() or open using OdsOpen().
*/
int OdsParseTerminate (ODS_STRUCT *odsptr)
{
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsParseTerminate() !&B !&Z !&Z",
OdsExtended, odsptr->ExpFileName, odsptr->NamFileSysNamePtr);
if (!(odsptr->ExpFileNameLength || odsptr->ResFileNameLength))
return (SS$_ABORT);
if (odsptr->NamNamePtr == odsptr->NamTypePtr &&
odsptr->NamTypeLength <= 1)
{
/* no name, no type; a directory specification (with possible version) */
if (odsptr->Nam_fnb & NAM$M_EXP_VER ||
odsptr->Nam_fnb & NAM$M_WILD_VER)
{
/* with version, remove that annoying single period */
sptr = (cptr = odsptr->NamNamePtr) + 1;
while (*sptr) *cptr++ = *sptr++;
*cptr = '\0';
odsptr->NamVersionPtr = odsptr->NamNamePtr;
odsptr->NamTypeLength = 0;
if (odsptr->NamFileSysNameLength)
{
sptr = (cptr = odsptr->NamFileSysNamePtr) + 1;
while (*sptr) *cptr++ = *sptr++;
*cptr = '\0';
odsptr->NamFileSysNameLength--;
}
}
else
{
/* just lop it off at the directory terminator */
odsptr->NamNamePtr[0] = '\0';
odsptr->NamFileSysNamePtr = "";
odsptr->NamTypeLength = odsptr->NamVersionLength =
odsptr->NamFileSysNameLength = 0;
}
}
else
if (odsptr->NamTypeLength <= 1)
{
/* name but no type (with possible version) */
if (odsptr->Nam_fnb & NAM$M_EXP_VER ||
odsptr->Nam_fnb & NAM$M_WILD_VER)
{
/* remove that annoying single period */
sptr = (cptr = odsptr->NamTypePtr) + 1;
while (*sptr) *cptr++ = *sptr++;
*cptr = '\0';
odsptr->NamVersionPtr = odsptr->NamTypePtr;
odsptr->NamTypeLength = 0;
if (odsptr->NamFileSysNameLength)
{
cptr = odsptr->NamFileSysNamePtr + odsptr->NamFileSysNameLength;
while (cptr > odsptr->NamFileSysNamePtr &&
*cptr != '.' && !SAME2(cptr,'^.')) cptr--;
if (*cptr == '.')
{
sptr = cptr + 1;
while (*sptr) *cptr++ = *sptr++;
*cptr = '\0';
odsptr->NamFileSysNameLength = cptr - odsptr->NamFileSysNamePtr;
}
}
}
else
{
if (!(odsptr->Nam_fnb & NAM$M_EXP_TYPE ||
odsptr->Nam_fnb & NAM$M_WILD_TYPE))
{
/* no type and no version supplied */
(odsptr->NamVersionPtr = odsptr->NamTypePtr)[0] = '\0';
odsptr->NamTypeLength = odsptr->NamVersionLength = 0;
}
else
{
/* type is a period only! */
odsptr->NamVersionPtr[0] = '\0';
odsptr->NamVersionLength = 0;
}
if (odsptr->NamFileSysNameLength)
{
cptr = odsptr->NamFileSysNamePtr + odsptr->NamFileSysNameLength;
while (cptr > odsptr->NamFileSysNamePtr &&
*cptr != '.' && !SAME2(cptr-1,'^.')) cptr--;
if (*cptr == '.')
{
*cptr = '\0';
odsptr->NamFileSysNameLength = cptr - odsptr->NamFileSysNamePtr;
}
}
}
}
else
if (odsptr->Nam_fnb & NAM$M_EXP_VER ||
odsptr->Nam_fnb & NAM$M_WILD_VER)
{
/* a type and a version supplied */
odsptr->NamVersionPtr[odsptr->NamVersionLength] = '\0';
}
else
{
/* a type but no version supplied */
odsptr->NamVersionPtr[0] = '\0';
odsptr->NamVersionLength = 0;
if (odsptr->NamFileSysNameLength)
{
cptr = odsptr->NamFileSysNamePtr + odsptr->NamFileSysNameLength;
while (cptr > odsptr->NamFileSysNamePtr &&
*cptr != ';' && !SAME2(cptr-1,'^;')) cptr--;
if (*cptr == ';')
{
*cptr = '\0';
odsptr->NamFileSysNameLength = cptr - odsptr->NamFileSysNamePtr;
}
}
}
if (odsptr->ResFileNameLength)
odsptr->ResFileNameLength = odsptr->NamVersionPtr -
odsptr->ResFileName;
else
odsptr->ExpFileNameLength = odsptr->NamVersionPtr -
odsptr->ExpFileName;
#ifndef ODS_EXTENDED
/*
06-JUN-2013 MGD VAX VMS V7.3 seems to require this (these)
adjusted or it generates RMS$_ESL errors (!?)
*/
if (odsptr->ResFileNameLength)
odsptr->Nam.nam$b_rsl = odsptr->ResFileNameLength;
else
odsptr->Nam.nam$b_esl = odsptr->ExpFileNameLength;
#endif
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"!&Z !&Z", odsptr->ExpFileName, odsptr->NamFileSysNamePtr);
return (SS$_NORMAL);
}
/****************************************************************************/
/*
Using the information in the ODS structure NAM field queue an ACP I/O to
retrieve file information. Of course, this function can only be used after
parse using OdsParse(). For simplicity retrieves all information of interest
to all users of the function regardless of whether an individual user is
interested in all information! Any AST routine *MUST* deassign the channel
after use and before continuing.
This function uses the ACP-QIO interface detailed in the "OpenVMS I/O User's
Reference Manual", and is probably as fast as we can get for this type of file
system functionality!
*/
int OdsFileAcpInfo
(
ODS_STRUCT *odsptr,
GENERAL_AST AstFunction,
unsigned long AstParam
)
{
static $DESCRIPTOR (DeviceDsc, "");
int status;
FILE_QIO *fqptr;
ATRDEF *atptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsFileAcpInfo() !&B !&Z !&A(!&X)",
OdsExtended, odsptr->NamDevicePtr, AstFunction, AstParam);
fqptr = &odsptr->FileQio;
/* assign a channel to the disk device containing the file */
DeviceDsc.dsc$a_pointer = odsptr->NamDevicePtr;
DeviceDsc.dsc$w_length = odsptr->NamDeviceLength;
status = sys$assign (&DeviceDsc, &fqptr->AcpChannel, 0, 0, 0);
if (VMSnok (status))
{
fqptr->IOsb.Status = status;
if (!AstFunction) return (status);
SysDclAst (AstFunction, AstParam);
return (status);
}
/* set up the File Information Block for the ACP interface */
fqptr->FibDsc.dsc$w_length = sizeof(fqptr->Fib);
fqptr->FibDsc.dsc$a_pointer = &fqptr->Fib;
memset (&fqptr->Fib, 0, sizeof(fqptr->Fib));
fqptr->FileNameDsc.dsc$a_pointer = odsptr->NamFileSysNamePtr;
fqptr->FileNameDsc.dsc$w_length = odsptr->NamFileSysNameLength;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
memcpy (&fqptr->Fib.fib$w_did, &odsptr->Naml.naml$w_did, 6);
fqptr->Fib.fib$b_name_format_in = FIB$C_ISO_LATIN;
fqptr->Fib.fib$b_name_format_out = FIB$C_ISO_LATIN;
fqptr->Fib.fib$w_nmctl = FIB$M_NAMES_8BIT;
}
else
#endif /* ODS_EXTENDED */
memcpy (&fqptr->Fib.fib$w_did, &odsptr->Nam.nam$w_did, 6);
atptr = &fqptr->FileAtr;
atptr->atr$w_size = sizeof(fqptr->CdtTime64);
atptr->atr$w_type = ATR$C_CREDATE;
atptr->atr$l_addr = &fqptr->CdtTime64;
atptr++;
atptr->atr$w_size = sizeof(fqptr->RdtTime64);
atptr->atr$w_type = ATR$C_REVDATE;
atptr->atr$l_addr = &fqptr->RdtTime64;
atptr++;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
atptr->atr$w_size = sizeof(fqptr->ModTime64);
atptr->atr$w_type = ATR$C_MODDATE;
atptr->atr$l_addr = &fqptr->ModTime64;
atptr++;
}
#endif /* ODS_EXTENDED */
atptr->atr$w_size = sizeof(fqptr->AtrUic);
atptr->atr$w_type = ATR$C_UIC;
atptr->atr$l_addr = &fqptr->AtrUic;
atptr++;
atptr->atr$w_size = sizeof(fqptr->AtrUchar);
atptr->atr$w_type = ATR$C_UCHAR;
atptr->atr$l_addr = &fqptr->AtrUchar;
atptr++;
atptr->atr$w_size = sizeof(fqptr->AtrFpro);
atptr->atr$w_type = ATR$C_FPRO;
atptr->atr$l_addr = &fqptr->AtrFpro;
atptr++;
atptr->atr$w_size = sizeof(fqptr->RecAttr);
atptr->atr$w_type = ATR$C_RECATTR;
atptr->atr$l_addr = &fqptr->RecAttr;
atptr++;
atptr->atr$w_size = atptr->atr$w_type = atptr->atr$l_addr = 0;
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"!#AZ did:!UL,!UL,!UL {!UL}!-!#AZ",
DeviceDsc.dsc$w_length, DeviceDsc.dsc$a_pointer,
fqptr->Fib.fib$w_did[0],
fqptr->Fib.fib$w_did[1],
fqptr->Fib.fib$w_did[2],
fqptr->FileNameDsc.dsc$w_length,
fqptr->FileNameDsc.dsc$a_pointer);
if (!AstFunction)
{
status = sys$qiow (EfnWait, fqptr->AcpChannel, IO$_ACCESS,
&fqptr->IOsb, 0, 0,
&fqptr->FibDsc,
&fqptr->FileNameDsc, 0, 0,
&fqptr->FileAtr, 0);
sys$dassgn (fqptr->AcpChannel);
fqptr->AcpChannel = 0;
if (VMSok (status)) status = fqptr->IOsb.Status;
if (OdsUseModDate) OdsFileAcpInfoRdt (odsptr);
}
else
if (OdsUseModDate)
{
odsptr->AstFunction = AstFunction;
odsptr->AstParam = AstParam;
status = sys$qio (EfnNoWait, fqptr->AcpChannel, IO$_ACCESS,
&fqptr->IOsb, OdsFileAcpInfoRdt, odsptr,
&fqptr->FibDsc,
&fqptr->FileNameDsc, 0, 0,
&fqptr->FileAtr, 0);
if (VMSnok (status))
{
fqptr->IOsb.Status = status;
if (odsptr->AstFunction)
{
SysDclAst (odsptr->AstFunction, odsptr->AstParam);
odsptr->AstFunction = odsptr->AstParam = NULL;
}
}
}
else
{
status = sys$qio (EfnNoWait, fqptr->AcpChannel, IO$_ACCESS,
&fqptr->IOsb, AstFunction, AstParam,
&fqptr->FibDsc,
&fqptr->FileNameDsc, 0, 0,
&fqptr->FileAtr, 0);
if (VMSnok (status))
{
fqptr->IOsb.Status = status;
if (AstFunction) SysDclAst (AstFunction, AstParam);
}
}
return (status);
}
/****************************************************************************/
/*
Called by OdsFileAcpInfo() directly or as an AST to move the ATR$C_MODDATE onto
the ATR$C_REVDATE.
*/
void OdsFileAcpInfoRdt (ODS_STRUCT *odsptr)
{
FILE_QIO *fqptr;
/*********/
/* begin */
/*********/
fqptr = &odsptr->FileQio;
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsFileAcpInfoRdt() mod:!%D rdt:!%D",
&fqptr->ModTime64, &fqptr->RdtTime64);
if (fqptr->ModTime64) fqptr->RdtTime64 = fqptr->ModTime64;
if (odsptr->AstFunction)
{
SysDclAst (odsptr->AstFunction, odsptr->AstParam);
odsptr->AstFunction = odsptr->AstParam = NULL;
}
}
/****************************************************************************/
/*
Using the information in the ODS structure NAM field queue an ACP I/O to modify
selected file information. This function can only be used after parse using
OdsParse(). Any AST *MUST* deassign the channel after use and before
continuing.
This function uses the ACP-QIO interface detailed in the "OpenVMS I/O User's
Reference Manual", and is probably as fast as we can get for this type of file
system functionality!
*/
int OdsFileAcpModify
(
ODS_STRUCT *odsptr,
unsigned short *ProtectionMaskPtr,
unsigned short *VersionLimitPtr,
GENERAL_AST AstFunction,
unsigned long AstParam
)
{
static $DESCRIPTOR (DeviceDsc, "");
int status;
FILE_QIO *fqptr;
ATRDEF *atptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsFileAcpModify() !&B !&X:!4XL !&X:!UL !&A(!&X)",
OdsExtended, ProtectionMaskPtr,
!ProtectionMaskPtr ? 0 : *ProtectionMaskPtr,
VersionLimitPtr,
!VersionLimitPtr ? 0 : *VersionLimitPtr,
AstFunction, AstParam);
fqptr = &odsptr->FileQio;
/* assign a channel to the disk device containing the file */
DeviceDsc.dsc$a_pointer = odsptr->NamDevicePtr;
DeviceDsc.dsc$w_length = odsptr->NamDeviceLength;
status = sys$assign (&DeviceDsc, &fqptr->AcpChannel, 0, 0, 0);
if (VMSnok (status))
{
fqptr->IOsb.Status = status;
if (!AstFunction) return (status);
SysDclAst (AstFunction, AstParam);
return (status);
}
/* set up the File Information Block for the ACP interface */
fqptr->FibDsc.dsc$w_length = sizeof(fqptr->Fib);
fqptr->FibDsc.dsc$a_pointer = &fqptr->Fib;
memset (&fqptr->Fib, 0, sizeof(fqptr->Fib));
#ifdef ODS_EXTENDED
if (OdsExtended)
{
fqptr->FileNameDsc.dsc$a_pointer = odsptr->Naml.naml$l_filesys_name;
fqptr->FileNameDsc.dsc$w_length = odsptr->Naml.naml$l_filesys_name_size;
memcpy (&fqptr->Fib.fib$w_did, &odsptr->Naml.naml$w_did, 6);
fqptr->Fib.fib$b_name_format_in = FIB$C_ISO_LATIN;
fqptr->Fib.fib$b_name_format_out = FIB$C_ISO_LATIN;
fqptr->Fib.fib$w_nmctl = FIB$M_NAMES_8BIT;
}
else
#endif /* ODS_EXTENDED */
{
fqptr->FileNameDsc.dsc$a_pointer = odsptr->NamNamePtr;
fqptr->FileNameDsc.dsc$w_length = odsptr->NamNameLength +
odsptr->NamTypeLength +
odsptr->NamVersionLength;
memcpy (&fqptr->Fib.fib$w_did, &odsptr->Nam.nam$w_did, 6);
}
if (VersionLimitPtr) fqptr->Fib.fib$w_verlimit = *VersionLimitPtr;
atptr = &fqptr->FileAtr;
if (ProtectionMaskPtr)
{
atptr->atr$w_size = sizeof(*ProtectionMaskPtr);
atptr->atr$w_type = ATR$C_FPRO;
atptr->atr$l_addr = ProtectionMaskPtr;
atptr++;
}
atptr->atr$w_size = atptr->atr$w_type = atptr->atr$l_addr = 0;
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"!#AZ did:!UL,!UL,!UL {!UL}!-!#AZ",
DeviceDsc.dsc$w_length, DeviceDsc.dsc$a_pointer,
fqptr->Fib.fib$w_did[0],
fqptr->Fib.fib$w_did[1],
fqptr->Fib.fib$w_did[2],
fqptr->FileNameDsc.dsc$w_length,
fqptr->FileNameDsc.dsc$a_pointer);
if (!AstFunction)
{
status = sys$qiow (EfnWait, fqptr->AcpChannel, IO$_MODIFY,
&fqptr->IOsb, 0, 0,
&fqptr->FibDsc,
&fqptr->FileNameDsc, 0, 0,
&fqptr->FileAtr, 0);
sys$dassgn (fqptr->AcpChannel);
fqptr->AcpChannel = 0;
if (VMSok (status)) status = fqptr->IOsb.Status;
}
else
status = sys$qio (EfnNoWait, fqptr->AcpChannel, IO$_MODIFY,
&fqptr->IOsb, AstFunction, AstParam,
&fqptr->FibDsc,
&fqptr->FileNameDsc, 0, 0,
&fqptr->FileAtr, 0);
if (VMSnok (status))
{
fqptr->IOsb.Status = status;
if (AstFunction) SysDclAst (AstFunction, AstParam);
}
return (status);
}
/*****************************************************************************/
/*
Return success status if the specified file name exists in the specified
directory, error otherwise. This function completes synchronously!
*/
int OdsFileExists
(
char *Directory,
char *FileName
)
{
int status,
DirectoryLength,
FileNameLength;
char ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1];
struct FAB SearchFab;
struct NAM SearchNam;
#ifdef ODS_EXTENDED
struct NAML SearchNaml;
#endif
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsFileExists() !&B !&Z !&Z",
OdsExtended, Directory, FileName);
if (Directory)
DirectoryLength = strlen(Directory);
else
DirectoryLength = 0;
if (FileName)
FileNameLength = strlen(FileName);
else
FileNameLength = 0;
SearchFab = cc$rms_fab;
SearchFab.fab$l_fop = FAB$M_NAM;
/* synchronous service */
SearchFab.fab$l_fop &= ~FAB$M_ASY;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
SearchFab.fab$l_fna = SearchFab.fab$l_dna = -1;
SearchFab.fab$b_fns = SearchFab.fab$b_dns = 0;
SearchFab.fab$l_nam = &SearchNaml;
ENAMEL_RMS_NAML(SearchNaml)
SearchNaml.naml$b_nop = NAM$M_NOCONCEAL;
SearchNaml.naml$l_long_defname = Directory;
SearchNaml.naml$l_long_defname_size = DirectoryLength;
SearchNaml.naml$l_long_filename = FileName;
SearchNaml.naml$l_long_filename_size = FileNameLength;
SearchNaml.naml$l_long_expand = ExpFileName;
SearchNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
}
else
#endif /* ODS_EXTENDED */
{
SearchFab.fab$l_dna = Directory;
SearchFab.fab$b_dns = DirectoryLength;
SearchFab.fab$l_fna = FileName;
SearchFab.fab$b_fns = FileNameLength;
SearchFab.fab$l_nam = &SearchNam;
SearchNam = cc$rms_nam;
SearchNam.nam$b_nop = NAM$M_NOCONCEAL;
SearchNam.nam$l_esa = ExpFileName;
SearchNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
}
status = sys$parse (&SearchFab, 0, 0);
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "sys$parse() !&S", status);
if (VMSok (status))
{
status = sys$search (&SearchFab, 0, 0);
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "sys$search() !&S", status);
if (status == RMS$_DNF) status = RMS$_FNF;
}
/* release parse and search internal data structures */
SearchFab.fab$l_fna = "a:[b]c.d;";
SearchFab.fab$b_fns = 9;
SearchFab.fab$b_dns = 0;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
SearchNaml.naml$l_long_result = 0;
SearchNaml.naml$b_nop = NAM$M_SYNCHK;
}
else
#endif /* ODS_EXTENDED */
{
SearchNam.nam$l_rlf = 0;
SearchNam.nam$b_nop = NAM$M_SYNCHK;
}
sys$parse (&SearchFab, 0, 0);
return (status);
}
/*****************************************************************************/
/*
Given a file or directory specification in 'FileName' generate the file name
of the directory file.
(e.g. "DEVICE:[DIR1]DIR2.DIR" from "DEVICE:[DIR1.DIR2]FILE.EXT",
"DEVICE:[DIR1]DIR2.DIR" from "DEVICE:[DIR1.DIR2]",
and "DEVICE:[000000]DIR1.DIR" from "DEVICE:[DIR1]", etc.)
Attempts to improve the perfomance of this function by storing the previous
file specification processed and the previous directory file name result. If
this file specification directory part is the same as the previous directory
part then just return the previous result!
*/
int OdsNameOfDirectoryFile
(
char *FileName,
int FileNameLength,
char *DirFileNamePtr,
int *DirFileLengthPtr
)
{
static int DirFileNameBufferLength = 0;
static char FileNameBuffer [ODS_MAX_FILE_NAME_LENGTH+1],
DirFileNameBuffer [ODS_MAX_FILE_NAME_LENGTH+1];
int status;
unsigned long Nam_fnb;
unsigned long PrvPrv [2];
char *cptr, *fptr, *sptr, *zptr;
char ExpFileName [ODS_MAX_FILE_NAME_LENGTH+1];
struct FAB ParseFab;
struct NAM ParseNam;
#ifdef ODS_EXTENDED
struct NAML ParseNaml;
#endif
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsNameOfDirectoryFile() !&B !&Z !&Z !&Z",
OdsExtended, FileName, FileNameBuffer, DirFileNameBuffer);
if (!FileNameLength) FileNameLength = strlen(FileName);
/* check if this has the same directory components as the last one */
sptr = FileNameBuffer;
cptr = FileName;
while (*cptr == *sptr &&
(*sptr != ']' || SAME2(sptr-1,'^]')) &&
(*cptr != ']' || SAME2(cptr-1,'^]')))
{
*sptr++;
*cptr++;
}
if (*cptr == ']' && *sptr == ']' && *(sptr-1) != '.' && *(cptr-1) != '.')
{
/* it does! return the result of the last one */
strcpy (DirFileNamePtr, DirFileNameBuffer);
*DirFileLengthPtr = DirFileNameBufferLength;
return (SS$_NORMAL);
}
ParseFab = cc$rms_fab;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
ParseFab.fab$l_fna = -1;
ParseFab.fab$b_fns = 0;
ParseFab.fab$l_nam = &ParseNaml;
ENAMEL_RMS_NAML(ParseNaml)
ParseNaml.naml$l_long_filename = FileName;
ParseNaml.naml$l_long_filename_size = FileNameLength;
ParseNaml.naml$l_long_expand = ExpFileName;
ParseNaml.naml$l_long_expand_alloc = sizeof(ExpFileName)-1;
ParseNaml.naml$b_nop = NAM$M_NOCONCEAL | NAM$M_SYNCHK;
/* use SYSPRV to ensure access to directory */
sys$setprv (1, &SysPrvMask, 0, &PrvPrv);
status = sys$parse (&ParseFab, 0, 0);
if (!(PrvPrv[0] & PRV$M_SYSPRV)) sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSnok (status))
{
DirFileNamePtr[*DirFileLengthPtr = 0] = '\0';
return (status);
}
ParseNaml.naml$l_long_ver[ParseNaml.naml$l_long_ver_size] = '\0';
fptr = ParseNaml.naml$l_long_name - 1;
}
else
#endif /* ODS_EXTENDED */
{
ParseFab.fab$l_fna = FileName;
ParseFab.fab$b_fns = FileNameLength;
ParseFab.fab$l_nam = &ParseNam;
ParseNam = cc$rms_nam;
ParseNam.nam$l_esa = ExpFileName;
ParseNam.nam$b_ess = ODS2_MAX_FILE_NAME_LENGTH;
ParseNam.nam$b_nop = NAM$M_NOCONCEAL | NAM$M_SYNCHK;
/* use SYSPRV to ensure access to directory */
sys$setprv (1, &SysPrvMask, 0, &PrvPrv);
status = sys$parse (&ParseFab, 0, 0);
if (!(PrvPrv[0] & PRV$M_SYSPRV)) sys$setprv (0, &SysPrvMask, 0, 0);
if (VMSnok (status))
{
DirFileNamePtr[*DirFileLengthPtr = 0] = '\0';
return (status);
}
ParseNam.nam$l_ver[ParseNam.nam$b_ver] = '\0';
fptr = ParseNam.nam$l_name - 1;
}
#ifdef ODS_EXTENDED
if (OdsExtended)
Nam_fnb = ParseNaml.naml$l_fnb;
else
#endif /* ODS_EXTENDED */
Nam_fnb = ParseNam.nam$l_fnb;
if (Nam_fnb & NAM$M_SEARCH_LIST)
{
/* search list, look for the actual file/directory */
status = sys$search (&ParseFab, 0, 0);
if (VMSok (status)) status = ParseFab.fab$l_sts;
/* if the directory doesn't actually exist then that's OK too! */
if (status == RMS$_FNF) status = SS$_NORMAL;
if (VMSnok (status))
{
/* release parse and search internal data structures */
ParseFab.fab$l_fna = "a:[b]c.d;";
ParseFab.fab$b_fns = 9;
ParseFab.fab$b_dns = 0;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
ParseNaml.naml$l_long_result = 0;
ParseNaml.naml$b_nop = NAM$M_SYNCHK;
}
else
#endif /* ODS_EXTENDED */
{
ParseNam.nam$l_rlf = 0;
ParseNam.nam$b_nop = NAM$M_SYNCHK;
}
sys$parse (&ParseFab, 0, 0);
return (status);
}
}
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "!&Z", ExpFileName);
while (fptr > ExpFileName)
{
if (*fptr == '[' && !SAME2(fptr-1,'^[')) break;
if (*fptr == '.' && !SAME2(fptr-1,'^.')) break;
fptr--;
}
if (fptr > ExpFileName && fptr[-1] == ']')
{
/* concealed, logical device */
fptr -= 2;
if (MATCH10 (fptr, ".][000000]"))
{
fptr--;
while (fptr > ExpFileName && *fptr != '[' &&
*fptr != '.' && fptr[-1] != '^') fptr--;
}
}
zptr = (sptr = DirFileNameBuffer) + sizeof(DirFileNameBuffer);
if (MATCH8 (fptr, "[000000]") || MATCH0 (fptr, "[000000.]", 9))
{
#ifdef ODS_EXTENDED
if (OdsExtended)
{
for (cptr = ParseNaml.naml$l_long_dev;
cptr < fptr && sptr < zptr;
*sptr++ = *cptr++);
}
else
#endif /* ODS_EXTENDED */
{
for (cptr = ParseNam.nam$l_dev;
cptr < fptr && sptr < zptr;
*sptr++ = *cptr++);
}
for (cptr = "[000000]000000.DIR";
*cptr && sptr < zptr;
*sptr++ = *cptr++);
if (sptr >= zptr) sptr--;
*sptr = '\0';
}
else
if (*fptr == '[')
{
#ifdef ODS_EXTENDED
if (OdsExtended)
{
for (cptr = ParseNaml.naml$l_long_dev;
cptr < fptr && sptr < zptr;
*sptr++ = *cptr++);
}
else
#endif /* ODS_EXTENDED */
{
for (cptr = ParseNam.nam$l_dev;
cptr < fptr && sptr < zptr;
*sptr++ = *cptr++);
}
for (cptr = "[000000]"; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (fptr[0] == '.' && fptr[1] == ']')
fptr += 3;
else
fptr++;
while (*fptr && *fptr != '.' && *fptr != ']' && sptr < zptr)
{
if (*fptr == '^') *sptr++ = *fptr++;
if (sptr < zptr) *sptr++ = *fptr++;
}
for (cptr = ".DIR"; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (sptr >= zptr) sptr--;
*sptr = '\0';
}
else
{
#ifdef ODS_EXTENDED
if (OdsExtended)
{
for (cptr = ParseNaml.naml$l_long_dev;
cptr < fptr && sptr < zptr;
*sptr++ = *cptr++);
}
else
#endif /* ODS_EXTENDED */
{
for (cptr = ParseNam.nam$l_dev;
cptr < fptr && sptr < zptr;
*sptr++ = *cptr++);
}
if (sptr < zptr) *sptr++ = ']';
if (fptr[0] == '.' && fptr[1] == ']')
fptr += 3;
else
fptr++;
while (*fptr && *fptr != ']' && *fptr != '.' && sptr < zptr)
{
if (*fptr == '^') *sptr++ = *fptr++;
if (sptr < zptr) *sptr++ = *fptr++;
}
for (cptr = ".DIR"; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (sptr >= zptr) sptr--;
*sptr = '\0';
}
/* buffer this (soon to be the previous) file name */
strcpy (FileNameBuffer, FileName);
/* copy out the generated directory file name */
strcpy (DirFileNamePtr, DirFileNameBuffer);
*DirFileLengthPtr = DirFileNameBufferLength = sptr - DirFileNameBuffer;
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"{!UL}!-!#AZ", *DirFileLengthPtr, DirFileNamePtr);
/* release parse and search internal data structures */
ParseFab.fab$l_fna = "a:[b]c.d;";
ParseFab.fab$b_fns = 9;
ParseFab.fab$b_dns = 0;
#ifdef ODS_EXTENDED
if (OdsExtended)
{
ParseNaml.naml$l_long_result = 0;
ParseNaml.naml$b_nop = NAM$M_SYNCHK;
}
else
#endif /* ODS_EXTENDED */
{
ParseNam.nam$l_rlf = 0;
ParseNam.nam$b_nop = NAM$M_SYNCHK;
}
sys$parse (&ParseFab, 0, 0);
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"!AZ !AZ", FileNameBuffer, DirFileNameBuffer);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
ODS (FILES-11) directory parser. Two orders of magnitude faster than $SEARCH
and NO repeated elevation to EXEC mode. At the first call takes an in-memory
snapshot of the directory file content and retains that, parsing the content,
for the duration of the search. The memory is released by OdsParseRelease().
Successive calls parse the next directory name from the directory file and
return as would OdsSearch().
Returns SS$_RETRY to indicate the parser declines to process the initial call
and the caller should return to using $SEARCH (reasons obvious in code).
Otherwise returns a VMS success or non-success status code.
Always allow for the extended specification escape character when copying file
specification elements. This is not a syntax check function and will present
no issue with a non-extended file specification.
THE FOLLOWING ARE NOT MY WORDS:
A files-11 directory file holds a sequence of records. There is one record
for each filename in the directory. Each record consists of a HEADER,
followed by one or more SUBRECORDs - one SUBRECORD for each version of that
file. The HEADER is laid out as follows:
word:size size of this record, excluding itself
word:verlimit version limit for this file
byte:flags flags : 0 = DIR$C_FID = usual case
byte:namecount # of characters in next field
byte:name[namecount] filename
byte:pad null byte, if reqd, to pad to next word boundary
The SUBRECORDs are laid out as follows:
word:version version number
six-byte:fid fid of this version
The SUBRECORDs are ordered by decreasing version number.
Records are dense within each 512-byte block of the directory file (ie,
there are no 'gaps' between records). However, not all blocks of the
directory file need be full. The 'end-of-data' for a block is marked by a
HEADER whose size field is 0xFFFF.
Finally, a file may well have so many versions that there is not enough
room within a 512-byte block to hold the entire record for that filename.
Say the first block had enough room for versions 1000 down to 950 for
filename "A.A". The Files-11 XQP inserts a 0xFFFF 'end-of-block', at
that point, then starts afresh in the next block with a HEADER, for the
same filename, "A.A", but with SUBRECORDs continuing for version 944 and
downwards. [put another way, records don't span block boundaries]
Very finally, a HEADER record must have at least one following VERSION
subrecord in that block. Backup code assumes this to hold true. If
it doesn't hold true, then typical symptoms are failures in trying to
access FOO.BAR;-1 when there's only one version of that file.
Here's a tiny example, of a directory which holds just 3 files, called
A.A;5, A.A;2 and MINE.DAT;6 ...
record
HEADER
word:size 0018
word:verlimit 7fff
byte:flags 00 = DIR$C_FID = regular case
byte:namecount 03
byte:name[namecount] 412e41 = 'A.A'
byte:pad 00
SUBRECORD-1
word:version 0005
six-byte:fid 1524-0049-0000 = (5412,73,0)
SUBRECORD-2
word:version 0002
six-byte:fid 16bc-003f-0000 = (5820,63,0)
record
HEADER
word:size 0014
word:verlimit 7fff
byte:flags 00 = DIR$C_FID = regular case
byte:namecount 08
byte:name[namecount] 4d494e452e444154 = 'MINE.DAT'
byte:pad none required
SUBRECORD-1
word:version 0006
six-byte:fid 190f-0057-0000 = (6415,87,0)
record
HEADER
word:size ffff => end-of-block
*/
#if ODS_DIRECT
int OdsDirectSearch (ODS_STRUCT *odsptr)
{
static char VersionString [16];
static $DESCRIPTOR (VersionStringDsc, VersionString);
static $DESCRIPTOR (VersionFaoDsc, ";!UL\0");
BOOL WildMatch;
uint status, flags, length, nlen, rlen, vlim, vnum,
EmptyBlockCount;
char ch;
char *cptr, *czptr, *dzptr, *fptr, *rptr, *rzptr, *sptr, *zptr;
uchar *nptr;
uchar fid [6];
char DeviceName [64+1];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsDirectSearch() !&X", odsptr);
/* this bogus status indicates the parser declines the call */
if (!OdsDirect)
{
odsptr->DirectRetry = true;
return (SS$_RETRY);
}
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectCallCount);
odsptr->DirectCallCount++;
/* this function only handles single, flat directories */
if (((odsptr->Nam_fnb & NAM$M_SEARCH_LIST) != 0) ||
((odsptr->Nam_fnb & NAM$M_WILD_DIR) != 0))
{
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectRetryCount);
/* only do this the once when the initial call declined */
odsptr->DirectRetry = true;
return (SS$_RETRY);
}
if (!odsptr->DataPtr)
{
/**************/
/* initialise */
/**************/
if (OdsNoDirect)
{
zptr = (sptr = DeviceName) + sizeof(DeviceName)-1;
czptr = (cptr = odsptr->ExpFileName) + odsptr->ExpFileNameLength;
while (cptr < czptr && sptr < zptr && *cptr != ':') *sptr++ = *cptr++;
if (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "!&Z !&Z",
DeviceName, OdsNoDirect);
/* list of comma-separated device names */
cptr = OdsNoDirect;
while (*cptr)
{
sptr = cptr;
while (*cptr && *cptr != ',') cptr++;
ch = *cptr;
*cptr = '\0';
if (!strcasecmp (DeviceName, sptr))
{
*cptr = ch;
sptr = NULL;
break;
}
if (*cptr = ch) cptr++;
}
if (!sptr)
{
/* hit one of the device names in the logical name value */
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectRetryCount);
odsptr->DirectRetry = true;
return (SS$_RETRY);
}
}
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectLoadCount);
/* pre-fill result file name up to and including directory */
zptr = (sptr = odsptr->ResFileName) + sizeof(odsptr->ResFileName)-1;
czptr = (cptr = odsptr->ExpFileName) + odsptr->ExpFileNameLength;
while (cptr < czptr && sptr < zptr && *cptr != ']')
{
if (MATCH10(cptr,".][000000]"))
{
cptr += 9;
continue;
}
if (SAME2(cptr,'.]'))
{
*sptr++ = *cptr++;
cptr += 2;
continue;
}
if (*cptr == '^') *sptr++ = *cptr++;
if (cptr < czptr && sptr < zptr) *sptr++ = *cptr++;
}
if (cptr < czptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
if (cptr < czptr && sptr < zptr)
{
/* fill various pointers and lengths */
length = sptr - odsptr->ResFileName;
czptr = (cptr = odsptr->ResFileName) + length;
odsptr->NamNodePtr = cptr;
odsptr->NamNodeLength = 0;
odsptr->NamDevicePtr = cptr;
while (cptr < czptr && *cptr != ':') cptr++;
while (cptr < czptr) cptr++;
odsptr->NamDeviceLength = cptr - odsptr->NamDevicePtr;
odsptr->NamDirectoryPtr = cptr;
while (cptr < czptr && *cptr != ']')
{
if (*cptr == '^') cptr++;
if (cptr < czptr) cptr++;
}
while (cptr < czptr) cptr++;
odsptr->NamDirectoryLength = cptr - odsptr->NamDirectoryPtr;
/* the parsed file name will be appended to this pointer */
odsptr->NamNamePtr = cptr;
/* reproduce the pre-fill in the expanded file name */
zptr = (sptr = odsptr->ExpFileName) + sizeof(odsptr->ExpFileName)-1;
czptr = (cptr = odsptr->ResFileName) + (int)odsptr->NamNamePtr;
for (cptr = odsptr->ResFileName;
cptr < czptr && sptr < zptr;
*sptr++ = *cptr++);
*sptr = '\0';
/* searches for highest version and *.DIR may be optimised */
odsptr->DirectDotDir =
odsptr->DirectVersion0 =
odsptr->DirectVersionHit0 = false;
odsptr->DirectWildcard[0] = '\0';
zptr = (sptr = odsptr->DirectWildcard) +
sizeof(odsptr->DirectWildcard)-1;
for (cptr = odsptr->NamFileSysNamePtr;
*cptr && sptr < zptr;
*sptr++ = *cptr++);
*sptr = '\0';
if (!odsptr->DirectWildcard[0])
odsptr->DirectVersion0 = true;
else
if (MATCH7 (odsptr->DirectWildcard, "*.DIR;"))
{
/* optimise WASD's "Index of" DirBeginDirectories() */
odsptr->DirectDotDir = odsptr->DirectVersion0 = true;
odsptr->DirectWildcard[0] = '\0';
}
else
if (MATCH5 (odsptr->DirectWildcard, "*.*;") ||
MATCH6 (odsptr->DirectWildcard, "*.*;0"))
{
odsptr->DirectVersion0 = true;
odsptr->DirectWildcard[0] = '\0';
}
else
if (MATCH6 (odsptr->DirectWildcard, "*.*;*"))
odsptr->DirectWildcard[0] = '\0';
else
if (*(sptr-1) == ';')
{
odsptr->DirectVersion0 = true;
strcat (odsptr->DirectWildcard, "*");
}
else
if (*(USHORTPTR)(sptr-2) == ';0')
odsptr->DirectVersion0 = true;
else
if (!odsptr->NamVersionLength)
{
odsptr->DirectVersion0 = true;
strcat (odsptr->DirectWildcard, ";*");
}
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"dotdir:!&B version0:!&B dotdir:!&B wildcard:!&Z",
odsptr->DirectDotDir, odsptr->DirectVersion0,
odsptr->DirectDotDir, odsptr->DirectWildcard);
/* read the directory file into (global) memory */
status = OdsLoadDirect (odsptr, odsptr->NamDevicePtr);
if (VMSnok (status))
{
if (status != SS$_NOSUCHFILE)
ErrorNoticed (NULL, status, odsptr->NamDevicePtr, FI_LI);
return (SS$_RETRY);
}
odsptr->DirectTheLength =
odsptr->DirectTheRecord =
odsptr->DirectSubRecord = 0;
if (WATCH_CATEGORY(WATCH_INTERNAL))
WatchThis (WATCHALL, WATCH_INTERNAL,
"DIRECTory !UL blocks !UL bytes version0:!&B dotdir:!&B !&Z !&Z",
(odsptr->DataLength / 512) + 1, odsptr->DataLength,
odsptr->DirectVersion0, odsptr->DirectDotDir,
odsptr->NamDevicePtr, odsptr->DirectWildcard);
}
else
status = SS$_RESULTOVF;
}
else
status = SS$_NORMAL;
/* loop(s) just to allow convenient /break;/s from the processing */
for (;;)
{
/*******************/
/* parse directory */
/*******************/
/* if an error from the initialisation */
if (VMSnok (status)) break;
EmptyBlockCount = 0;
if (odsptr->DirectSubRecord)
rptr = odsptr->DataPtr + odsptr->DirectSubRecord;
else
rptr = odsptr->DataPtr + odsptr->DirectTheRecord;
rzptr = odsptr->DataPtr + odsptr->DirectTheRecord +
odsptr->DirectTheLength;
dzptr = odsptr->DataPtr + odsptr->DataLength;
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"!UL !UL !UL !UL !UL !UL !UL !UL",
odsptr->DataPtr, odsptr->DataLength,
odsptr->DirectTheRecord, odsptr->DirectTheLength,
odsptr->DirectSubRecord, rptr, rzptr, dzptr);
for (;;)
{
/* if just parsing subrecords (versions) */
if (odsptr->DirectSubRecord) break;
for (;;)
{
rlen = (uint)*(USHORTPTR)rptr;
rptr += sizeof(ushort);
if (WATCH_MODULE(WATCH_MOD_ODS))
{
if (rlen == (uint)0xffff)
WatchThis (WATCHALL, WATCH_MOD_ODS, "0xFFFF end of record");
else
{
WatchThis (WATCHALL, WATCH_MOD_ODS,
"RECORD block:!UL byte:!UL rlen:!UL",
((rptr - odsptr->DataPtr) / 512) + 1,
((rptr - odsptr->DataPtr) % 512),
rlen);
WatchDataDump (rptr, rlen);
}
}
/* if not end of records (in this block) sentinal */
if (rlen && rlen != (uint)0xffff && rlen < 508)
{
/* records are always on even byte (word) boundaries */
rzptr = rptr + rlen;
if ((int)rzptr & 1) rzptr++;
/* break from loop to process record */
EmptyBlockCount = 0;
break;
}
else
if (rlen && rlen != (uint)0xffff && rlen > 508)
{
status = SS$_BUGCHECK;
ErrorNoticed (NULL, status,
"block:!UL byte:!UL length:!UL !&Z",
FI_LI,
((rptr - odsptr->DataPtr) / 512) + 1,
((rptr - odsptr->DataPtr) % 512),
rlen, odsptr->NamDevicePtr);
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectBugcheckCount);
break;
}
else
if (EmptyBlockCount++ >= 32)
{
status = SS$_BUGCHECK;
ErrorNoticed (NULL, status, odsptr->NamDevicePtr, FI_LI);
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectBugcheckCount);
break;
}
/* step the record pointer to the next block */
rptr -= odsptr->DataPtr;
/* if not already on the block boundary add one to get to next */
if ((ulong)rptr % 512)
rptr = (((ulong)rptr / 512) + 1) * 512;
else
rptr = ((ulong)rptr / 512) * 512;
rptr += (ulong)odsptr->DataPtr;
if (WATCH_MODULE(WATCH_MOD_ODS))
{
WatchThis (WATCHALL, WATCH_MOD_ODS,
"DISK block:!UL byte:!UL",
((rptr - odsptr->DataPtr) / 512) + 1,
((rptr - odsptr->DataPtr) % 512));
WatchDataDump (rptr, 512);
}
/* continue to parse if not at end of content */
if (rptr < dzptr) continue;
/* end of records (file names) */
odsptr->DirectTheLength =
odsptr->DirectTheRecord =
odsptr->DirectSubRecord = 0;
if (odsptr->DirectWildcard[0])
status = RMS$_NMF;
else
status = RMS$_FNF;
break;
}
if (VMSnok (status)) break;
/****************/
/* got a record */
/****************/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "rlen:!UL", rlen);
vlim = *(USHORTPTR)rptr;
rptr += sizeof(ushort);
flags = *(uchar*)rptr++;
flags &= 0x07;
nlen = *(uchar*)rptr++;
nptr = rptr;
rptr += nlen;
if ((int)rptr & 1) rptr++;
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "flags:!2XL !UL !#AZ",
flags, nlen, nlen, nptr);
if (flags)
{
rptr = rzptr;
continue;
}
/**
Andrew C. Goldstein
VAX/VMS Software Devlopment
11-Jan-1985
https://web-docs.gsi.de/~kraemer/COLLECTION/VMS/ods2.txt
4.2.3 DIR$B_FLAGS - 1 Byte Flags
This byte contains the type code of the directory entry and
assorted flag bits. It contains the following subfields and
status bits:
DIR$V_TYPE The type code is contained in the three low
bits of the flags byte. It is one of the
following values:
DIR$C_FID The value field is a list of version
numbers and 48 bit File Id's.
DIR$C_LINKNAME The value field is a symbolic link string
(i.e., an alphabetic file specification).
[Symbolic links are not yet supported by
any implementation of Files-11.]
[No status bits are defined at present.]
DIR$C_FID = 0; ! normal file ID
DIR$C_LINKNAME = 1; ! symbolic name
! Filename encoding codes.
DIR$C_ODS2 = 0; ! ODS-2 legal ASCII
DIR$C_ISL1 = 1; ! ODS-2 illegal ASCII or ISO LATIN-1
DIR$$_TYPE_RESERVED = 2;
DIR$C_UCS2 = 3; ! Unicode USC-2 (16 bit characters)
**/
/* note the current record */
odsptr->DirectTheRecord = rptr - odsptr->DataPtr;
odsptr->DirectTheLength = rzptr - rptr;
odsptr->DirectSubRecord = 0;
/* buffer the on-disk file name */
zptr = (sptr = odsptr->SysFileName) + sizeof(odsptr->SysFileName)-1;
while (nlen-- && sptr < zptr) *sptr++ = *nptr++;
*sptr = '\0';
odsptr->NamFileSysNamePtr = odsptr->SysFileName;
odsptr->NamFileSysNameLength = sptr - odsptr->SysFileName;
/* note where the version begins */
odsptr->DirectSysFileNameLength = odsptr->NamFileSysNameLength;
if (sptr >= zptr)
{
status = SS$_RESULTOVF;
ErrorNoticed (NULL, status, odsptr->SysFileName, FI_LI);
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectBugcheckCount);
}
break;
}
if (VMSnok (status)) break;
if (odsptr->DirectVersion0 &&
!odsptr->DirectSubRecord)
{
/****************************/
/* only most-recent version */
/****************************/
/* note current file name in case spans multiple blocks */
if (odsptr->NamFileSysNameLength != odsptr->DirectCurrentLength ||
!strsame (odsptr->NamFileSysNamePtr, odsptr->DirectCurrent, -1))
{
zptr = (sptr = odsptr->DirectCurrent) +
sizeof(odsptr->DirectCurrent)-1;
nlen = odsptr->NamFileSysNameLength;
nptr = odsptr->NamFileSysNamePtr;
while (nlen-- && sptr < zptr) *sptr++ = *nptr++;
*sptr = '\0';
if (sptr >= zptr)
{
status = SS$_RESULTOVF;
ErrorNoticed (NULL, status, odsptr->DirectCurrent, FI_LI);
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectBugcheckCount);
}
odsptr->DirectCurrentLength = sptr - odsptr->DirectCurrent;
odsptr->DirectVersionHit0 = false;
}
else
if (odsptr->DirectVersionHit0)
{
/* same name and already hit version zero so skip this record */
odsptr->DirectTheRecord = rzptr - odsptr->DataPtr;
odsptr->DirectTheLength = odsptr->DirectSubRecord = 0;
continue;
}
else
odsptr->DirectVersionHit0 = true;
}
if (VMSok (status))
{
/*******************/
/* version and FID */
/*******************/
vnum = *(USHORTPTR)rptr;
rptr += sizeof(ushort);
memcpy (fid, rptr, sizeof(fid));
rptr += sizeof(fid);
if (rptr < rzptr)
{
/* next sub-record (version) */
odsptr->DirectSubRecord = rptr - odsptr->DataPtr;
}
else
{
/* subrecords exhausted, next record please Mr Music */
odsptr->DirectTheLength = odsptr->DirectSubRecord = 0;
odsptr->DirectTheRecord = rptr - odsptr->DataPtr;
}
}
if (VMSok (status))
{
/**************************/
/* version 0 already hit? */
/**************************/
if (odsptr->DirectVersionHit0) continue;
}
if (VMSok (status))
{
/***********************/
/* report this version */
/***********************/
#ifdef ODS_EXTENDED
if (OdsExtended)
memcpy (&odsptr->Naml.naml$w_fid, &fid, sizeof(fid));
else
#endif /* ODS_EXTENDED */
memcpy (&odsptr->Nam.nam$w_fid, &fid, sizeof(fid));
sys$fao (&VersionFaoDsc, 0, &VersionStringDsc, vnum);
/* append the version number */
zptr = (sptr = odsptr->SysFileName) + sizeof(odsptr->SysFileName)-1;
sptr += odsptr->DirectSysFileNameLength;
for (cptr = VersionString; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
odsptr->NamFileSysNameLength = sptr - odsptr->SysFileName;
if (sptr >= zptr)
{
status = SS$_RESULTOVF;
ErrorNoticed (NULL, status, odsptr->SysFileName, FI_LI);
InstanceGblSecIncrLong (&AccountingPtr->OdsDirectBugcheckCount);
}
}
if (VMSnok (status)) break;
if (odsptr->DirectDotDir)
{
/* small optimisation when looking only for directories */
if (*(sptr-1) != '1' ||
*(sptr-2) != ';' ||
TOUP(*(sptr-3)) != 'R' ||
TOUP(*(sptr-4)) != 'I' ||
TOUP(*(sptr-5)) != 'D' ||
*(sptr-6) != '.')
continue;
}
else
if (odsptr->DirectWildcard[0])
{
/******************/
/* match wildcard */
/******************/
WildMatch = StringMatchAndRegex (NULL,
odsptr->SysFileName,
odsptr->DirectWildcard,
SMATCH_GREEDY, NULL, NULL);
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "WILDCARD !&Z !&Z !AZ",
odsptr->SysFileName,
odsptr->DirectWildcard,
WildMatch ? "YES" : "NO");
if (!WildMatch) continue;
}
break;
}
if (VMSok (status))
{
/************************/
/* complete result name */
/************************/
/* append the pre-filled elements with the name.type;version */
zptr = odsptr->ResFileName + sizeof(odsptr->ResFileName)-1;
sptr = odsptr->NamNamePtr;
odsptr->NamVersionPtr = odsptr->NamTypePtr = NULL;
/* escape non-ODS-2 characters (after all, if not there not ODS-5!) */
nptr = odsptr->NamFileSysNamePtr;
for (nlen = odsptr->NamFileSysNameLength; nlen && sptr < zptr; nlen--)
{
if ((*nptr >= 'A' && *nptr <= 'Z') ||
(*nptr >= 'a' && *nptr <= 'z') ||
(*nptr >= '0' && *nptr <= '9') ||
(*nptr == '$' || *nptr == '-' || *nptr == '_') ||
(*nptr >= 0xa0 && *nptr <= 0xff))
*(uchar*)sptr++ = *nptr++;
else
{
if (*nptr == '.')
{
/* look ahead for a following period */
czptr = nptr + nlen;
for (cptr = nptr+1; cptr < czptr && *cptr != '.'; cptr++);
if (cptr < czptr)
{
/* found a following period so escape this one */
*sptr++ = '^';
}
else
{
/* no following period so end of name and begining of type */
odsptr->NamNameLength = sptr - odsptr->NamNamePtr;
odsptr->NamTypePtr = sptr;
}
}
else
/* semicolon permitted in names so only after a type period */
if (*nptr == ';' && odsptr->NamTypePtr)
{
/* version delimiting semicolon so end of type */
if (!odsptr->NamTypePtr) odsptr->NamTypePtr = sptr;
odsptr->NamTypeLength = sptr - odsptr->NamTypePtr;
odsptr->NamVersionPtr = sptr;
}
else
*sptr++ = '^';
if (sptr < zptr) *sptr++ = *nptr++;
}
}
*sptr = '\0';
if (!odsptr->NamTypePtr)
{
odsptr->NamTypePtr = sptr;
odsptr->NamTypeLength = sptr - odsptr->NamTypePtr;
}
if (!odsptr->NamVersionPtr) odsptr->NamVersionPtr = sptr;
odsptr->NamVersionLength = sptr - odsptr->NamVersionPtr;
odsptr->ResFileNameLength = sptr - odsptr->ResFileName;
/* also append the resultant file name to the pre-filled expanded name */
zptr = (sptr = odsptr->ExpFileName) + sizeof(odsptr->ExpFileName)-1;
sptr += (odsptr->NamNamePtr - odsptr->ResFileName);
czptr = odsptr->ResFileName + odsptr->ResFileNameLength;
for (cptr = odsptr->NamNamePtr;
cptr < czptr && sptr < zptr;
*sptr++ = *cptr++);
*sptr = '\0';
odsptr->ExpFileNameLength = sptr - odsptr->ExpFileName;
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"fid:(!UL,!UL,!UL) (!UL)!AZ (!UL)!AZ (!UL)!#AZ",
(fid[0] + (fid[1] << 8) + (fid[5] << 16)),
(fid[2] + (fid[3] << 8)),
(fid[4]),
odsptr->ExpFileNameLength, odsptr->ExpFileName,
odsptr->ResFileNameLength, odsptr->ResFileName,
odsptr->NamFileSysNameLength,
odsptr->NamFileSysNameLength,
odsptr->NamFileSysNamePtr);
if (odsptr->DirectVersion0) odsptr->DirectVersionHit0 = true;
}
if (VMSnok (status))
{
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "!&S", status);
/* release any directory file (global) memory */
if (odsptr->DataPtr)
{
if (WATCH_CATEGORY(WATCH_INTERNAL))
WatchThis (WATCHALL, WATCH_INTERNAL, "DIRECTory called:!UL",
odsptr->DirectCallCount);
VmFree (odsptr->DataPtr, FI_LI);
odsptr->DataPtr = NULL;
odsptr->DataLength = 0;
}
}
/*******************/
/* deliver any AST */
/*******************/
odsptr->Fab.fab$l_sts = status;
if (odsptr->AstFunction)
{
SysDclAst (odsptr->AstFunction, odsptr->AstParam);
odsptr->AstFunction = odsptr->AstParam = NULL;
}
return (status);
}
#endif /* ODS_DIRECT */
/*****************************************************************************/
/*
Called by AdminReportServerStats().
*/
#if ODS_DIRECT
char* OdsDirectReport (REQUEST_STRUCT* rqptr)
{
static char buf [128];
int average;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsDirectReport()");
if (AccountingPtr->OdsDirectLoadCount)
average = (AccountingPtr->OdsDirectCallCount -
AccountingPtr->OdsDirectRetryCount) /
AccountingPtr->OdsDirectLoadCount;
else
average = 0;
FaoToBuffer (buf, sizeof(buf), NULL,
"<tr><th>ODS directory parser:</th>\
<td colspan=\"2\">!&L ÷ !&L = !&L (!&L, !&L)</td></tr>\n",
AccountingPtr->OdsDirectCallCount,
AccountingPtr->OdsDirectLoadCount, average,
AccountingPtr->OdsDirectRetryCount,
AccountingPtr->OdsDirectBugcheckCount);
return (buf);
}
#endif /* ODS_DIRECT */
/*****************************************************************************/
/*
Load the specified directory name into dynamically allocated memory. 'DataPtr'
and 'DataLength' are set to reflect the file contents. 'DataPtr' needs to be
freed when finished with.
*/
#if ODS_DIRECT
int OdsLoadDirect
(
ODS_STRUCT *odsptr,
char *DirectName
)
{
int status,
DirFileNameLength;
char DirFileName [ODS_MAX_FILE_NAME_LENGTH+1];
ODS_STRUCT LoadOds;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsLoadDirect() !&Z", DirectName);
/* release any directory file (global) memory */
if (odsptr->DataPtr)
{
VmFree (odsptr->DataPtr, FI_LI);
odsptr->DataPtr = NULL;
odsptr->DataLength = 0;
}
status = OdsNameOfDirectoryFile (DirectName, strlen(DirectName),
DirFileName, &DirFileNameLength);
if (VMSnok (status)) return (status);
OdsStructInit (&LoadOds, true);
/* ensure we can read this directory */
sys$setprv (1, &SysPrvMask, 0, 0);
/* OdsParse() NAM$M_NOCONCEAL before OdsSearchNoConceal() */
OdsParse (&LoadOds,
NULL, 0, DirFileName, DirFileNameLength, NAM$M_NOCONCEAL,
NULL, NULL);
if (VMSok (status = OdsReallyADir (NULL, &LoadOds)))
{
if (VMSok (status = OdsLoadContent (&LoadOds, DirFileName)))
{
/* purloin the loaded directory content */
odsptr->DataPtr = LoadOds.DataPtr;
odsptr->DataLength = LoadOds.DataLength;
LoadOds.DataPtr = NULL;
LoadOds.DataLength = 0;
OdsParseRelease (&LoadOds);
if (0 && WATCH_MODULE(WATCH_MOD_ODS))
WatchDataDump (odsptr->DataPtr, odsptr->DataLength);
}
}
sys$setprv (0, &SysPrvMask, 0, 0);
return (status);
}
#endif /* ODS_DIRECT */
/*****************************************************************************/
/*
Load the specified file name raw content into dynamically allocated memory.
'DataPtr' and 'DataLength' are set to reflect the file contents. 'DataPtr'
needs to be freed when finished with.
*/
int OdsLoadContent
(
ODS_STRUCT *odsptr,
char *FileName
)
{
int status,
SizeInBytes;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsLoadContent() !AZ", FileName);
status = OdsOpenReadOnly (odsptr, FileName, true);
if (VMSnok (status)) return (status);
if (odsptr->XabFhc.xab$l_ebk <= 1)
SizeInBytes = odsptr->XabFhc.xab$w_ffb;
else
SizeInBytes = ((odsptr->XabFhc.xab$l_ebk-1) << 9) +
odsptr->XabFhc.xab$w_ffb;
/* round-up to ensure we have a full complement of blocks allocated */
odsptr->DataPtr = (char*)VmGet (((SizeInBytes/512)+1)*512);
odsptr->DataLength = 0;
odsptr->Rab.rab$l_ubf = odsptr->DataPtr;
for (;;)
{
if (SizeInBytes > 512*127)
odsptr->Rab.rab$w_usz = 512*127;
else
if (SizeInBytes > 0)
odsptr->Rab.rab$w_usz = SizeInBytes;
else
break;
status = sys$read (&odsptr->Rab, 0, 0);
if (VMSnok (status)) break;
odsptr->DataLength += odsptr->Rab.rab$w_rsz;
odsptr->Rab.rab$l_ubf += odsptr->Rab.rab$w_rsz;
SizeInBytes -= odsptr->Rab.rab$w_rsz;
}
sys$close (&odsptr->Fab, 0, 0);
if (status == RMS$_EOF) status = SS$_NORMAL;
if (VMSnok (status))
{
VmFree (odsptr->DataPtr, FI_LI);
odsptr->DataPtr = NULL;
odsptr->DataLength = 0;
}
return (status);
}
/*****************************************************************************/
/*
Load the specified file name into dynamically allocated memory. 'DataPtr' and
'DataLength' are set to reflect the file contents. Records are delimited by
newline characters and the file is terminated with a null character. Other
file related data remains set in the ODS structure. A VMS status code is
returned. This is a fully synchronous function mainly designed for loading
configuration files, etc. 'DataPtr' needs to be freed when finished with.
*/
int OdsLoadTextFile
(
ODS_STRUCT *odsptr,
char *FileName
)
{
int status,
SizeInBytes;
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsLoadTextFile() !AZ", FileName);
status = OdsOpenReadOnly (odsptr, FileName, false);
if (VMSnok (status)) return (status);
if (odsptr->XabFhc.xab$l_ebk <= 1)
SizeInBytes = odsptr->XabFhc.xab$w_ffb;
else
SizeInBytes = ((odsptr->XabFhc.xab$l_ebk-1) << 9) +
odsptr->XabFhc.xab$w_ffb;
odsptr->DataPtr = odsptr->DataParsePtr = cptr = (char*)VmGet(SizeInBytes+1);
odsptr->DataLength = odsptr->DataLineLength = 0;
for (;;)
{
odsptr->Rab.rab$l_ubf = cptr;
if (SizeInBytes > 32767)
odsptr->Rab.rab$w_usz = 32767;
else
odsptr->Rab.rab$w_usz = SizeInBytes;
status = sys$get (&odsptr->Rab, 0, 0);
if (VMSnok (status)) break;
cptr[odsptr->Rab.rab$w_rsz] = '\n';
sptr = cptr;
cptr += odsptr->Rab.rab$w_rsz + 1;
while (sptr < cptr)
{
if (!*sptr) *sptr = ' ';
sptr++;
}
odsptr->DataLength += odsptr->Rab.rab$w_rsz + 1;
SizeInBytes -= odsptr->Rab.rab$w_rsz + 1;
}
sys$close (&odsptr->Fab, 0, 0);
if (status == RMS$_EOF) status = SS$_NORMAL;
if (VMSok (status))
*cptr = '\0';
else
{
VmFree (odsptr->DataPtr, FI_LI);
odsptr->DataPtr = odsptr->DataLinePtr = odsptr->DataParsePtr = NULL;
odsptr->DataLength = odsptr->DataLineLength = 0;
}
return (status);
}
/*****************************************************************************/
/*
Free any memory allocated to contain the loaded text file.
Reset associated pointers and storage to empty.
*/
void OdsFreeTextFile (ODS_STRUCT *odsptr)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsFreeTextFile()");
if (odsptr->DataPtr)
{
VmFree (odsptr->DataPtr, FI_LI);
odsptr->DataPtr = odsptr->DataLinePtr = odsptr->DataParsePtr = NULL;
odsptr->DataLength = odsptr->DataLineLength = 0;
}
}
/*****************************************************************************/
/*
Parses each newline-delimited 'line' from a text file pointed to by 'DataPtr'.
Stores each of these lines between calls pointed to by 'DataLinePtr' and
'DataLineLength'. Current position in text file pointed to by 'DataParsePtr'
Designed for configuration files where a trailing backslash is used to continue
a line. 'DataLinePtr' needs to be freed if the file content is not read to
completion. 'BackslashMeans' can be '\\' meaning the backslash/newline are
absorbed, can be '\n' meaning a single newline is substituted, or anything else
the backslash is just part of the line.
*/
char* OdsParseTextFile
(
ODS_STRUCT *odsptr,
char BackslashMeans
)
{
int DataLineSize;
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsParseTextFile() !UL", BackslashMeans);
if (!odsptr->DataParsePtr) return (NULL);
if (!*(cptr = sptr = odsptr->DataParsePtr))
{
if (odsptr->DataLinePtr)
{
VmFree (odsptr->DataLinePtr, FI_LI);
odsptr->DataLinePtr = NULL;
odsptr->DataLineLength = odsptr->DataLineSize = 0;
}
return (NULL);
}
while (*sptr && *sptr != '\n')
{
sptr = odsptr->DataParsePtr;
while (*sptr && *sptr != '\n' && !SAME2(sptr,'\\\n')) sptr++;
if (*sptr == '\\') sptr += 2;
odsptr->DataParsePtr = sptr;
}
if (sptr - cptr + 1 > odsptr->DataLineSize)
{
if (sptr - cptr + 1 < 512)
DataLineSize = 512;
else
DataLineSize = sptr - cptr + 1;
if (DataLineSize > odsptr->DataLineSize)
{
if (odsptr->DataLinePtr) VmFree (odsptr->DataLinePtr, FI_LI);
odsptr->DataLinePtr = VmGet (odsptr->DataLineSize = DataLineSize);
}
}
if (*sptr) sptr++;
odsptr->DataParsePtr = sptr;
sptr = odsptr->DataLinePtr;
while (*cptr && *cptr != '\n')
{
while (*cptr && *cptr != '\n' && !SAME2(cptr,'\\\n'))
*sptr++ = *cptr++;
if (*cptr == '\\')
{
odsptr->DataLineNumber++;
switch (BackslashMeans)
{
case '\\' : cptr += 2; break;
case '\n' : *sptr++ = '\n'; cptr += 2; break;
default : *sptr++ = *cptr++;
}
}
}
*sptr = '\0';
odsptr->DataLineLength = sptr - odsptr->DataLinePtr;
odsptr->DataLineNumber++;
return (odsptr->DataLinePtr);
}
/*****************************************************************************/
/*
Synchronous check on the file characteristics directory bit to confirm a file
ending in '.DIR' is really a directory. The file must have been parsed or
searched-for. Returns SS$_NORMAL if it is, SS$_ABORT if it is not, or another
error status for whatever reason.
*/
int OdsReallyADir
(
REQUEST_STRUCT *rqptr,
ODS_STRUCT *odsptr
)
{
#define FCH$M_DIRECTORY 0x2000
int status;
unsigned long PrvPrv [2];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsReallyADir()");
/* use SYSPRV to ensure access to perform this check */
sys$setprv (1, &SysPrvMask, 0, &PrvPrv);
status = OdsFileAcpInfo (odsptr, NULL, 0);
if (!(PrvPrv[0] & PRV$M_SYSPRV)) sys$setprv (0, &SysPrvMask, 0, 0);
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "!&S !&B",
status, odsptr->FileQio.AtrUchar & FCH$M_DIRECTORY);
if (VMSnok (status)) return (status);
if (odsptr->FileQio.AtrUchar & FCH$M_DIRECTORY) return (SS$_NORMAL);
return (SS$_ABORT);
}
/*****************************************************************************/
/*
Copies ODS structure 2 to structure 1 adjusting the various pointers.
*/
OdsCopyStructure
(
ODS_STRUCT *odsptr1,
ODS_STRUCT *odsptr2
)
{
char *cptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsCopyStructure() !&B", OdsExtended);
/* copy the entire on-disk structure from file to cache */
memcpy (odsptr1, odsptr2, sizeof(ODS_STRUCT));
/* now adjust the pointers in this new structure */
odsptr1->NamNodePtr = cptr = odsptr1->ExpFileName;
odsptr1->NamDevicePtr = (cptr += odsptr1->NamNodeLength);
odsptr1->NamDirectoryPtr = (cptr += odsptr1->NamDeviceLength);
odsptr1->NamNamePtr = (cptr += odsptr1->NamDirectoryLength);
odsptr1->NamTypePtr = (cptr += odsptr1->NamNameLength);
odsptr1->NamVersionPtr = (cptr += odsptr1->NamTypeLength);
odsptr1->NamFileSysNamePtr = odsptr1->SysFileName;
}
/****************************************************************************/
/*
Get the volume's underlying file system (ODS-2 or ODS-5), by sys$getdvi() the
ACPTYPE for the device. Return the appropriate WASD value for detected file
system or zero to indicate some other condition. Return 0 if it cannot be
determined for some reason, or 2 or 5 representing each of the underlying
file-system structures.
*/
/* if pre-7.2 Alpha then define this */
#ifndef DVI$C_ACP_F11V5
#define DVI$C_ACP_F11V5 11
#endif
int OdsVolumeStructure (char *DeviceName)
{
static unsigned long DevAcpType,
DevChar;
static $DESCRIPTOR (DevNameDsc, "");
static struct {
short buf_len;
short item;
char *buf_addr;
short *ret_len;
}
AcpTypeItemList [] =
{
{ sizeof(DevAcpType), DVI$_ACPTYPE, &DevAcpType, 0 },
{ sizeof(DevChar), DVI$_DEVCHAR, &DevChar, 0 },
{ 0, 0, 0, 0 }
};
int status;
char *cptr;
struct {
unsigned short Status;
unsigned short Count;
unsigned long Unused;
} IOsb;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS,
"OdsVolumeStructure() !&Z", DeviceName);
for (cptr = DeviceName; *cptr && *cptr != ':'; cptr++);
/* if we can't find a device in it then assume it's ODS-2 */
if (!*cptr) return (0);
DevNameDsc.dsc$a_pointer = DeviceName;
DevNameDsc.dsc$w_length = cptr - DeviceName;
DevChar = DevAcpType = 0;
status = sys$getdviw (EfnWait, 0, &DevNameDsc, &AcpTypeItemList,
&IOsb, 0, 0, 0);
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchDataFormatted ("sys$getdviw() !#AZ !&S !&S !UL\n",
DevNameDsc.dsc$w_length, DevNameDsc.dsc$a_pointer,
status, IOsb.Status, DevAcpType);
if (VMSok (status)) status = IOsb.Status;
/* if error */
if (VMSnok(status)) return (0);
/* if volume not mounted */
if (!(DevChar & DEV$M_MNT)) return (0);
if (DevAcpType == DVI$C_ACP_F11V2) return (2);
if (DevAcpType == DVI$C_ACP_F11V5) return (5);
return (0);
}
/*****************************************************************************/
/*
Performance of OdsDirectSearch() compared to OdsSearch().
Compile with module WATCHing.
$ HTTPD /TESTS ODS=SEARCH=<filespec> !use OdsSearch() i.e. $SEARCH
$ HTTPD /TESTS ODS=DIRECT=<filespec> !use OdsSearchNext()
Adding an ACP file access provides a bit more of a realistic load.
$ HTTPD /TESTS ODS=SEARCH=ACP=<filespec>
$ HTTPD /TESTS ODS=DIRECT=ACP=<filespec>
*/
#if ODS_DIRECT
void OdsDirectPerfOut
(
struct dsc$descriptor_s *dscptr,
int fcount
)
{
fprintf (stdout, "%d files\t%*.*s\n",
fcount,
dscptr->dsc$w_length, dscptr->dsc$w_length, dscptr->dsc$a_pointer);
}
void OdsDirectPerf (char *param)
{
BOOL DoAcp, DoShow;
int dlen, fcount, flen, status;
char *dptr, *fptr;
ODS_STRUCT SearchOds;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_ODS))
WatchThis (WATCHALL, WATCH_MOD_ODS, "OdsDirectPerf() !AZ", param);
if (strsame (param, "DIRECT=", 7))
{
OdsDirect = true;
param += 7;
}
else
if (strsame (param, "SEARCH=", 7))
param += 7;
else
exit (SS$_ABORT);
if (strsame (param, "ACP=", 4))
{
DoAcp = true;
param += 4;
}
else
DoAcp = false;
if (*param == '+')
{
DoShow = true;
param++;
}
else
DoShow = false;
dlen = flen = 0;
for (dptr = fptr = param; *fptr; fptr++);
while (fptr > dptr && *fptr != ']') fptr--;
if (fptr > dptr) fptr++;
flen = strlen(fptr);
dlen = fptr - dptr;
status = OdsParse (&SearchOds, fptr, flen, dptr, dlen,
NAM$M_NOCONCEAL, 0, 0);
if (VMSnok (status)) exit (status);
fcount = 0;
lib$init_timer();
while (VMSok (status = OdsSearchNoConceal (&SearchOds, 0, 0)))
{
if (DoShow)
fprintf (stdout, "%s\n", SearchOds.ResFileName);
if (DoAcp)
if (VMSnok (status = OdsFileAcpInfo (&SearchOds, NULL, 0)))
break;
if (!(++fcount % 1000))
lib$show_timer(0, 0, OdsDirectPerfOut, fcount);
}
lib$show_timer(0, 0, OdsDirectPerfOut, fcount);
exit (status);
}
#endif /* ODS_DIRECT */
/****************************************************************************/