[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]
/*****************************************************************************
/*
HTAdmin.c
Command-line administration of the WASD .$HTA authentication databases.
$ HTADMIN <database> [<username>] [<qualifiers>]
USAGE EXAMPLES
--------------
To create a new database named EXAMPLE.$HTA (in the current directory)
$ HTADMIN EXAMPLE /CREATE
Delete an existing database
$ HTADMIN EXAMPLE /DELETE /CONFIRM
List (briefly) the records
$ HTADMIN EXAMPLE
List (briefly) the specific user record DANIEL
$ HTADMIN EXAMPLE DANIEL
List all detail (132 colums) of the specified user record
$ HTADMIN EXAMPLE DANIEL /FULL
To add the new record DANIEL with default read access
$ HTADMIN EXAMPLE DANIEL /ADD /NAME="Mark Daniel"
Add the new record DANIEL with contact details and read+write access
$ HTADMIN EXAMPLE DANIEL /ADD /WRITE /CONTACT="Postal Address"
Add the new record DANIEL and be prompted for a password, or to specify the
password on the command-line, or have the utility generate a password or
four-digit PIN style password (which is displayed after the record is
sucessfully added)
$ HTADMIN EXAMPLE DANIEL /ADD /NAME="Mark Daniel" /PASSWORD
$ HTADMIN EXAMPLE DANIEL /ADD /NAME="Mark Daniel" /PASSWORD=cher10s
$ HTADMIN EXAMPLE DANIEL /ADD /NAME="Mark Daniel" /GENERATE
$ HTADMIN EXAMPLE DANIEL /ADD /NAME="Mark Daniel" /PIN
To update an existing record
$ HTADMIN EXAMPLE DANIEL /UPDATE /EMAIL="Mark.Daniel@wasd.vsm.com.au"
Update the specified record's password (interactively) then to generate a four
digit PIN for a password (which is then displayed)
$ HTADMIN EXAMPLE DANIEL /UPDATE /PASSWORD
$ HTADMIN EXAMPLE DANIEL /UPDATE /GENERATE
$ HTADMIN EXAMPLE DANIEL /UPDATE /PIN
Disable then enable an existing user record without changing anything else
$ HTADMIN EXAMPLE DANIEL /UPDATE /DISABLE
$ HTADMIN EXAMPLE DANIEL /UPDATE /ENABLE
To list the entire database, first briefly, then in 132 column mode (with all
detail), then finally as a comma-separated listing
$ HTADMIN EXAMPLE
$ HTADMIN EXAMPLE /FULL
$ HTADMIN EXAMPLE /CSV
SORT DETAILS
------------
The /SORT qualifier sorts the current database records according to the /SORT=
parameters. It can be used with the /LIST qualifier to produce ordered reports
or will output the records into another authentication file. By default it
sorts ascending by username. Qualifier parameters allow a sort by DATE or
COUNT. Each of these allows the further specification of which date or count;
ACCESS, CHANGE or FAILURE.
Generating a listing with specified order
$ HTADMIN EXAMPLE /LIST /SORT=DATE=ACCESS
$ HTADMIN EXAMPLE /LIST /SORT=COUNT=FAILURE /OUTPUT=EXAMPLE.LIS
Sort descending by username into a higher version of EXAMPLE.$HTA
$ HTADMIN EXAMPLE /SORT
To sort by username into another .$HTA file
$ HTADMIN EXAMPLE /SORT /OUTPUT=ANOTHER
List by most-recently accessed
$ HTADMIN EXAMPLE /LIST /SORT=DATE
List by most-recently failed to authenticate
$ HTADMIN EXAMPLE /LIST /SORT=DATE=FAILURE
Sort file into order by most frequently authenticated (accessed)
$ HTADMIN EXAMPLE /SORT=COUNT
QUALIFIERS
----------
/ADD add a new record
/CONFIRM confirm deletion of database
/CONTACT="<string>" contact information for record
/CREATE create a new database
/CSV[=TAB|char] comma-separated listing (optional character)
/DATABASE= database name (or as command-line parameter)
/DELETE delete a database or username record from a database
/DISABLED username record is disabled (cannot be used)
/EMAIL="<string>" email address for record
/ENABLED username record is enabled (can be used)
/FULL listing showing full details
/GENERATE generate a six character password
/HELP brief usage information
/[NO]HTTPS synonym for /SSL
/LIST listing (brief by default, see /FULL and /CSV)
/MODIFY synonym for /UPDATE
/NAME="<string>" full name for username record
/OUTPUT= alternate output for database listing
/PASSWORD[=<string>] username record password (prompts if not supplied)
/PIN generate four-digit "PIN number" for password
/[NO]READ username can/can't read
/SORT[=<parameters>] sort the records into a new/nuther database
/[NO]SSL only allowed to authenticate when using SSL (https:)
/[NO]WRITE username can/can't write
/UPDATE update an existing username record
/USER=<string> username
/VERSION display version of HTADMIN
BUILD DETAILS
-------------
See BUILD_HTADMIN.COM procedure.
COPYRIGHT
---------
Copyright (C) 2003-2021 Mark G.Daniel
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
VERSION HISTORY (update SOFTWAREVN as well!)
---------------
18-DEC-2020 MGD v1.0.5, VAX no longer implemented
16-APR-2016 MGD v1.0.4, .AddedBinTime to .AddedTime64 name change
26-MAY-2008 MGD v1.0.3, bugfix; /READ and /WRITE set-reset flags for
HTTP methods in-line with [SRC.HTTPD]HTADMIN.C
21-MAY-2008 MGD v1.0.2, bugfix; GetSetPassword() string descriptors
bugfix; upper-case password string regardless
23-DEC-2003 MGD v1.0.1, minor conditional mods to support IA64
23-SEP-2003 MGD v1.0.0, initial
*/
/*****************************************************************************/
#define SOFTWAREVN "1.0.5"
#define SOFTWARENM "HTADMIN"
#ifdef __ALPHA
# define SOFTWAREID SOFTWARENM " AXP-" SOFTWAREVN
#endif
#ifdef __ia64
# define SOFTWAREID SOFTWARENM " IA64-" SOFTWAREVN
#endif
#ifdef __VAX
# error VAX no longer implemented
#endif
#ifdef __x86_64
# define SOFTWAREID SOFTWARENM " X86-" SOFTWAREVN
#endif
char Copyright [] =
"Copyright (C) 2003-2021 Mark G.Daniel\n\
Licensed under the Apache License, Version 2.0 (the \"License\");\n\
you may not use this file except in compliance with the License.\n\
You may obtain a copy of the License at\n\
http://www.apache.org/licenses/LICENSE-2.0\n\
Unless required by applicable law or agreed to in writing, software\n\
distributed under the License is distributed on an \"AS IS\" BASIS,\n\
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
See the License for the specific language governing permissions and\n\
limitations under the License.\n";
#ifdef WASD_VMS_V6
#undef _VMS_V6_SOURCE
#define _VMS_V6_SOURCE
#undef __VMS_VER
#define __VMS_VER 60000000
#undef __CRTL_VER
#define __CRTL_VER 60000000
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
/* VMS related header files */
#include <climsgdef.h>
#include <descrip.h>
#include <sordef.h>
#include <sor$routines.h>
#include <ssdef.h>
#include <stsdef.h>
#include <uaidef.h>
/* application related header files */
#include "[-.httpd]wasd.h"
BOOL AddUserName,
CommandConfirmed,
CreateDatabase,
DeleteDatabase,
DeleteUserName,
GeneratePassword,
GeneratePIN,
ListBrief,
ListCsv,
ListDatabase,
ListFull,
FlagDisabled,
FlagEnabled,
FlagRead,
FlagNoRead,
FlagWrite,
FlagNoWrite,
FlagSslOnly,
FlagNoSslOnly,
RequiresWrite,
SortDatabase,
SortDate,
SortAccess,
SortChange,
SortCount,
SortFailure,
SortUserName,
UpdateUserName;
int ContactLength,
EmailLength,
FullNameLength,
PaswordLength,
UserNameLength;
unsigned long Time64 [2];
char CsvChar;
char *ContactPtr,
*DatabaseNamePtr,
*EmailPtr,
*FullNamePtr,
*OutputPtr,
*PasswordPtr,
*UserNamePtr;
char ExpFileName [256],
ResFileName [256];
char Utility [] = "HTADMIN";
AUTH_HTAREC HtaRecord;
struct FAB DatabaseFab;
struct NAM DatabaseNam;
struct RAB DatabaseRab;
struct XABPRO DatabaseXabPro;
/* prototypes */
int DatabaseAddRecord ();
DtabaseCreate (char*, BOOL);
DatabaseDelete ();
int DatabaseDeleteRecord ();
int DatabaseOpen ();
DatabasePrintRecord (int);
DatabaseRecordPut ();
DatabaseSort ();
int DatabaseUpdateRecord ();
GetParameters ();
int GetSetPassword ();
BOOL strsame (char*, char*, int);
/****************************************************************************/
main ()
{
char *cptr;
/*********/
/* begin */
/*********/
GetParameters ();
if (UserNamePtr)
{
UserNameLength = strlen(UserNamePtr);
if (UserNameLength > sizeof(HtaRecord.UserName))
{
fprintf (stdout, "%%%s-E-USERNAME, too long\n", Utility);
exit (SS$_RESULTOVF | STS$M_INHIB_MSG);
}
for (cptr = UserNamePtr; *cptr; cptr++)
if (!isalnum(*cptr) && *cptr != '_' && *cptr != '-') break;
if (*cptr)
{
fprintf (stdout, "%%%s-E-USERNAME, not acceptable\n", Utility);
exit (CLI$_INSFPRM | STS$M_INHIB_MSG);
}
}
if (FullNamePtr)
{
FullNameLength = strlen(FullNamePtr);
if (FullNameLength > sizeof(HtaRecord.FullName))
{
fprintf (stdout, "%%%s-E-FULLNAME, too long\n", Utility);
exit (SS$_RESULTOVF | STS$M_INHIB_MSG);
}
}
if (ContactPtr)
{
ContactLength = strlen(ContactPtr);
if (ContactLength > sizeof(HtaRecord.Contact))
{
fprintf (stdout, "%%%s-E-CONTACT, too long\n", Utility);
exit (SS$_RESULTOVF | STS$M_INHIB_MSG);
}
}
if (EmailPtr)
{
EmailLength = strlen(EmailPtr);
if (EmailLength > sizeof(HtaRecord.Email))
{
fprintf (stdout, "%%%s-E-EMAIL, too long\n", Utility);
exit (SS$_RESULTOVF | STS$M_INHIB_MSG);
}
}
if (CreateDatabase)
{
if (!DatabaseNamePtr || !DatabaseNamePtr[0]) exit (CLI$_INSFPRM);
DatabaseCreate (DatabaseNamePtr, false);
exit (SS$_NORMAL);
}
if (DeleteDatabase && !UserNamePtr) DatabaseDelete ();
sys$gettim (&Time64);
if (ListDatabase)
DatabaseSort ();
else
if (SortDatabase)
DatabaseSort ();
else
if (AddUserName)
DatabaseAddRecord ();
else
if (DeleteUserName)
DatabaseDeleteRecord ();
else
if (UpdateUserName)
DatabaseUpdateRecord ();
else
{
ListDatabase = true;
if (UserNamePtr) ListFull = true;
DatabaseSort ();
}
}
/*****************************************************************************/
/*
Add a new record. First make sure it does not already exist. The check for
a previously deleted (zeroed) record. If found update the record with the new
content. If not found add a new record to the end of the file.
*/
int DatabaseAddRecord ()
{
BOOL ReuseEmptyRecord;
int status;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (!UserNameLength)
{
fprintf (stdout, "%%%s-E-USERNAME, not specified\n", Utility);
exit (CLI$_INSFPRM | STS$M_INHIB_MSG);
}
DatabaseOpen (true);
status = DatabaseFindRecord ();
if (status == SS$_NORMAL) exit (RMS$_REX);
if (status != RMS$_EOF) exit (status);
/* now look for a previously deleted (empty) record */
status = sys$rewind (&DatabaseRab, 0, 0);
while (VMSok (status = sys$get (&DatabaseRab, 0, 0)))
if (!HtaRecord.UserNameLength) break;
if (VMSnok(status) && status != RMS$_EOF) exit (status);
if (status == RMS$_EOF)
ReuseEmptyRecord = false;
else
ReuseEmptyRecord = true;
memset (&HtaRecord, 0, sizeof(HtaRecord));
zptr = (sptr = HtaRecord.UserName) + sizeof(HtaRecord.UserName);
for (cptr = UserNamePtr; *cptr && sptr < zptr; *sptr++ = toupper(*cptr++));
*sptr = '\0';
HtaRecord.UserNameLength = sptr - HtaRecord.UserName;
if (FullNamePtr)
{
zptr = (sptr = HtaRecord.FullName) + sizeof(HtaRecord.FullName)-1;
for (cptr = FullNamePtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
}
if (ContactPtr)
{
zptr = (sptr = HtaRecord.Contact) + sizeof(HtaRecord.Contact)-1;
for (cptr = ContactPtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
}
if (EmailPtr)
{
zptr = (sptr = HtaRecord.Email) + sizeof(HtaRecord.Email)-1;
for (cptr = EmailPtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
}
/* unless otherwise specified newly created usernames have read access */
if (FlagRead || !FlagNoRead)
HtaRecord.Flags |= (AUTH_FLAG_GET | AUTH_FLAG_HEAD);
if (FlagNoRead) HtaRecord.Flags &= ~(AUTH_FLAG_GET | AUTH_FLAG_HEAD);
if (FlagWrite) HtaRecord.Flags |= (AUTH_FLAG_CONNECT | AUTH_FLAG_DELETE |
AUTH_FLAG_POST | AUTH_FLAG_PUT);
if (FlagNoWrite) HtaRecord.Flags &= ~(AUTH_FLAG_CONNECT | AUTH_FLAG_DELETE |
AUTH_FLAG_POST | AUTH_FLAG_PUT);
/* unless otherwise specified newly create usernames are enabled */
if (!FlagDisabled) HtaRecord.Flags |= AUTH_FLAG_ENABLED;
if (FlagDisabled) HtaRecord.Flags &= ~AUTH_FLAG_ENABLED;
if (FlagSslOnly) HtaRecord.Flags |= AUTH_FLAG_HTTPS_ONLY;
if (FlagNoSslOnly) HtaRecord.Flags &= ~AUTH_FLAG_HTTPS_ONLY;
if (PasswordPtr)
GetSetPassword ();
else
if (GeneratePassword)
GetSetPassword ();
else
if (GeneratePIN)
GetSetPassword ();
else
/* not specified, make the password unusable */
memset (&HtaRecord.HashedPwd, 0xaa, sizeof(HtaRecord.HashedPwd));
memcpy (&HtaRecord.AddedTime64, &Time64, 8);
DatabaseRab.rab$l_rbf = &HtaRecord;
DatabaseRab.rab$w_rsz = sizeof(HtaRecord);
if (ReuseEmptyRecord)
status = sys$update (&DatabaseRab, 0, 0);
else
status = sys$put (&DatabaseRab, 0, 0);
if (VMSok(status))
{
if (GeneratePassword)
fprintf (stdout, "%%%s-I-PASSWORD, for %s is \"%s\"\n",
Utility, UserNamePtr, PasswordPtr);
else
if (GeneratePIN)
fprintf (stdout, "%%%s-I-PIN, for %s is %s\n",
Utility, UserNamePtr, PasswordPtr);
}
exit (status);
}
/*****************************************************************************/
/*
Modify the specified field(s) and then update the current record.
*/
int DatabaseUpdateRecord ()
{
BOOL UpdateRecord;
int status;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (!UserNameLength)
{
fprintf (stdout, "%%%s-E-USERNAME, not specified\n", Utility);
exit (CLI$_INSFPRM | STS$M_INHIB_MSG);
}
DatabaseOpen (true);
status = DatabaseFindRecord ();
if (status == RMS$_EOF) exit (RMS$_RNF);
if (VMSnok (status)) exit (status);
UpdateRecord = false;
if (FullNamePtr)
{
zptr = (sptr = HtaRecord.FullName) + sizeof(HtaRecord.FullName)-1;
for (cptr = FullNamePtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
UpdateRecord = true;
}
if (ContactPtr)
{
zptr = (sptr = HtaRecord.Contact) + sizeof(HtaRecord.Contact)-1;
for (cptr = ContactPtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
UpdateRecord = true;
}
if (EmailPtr)
{
zptr = (sptr = HtaRecord.Email) + sizeof(HtaRecord.Email)-1;
for (cptr = EmailPtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
UpdateRecord = true;
}
if (FlagRead)
{
HtaRecord.Flags |= (AUTH_FLAG_GET | AUTH_FLAG_HEAD);
UpdateRecord = true;
}
if (FlagNoRead)
{
HtaRecord.Flags &= ~(AUTH_FLAG_GET | AUTH_FLAG_HEAD);
UpdateRecord = true;
}
if (FlagWrite)
{
HtaRecord.Flags |= (AUTH_FLAG_CONNECT | AUTH_FLAG_DELETE |
AUTH_FLAG_POST | AUTH_FLAG_PUT);
UpdateRecord = true;
}
if (FlagNoWrite)
{
HtaRecord.Flags &= ~(AUTH_FLAG_CONNECT | AUTH_FLAG_DELETE |
AUTH_FLAG_POST | AUTH_FLAG_PUT);
UpdateRecord = true;
}
if (FlagSslOnly)
{
HtaRecord.Flags |= AUTH_FLAG_HTTPS_ONLY;
UpdateRecord = true;
}
if (FlagNoSslOnly)
{
HtaRecord.Flags &= ~AUTH_FLAG_HTTPS_ONLY;
UpdateRecord = true;
}
if (FlagEnabled)
{
HtaRecord.Flags |= AUTH_FLAG_ENABLED;
UpdateRecord = true;
}
if (FlagDisabled)
{
HtaRecord.Flags &= ~AUTH_FLAG_ENABLED;
UpdateRecord = true;
}
if (PasswordPtr)
{
GetSetPassword ();
UpdateRecord = true;
}
else
if (GeneratePassword)
{
GetSetPassword ();
UpdateRecord = true;
}
else
if (GeneratePIN)
{
GetSetPassword ();
UpdateRecord = true;
}
if (!UpdateRecord) exit (SS$_NORMAL);
memcpy (&HtaRecord.LastChangeTime64, &Time64, 8);
HtaRecord.ChangeCount++;
DatabaseRab.rab$l_rbf = &HtaRecord;
DatabaseRab.rab$w_rsz = sizeof(HtaRecord);
status = sys$update (&DatabaseRab, 0, 0);
if (VMSok(status))
{
if (GeneratePassword)
fprintf (stdout, "%%%s-I-PASSWORD, for %s is \"%s\"\n",
Utility, UserNamePtr, PasswordPtr);
else
if (GeneratePIN)
fprintf (stdout, "%%%s-I-PIN, for %s is %s\n",
Utility, UserNamePtr, PasswordPtr);
}
exit (status);
}
/*****************************************************************************/
/*
Delete the by zeroing the content and updating the current record.
*/
int DatabaseDeleteRecord ()
{
int status;
/*********/
/* begin */
/*********/
if (!UserNameLength)
{
fprintf (stdout, "%%%s-E-USERNAME, not specified\n", Utility);
exit (CLI$_INSFPRM | STS$M_INHIB_MSG);
}
DatabaseOpen (true);
status = DatabaseFindRecord ();
if (status == RMS$_EOF) exit (RMS$_RNF);
if (VMSnok (status)) exit (status);
memset (&HtaRecord, 0, sizeof(HtaRecord));
status = sys$update (&DatabaseRab, 0, 0);
exit (status);
}
/*****************************************************************************/
/*
Sort the records (according to the /SORT= parameters) into a new version of the
same database file name, or into /OUTPUT= specification, or into record print.
*/
int DatabaseSort ()
{
static $DESCRIPTOR (DateFaoDsc, "!20%D\0");
int status,
InputRecordCount,
OutputRecordCount,
SortLrl,
SortOptions;
unsigned short ShortLength;
char *cptr;
char DateAsAt [32];
$DESCRIPTOR (DateAsAtDsc, DateAsAt);
$DESCRIPTOR (RecordDsc, "");
typedef struct
{
unsigned short type;
unsigned short order;
unsigned short offset;
unsigned short len;
} KEY_INFO;
struct
{
unsigned short num;
KEY_INFO key [1];
} SortKeys;
globalvalue int SOR$M_STABLE;
/*********/
/* begin */
/*********/
RecordDsc.dsc$a_pointer = &HtaRecord;
RecordDsc.dsc$w_length = sizeof(HtaRecord);
if (!SortUserName && !SortDate && !SortCount) SortUserName = true;
if (SortUserName)
{
SortKeys.key[0].type = DSC$K_DTYPE_T;
SortKeys.key[0].order = 0;
SortKeys.key[0].offset = 0;
SortKeys.key[0].len = AUTH_MAX_HTA_USERNAME_LENGTH;
SortKeys.num = 1;
}
else
if (SortDate)
{
if (SortAccess)
cptr = (char*)&HtaRecord.LastAccessTime64;
else
if (SortChange)
cptr = (char*)&HtaRecord.LastChangeTime64;
else
if (SortFailure)
cptr = (char*)&HtaRecord.LastFailureTime64;
else
exit (SS$_BUGCHECK);
SortKeys.key[0].type = DSC$K_DTYPE_Q;
SortKeys.key[0].order = 1;
SortKeys.key[0].offset = cptr - (char*)&HtaRecord;
SortKeys.key[0].len = 8;
SortKeys.num = 1;
}
else
if (SortCount)
{
if (SortAccess)
cptr = (char*)&HtaRecord.AccessCount;
else
if (SortChange)
cptr = (char*)&HtaRecord.ChangeCount;
else
if (SortFailure)
cptr = (char*)&HtaRecord.FailureCount;
else
exit (SS$_BUGCHECK);
SortKeys.key[0].type = DSC$K_DTYPE_LU;
SortKeys.key[0].order = 0;
SortKeys.key[0].offset = cptr - (char*)&HtaRecord;
SortKeys.key[0].len = 4;
SortKeys.num = 1;
}
else
exit (SS$_BUGCHECK);
SortOptions = SOR$M_STABLE;
SortLrl = sizeof(HtaRecord);
status = sor$begin_sort (&SortKeys, &SortLrl, &SortOptions,
0, 0, 0, 0, 0, 0);
if (VMSnok (status)) exit (status);
DatabaseOpen (false);
InputRecordCount = OutputRecordCount = 0;
while (VMSok (status = sys$get (&DatabaseRab, 0, 0)))
{
/* check the version of the authorization database */
if (HtaRecord.DatabaseVersion &&
HtaRecord.DatabaseVersion != AUTH_HTA_VERSION)
exit (SS$_INCOMPAT);
if (!HtaRecord.UserNameLength) continue;
/* seems a bit heavy-handed for a single record but simplifies code */
if (UserNamePtr)
if (!strsame (UserNamePtr, HtaRecord.UserName, -1))
continue;
status = sor$release_rec (&RecordDsc, 0);
if (VMSnok (status)) exit (status);
InputRecordCount++;
}
sys$close (&DatabaseFab, 0, 0);
if (ListDatabase)
{
if (OutputPtr && OutputPtr[0])
if (!(stdout = freopen (OutputPtr, "w", stdout)))
exit (vaxc$errno);
if (!ListCsv && !ListFull) ListBrief = true;
if (ListFull)
{
sys$fao (&DateFaoDsc, NULL, &DateAsAtDsc, 0);
fprintf (stdout,
"\n\
%s as at %s\n\
%-*s %-*s %-10s %s\n\
%-20s %-29s %-29s %-29s\n\
-----------------------------------------------------------\
-----------------------------------------------------------\n\
",
ExpFileName, DateAsAt,
AUTH_MAX_HTA_USERNAME_LENGTH,
"User Name",
AUTH_MAX_FULLNAME_LENGTH,
"Full Name",
"Access",
"Status",
"Added",
"Modified/Last",
"Accessed/Last",
"Failed/Last");
}
}
if (InputRecordCount)
{
status = sor$sort_merge (0);
if (VMSnok (status)) exit (status);
if (ListDatabase)
{
for (;;)
{
status = sor$return_rec (&RecordDsc, &ShortLength, 0);
if (status == SS$_ENDOFFILE) break;
if (VMSnok (status)) exit (status);
DatabasePrintRecord (++OutputRecordCount);
}
}
else
{
if (OutputPtr && OutputPtr[0])
DatabaseCreate (OutputPtr, true);
else
DatabaseCreate (DatabaseNamePtr, true);
/* construct a RAB and connect to the just-created database file */
DatabaseRab = cc$rms_rab;
DatabaseRab.rab$l_fab = &DatabaseFab;
DatabaseRab.rab$l_rbf = &HtaRecord;
DatabaseRab.rab$w_rsz = sizeof(HtaRecord);
status = sys$connect (&DatabaseRab, 0, 0);
if (VMSnok (status)) exit (status);
for (;;)
{
status = sor$return_rec (&RecordDsc, &ShortLength, 0);
if (status == SS$_ENDOFFILE) break;
if (VMSnok (status)) exit (status);
OutputRecordCount++;
status = sys$put (&DatabaseRab, 0, 0);
if (VMSnok (status)) exit (status);
}
sys$close (&DatabaseFab, 0, 0);
}
}
if (ListDatabase)
{
if (ListFull)
fputs ("\
----------------------------------------------------------\
-----------------------------------------------------------\n\
\n",
stdout);
}
status = sor$end_sort (0);
if (VMSnok (status)) exit (status);
if (InputRecordCount != OutputRecordCount) exit (SS$_BUGCHECK);
}
/*****************************************************************************/
/*
Print a single record.
*/
DatabasePrintRecord (int RecordCount)
{
static $DESCRIPTOR (DateFaoDsc, "!20%D\0");
int status;
char *cptr,
*AccessPtr,
*NonePtr;
char DateAdded [32],
DateLastAccess [32],
DateLastChange [32],
DateLastFailure [32];
$DESCRIPTOR (DateAddedDsc, DateAdded);
$DESCRIPTOR (DateLastAccessDsc, DateLastAccess);
$DESCRIPTOR (DateLastChangeDsc, DateLastChange);
$DESCRIPTOR (DateLastFailureDsc, DateLastFailure);
/*********/
/* begin */
/*********/
if (ListCsv) NonePtr = ""; else NonePtr = "(none)";
if (HtaRecord.AddedTime64[0] || HtaRecord.AddedTime64[1])
{
sys$fao (&DateFaoDsc, NULL, &DateAddedDsc,
&HtaRecord.AddedTime64);
if (DateAdded[0] == ' ') DateAdded[0] = '0';
}
else
strcpy (DateAdded, NonePtr);
if (HtaRecord.LastChangeTime64[0] || HtaRecord.LastChangeTime64[1])
{
sys$fao (&DateFaoDsc, NULL, &DateLastChangeDsc,
&HtaRecord.LastChangeTime64);
if (DateLastChange[0] == ' ') DateLastChange[0] = '0';
}
else
strcpy (DateLastChange, NonePtr);
if (HtaRecord.LastAccessTime64[0] || HtaRecord.LastAccessTime64[1])
{
sys$fao (&DateFaoDsc, NULL, &DateLastAccessDsc,
&HtaRecord.LastAccessTime64);
if (DateLastAccess[0] == ' ') DateLastAccess[0] = '0';
}
else
strcpy (DateLastAccess, NonePtr);
if (HtaRecord.LastFailureTime64[0] || HtaRecord.LastFailureTime64[1])
{
sys$fao (&DateFaoDsc, NULL, &DateLastFailureDsc,
&HtaRecord.LastFailureTime64);
if (DateLastFailure[0] == ' ') DateLastFailure[0] = '0';
}
else
strcpy (DateLastFailure, NonePtr);
if (HtaRecord.Flags & AUTH_FLAG_GET &&
HtaRecord.Flags & AUTH_FLAG_POST)
AccessPtr = "read+write";
else
if (HtaRecord.Flags & AUTH_FLAG_GET)
AccessPtr = "read";
else
if (HtaRecord.Flags & AUTH_FLAG_POST)
AccessPtr = "write";
else
AccessPtr = "none";
if (ListBrief)
fprintf (stdout, "%04.04d %-*s %-*s %-10s %s\n",
RecordCount,
AUTH_MAX_HTA_USERNAME_LENGTH,
HtaRecord.UserName,
AUTH_MAX_FULLNAME_LENGTH,
HtaRecord.FullName,
AccessPtr,
HtaRecord.Flags & AUTH_FLAG_ENABLED ?
"enabled" : "disabled");
else
if (ListFull)
{
fprintf (stdout, "%04.04d %-*s %-*s %-10s %s%s\n",
RecordCount,
AUTH_MAX_HTA_USERNAME_LENGTH,
HtaRecord.UserName,
AUTH_MAX_FULLNAME_LENGTH,
HtaRecord.FullName,
AccessPtr,
HtaRecord.Flags & AUTH_FLAG_ENABLED ?
"enabled" : "disabled",
HtaRecord.Flags & AUTH_FLAG_HTTPS_ONLY ?
" SSL-only" : "");
if (HtaRecord.Contact[0])
{
/* massage contact newlines into TABs */
for (cptr = HtaRecord.Contact; *cptr; cptr++)
{
if (*cptr == '\r') *cptr = ' ';
if (*cptr == '\n') *cptr = '\t';
}
fprintf (stdout, " %s\n", HtaRecord.Contact);
}
if (HtaRecord.Email[0])
fprintf (stdout, " %s\n", HtaRecord.Email);
if (!HtaRecord.Contact[0] && !HtaRecord.Email[0])
fprintf (stdout, " (no contact or email)\n");
fprintf (stdout, " %-20s %7d %-20s %7d %-20s %7d %-20s\n",
DateAdded, HtaRecord.ChangeCount, DateLastChange,
HtaRecord.AccessCount, DateLastAccess,
HtaRecord.FailureCount, DateLastFailure);
}
else
if (ListCsv)
{
if (!isprint(CsvChar) && CsvChar != '\t') CsvChar = ',';
for (cptr = HtaRecord.FullName; *cptr; cptr++)
if (*cptr == CsvChar) *cptr = ' ';
/* massage contact newlines into TABs */
for (cptr = HtaRecord.Contact; *cptr; cptr++)
{
if (*cptr == '\r') *cptr = ' ';
if (*cptr == '\n') *cptr = '\t';
if (*cptr == CsvChar) *cptr = ' ';
}
for (cptr = HtaRecord.Email; *cptr; cptr++)
if (*cptr == CsvChar) *cptr = ' ';
fprintf (stdout,
"%d%c%s%c%s%c%s%c%s%c%s%c%s%c%s%c%s%c%d%c%s%c%d%c%s%c%d%c%s\n",
RecordCount,
CsvChar,
HtaRecord.UserName,
CsvChar,
HtaRecord.FullName,
CsvChar,
HtaRecord.Contact,
CsvChar,
HtaRecord.Email,
CsvChar,
AccessPtr,
CsvChar,
HtaRecord.Flags & AUTH_FLAG_ENABLED ?
"enabled" : "disabled",
CsvChar,
HtaRecord.Flags & AUTH_FLAG_HTTPS_ONLY ?
"SSL-only" : "",
CsvChar,
DateAdded,
CsvChar,
HtaRecord.ChangeCount,
CsvChar,
DateLastChange,
CsvChar,
HtaRecord.AccessCount,
CsvChar,
DateLastAccess,
CsvChar,
HtaRecord.FailureCount,
CsvChar,
DateLastFailure);
}
}
/*****************************************************************************/
/*
Search from start to finish for the CLI-specified username, Leaves record
positioned for update and returns normal when found, EOF if not found.
*/
int DatabaseFindRecord ()
{
int status;
/*********/
/* begin */
/*********/
if (!UserNameLength) exit (SS$_BUGCHECK);
while (VMSok (status = sys$get (&DatabaseRab, 0, 0)))
{
/* check the version of the authorization database */
if (HtaRecord.DatabaseVersion &&
HtaRecord.DatabaseVersion != AUTH_HTA_VERSION)
exit (SS$_INCOMPAT);
if (HtaRecord.UserNameLength != UserNameLength) continue;
if (strsame (UserNamePtr, HtaRecord.UserName, -1)) return (SS$_NORMAL);
}
return (status);
}
/*****************************************************************************/
/*
Open and connect to the database file for either read or write.
*/
int DatabaseOpen (BOOL ForWrite)
{
int status;
/*********/
/* begin */
/*********/
if (!DatabaseNamePtr || !DatabaseNamePtr[0]) exit (CLI$_INSFPRM);
DatabaseFab = cc$rms_fab;
DatabaseFab.fab$l_fna = DatabaseNamePtr;
DatabaseFab.fab$b_fns = strlen(DatabaseNamePtr);
DatabaseFab.fab$l_dna = HTA_FILE_TYPE;
DatabaseFab.fab$b_dns = strlen(HTA_FILE_TYPE);
DatabaseFab.fab$l_nam = &DatabaseNam;
if (ForWrite)
DatabaseFab.fab$b_fac = FAB$M_GET | FAB$M_PUT | FAB$M_UPD;
else
DatabaseFab.fab$b_fac = FAB$M_GET;
DatabaseFab.fab$b_shr = FAB$M_SHRGET | FAB$M_SHRPUT | FAB$M_SHRUPD;
DatabaseNam = cc$rms_nam;
DatabaseNam.nam$l_esa = ExpFileName;
DatabaseNam.nam$b_ess = sizeof(ExpFileName)-1;
status = sys$open (&DatabaseFab, 0, 0);
if (VMSnok (status)) exit (status);
DatabaseRab = cc$rms_rab;
DatabaseRab.rab$l_fab = &DatabaseFab;
/* 2 buffers of sixty-four blocks (records) each */
DatabaseRab.rab$b_mbc = 64;
DatabaseRab.rab$b_mbf = 2;
/* read ahead performance option, read regardless of lock */
DatabaseRab.rab$l_rop = RAB$M_RAH | RAB$M_RRL;
DatabaseRab.rab$l_ubf = &HtaRecord;
DatabaseRab.rab$w_usz = sizeof(HtaRecord);
status = sys$connect (&DatabaseRab, 0, 0);
if (VMSnok (status)) exit (status);
return (status);
}
/*****************************************************************************/
/*
Create the specified database. If 'NewVersion' is false then check if the file
exists andreport the error if it does. If true the a later version will be
created if it already exists.
*/
DatabaseCreate
(
char *DatabaseName,
BOOL NewVersion
)
{
int status;
/*********/
/* begin */
/*********/
DatabaseFab = cc$rms_fab;
DatabaseFab.fab$l_fna = DatabaseName;
DatabaseFab.fab$b_fns = strlen(DatabaseName);
DatabaseFab.fab$l_dna = HTA_FILE_TYPE;
DatabaseFab.fab$b_dns = strlen(HTA_FILE_TYPE);
DatabaseFab.fab$l_nam = &DatabaseNam;
DatabaseNam = cc$rms_nam;
DatabaseNam.nam$l_esa = ExpFileName;
DatabaseNam.nam$b_ess = sizeof(ExpFileName)-1;
status = sys$parse (&DatabaseFab, 0, 0);
if (VMSnok (status)) exit (status);
if (!NewVersion)
{
status = sys$search (&DatabaseFab, 0, 0);
if (VMSnok (status) && status != RMS$_FNF) exit (status);
if (status != RMS$_FNF) exit (RMS$_FEX);
}
/* OK, now carefully adjust some of the data in the RMS structures */
DatabaseFab.fab$b_fac = FAB$M_GET | FAB$M_PUT | FAB$M_UPD;
DatabaseFab.fab$l_fop = FAB$M_SQO;
DatabaseFab.fab$w_mrs = sizeof(HtaRecord);
DatabaseFab.fab$b_rfm = FAB$C_FIX;
DatabaseFab.fab$b_shr = FAB$M_SHRGET | FAB$M_SHRPUT | FAB$M_SHRUPD;
DatabaseFab.fab$l_xab = &DatabaseXabPro;
DatabaseXabPro = cc$rms_xabpro;
DatabaseXabPro.xab$l_nxt = 0;
/* w:,g:,o:rwed,s:rwed */
DatabaseXabPro.xab$w_pro = 0xff00;
status = sys$create (&DatabaseFab, 0, 0);
if (VMSnok (status)) exit (status);
}
/*****************************************************************************/
/*
Delete the specified database.
*/
DatabaseDelete ()
{
int cnt, status;
/*********/
/* begin */
/*********/
if (!DatabaseNamePtr || !DatabaseNamePtr[0]) exit (CLI$_INSFPRM);
if (!CommandConfirmed)
{
fprintf (stdout,
"%%%s-E-DELETE, confirm database deletion using /CONFIRM\n",
Utility);
exit (CLI$_INSFPRM | STS$M_INHIB_MSG);
}
DatabaseFab = cc$rms_fab;
DatabaseFab.fab$l_fna = DatabaseNamePtr;
DatabaseFab.fab$b_fns = strlen(DatabaseNamePtr);
DatabaseFab.fab$l_dna = HTA_FILE_TYPE;
DatabaseFab.fab$b_dns = strlen(HTA_FILE_TYPE);
DatabaseFab.fab$l_nam = &DatabaseNam;
DatabaseNam = cc$rms_nam;
DatabaseNam.nam$l_esa = ExpFileName;
DatabaseNam.nam$b_ess = sizeof(ExpFileName)-1;
status = sys$parse (&DatabaseFab, 0, 0);
if (VMSnok (status)) exit (status);
status = sys$search (&DatabaseFab, 0, 0);
if (VMSnok (status)) exit (status);
cnt = 0;
while (VMSok (status = sys$erase (&DatabaseFab, 0, 0))) cnt++;
if (status == RMS$_FNF && cnt) status = SS$_NORMAL;
exit (status);
}
/*****************************************************************************/
/*
If a /PASSWORD=<string> has not been supplied at the CLI then prompt for a
non-echoed password and confirmation. Hash the password string into the
record's quadword hashed password.
*/
int GetSetPassword ()
{
static char Passwd1 [64],
Passwd2 [64];
int cnt, status;
char *cptr, *sptr;
MD5_HASH Md5Hash;
$DESCRIPTOR (PasswordDsc, "");
$DESCRIPTOR (UserNameDsc, "");
/*********/
/* begin */
/*********/
if (GeneratePassword)
{
/* generate a six alpha-numeric character password */
Md5Digest (&Time64, sizeof(Md5Hash), &Md5Hash);
cptr = (char*)&Md5Hash;
sptr = PasswordPtr = Passwd1;
cnt = 0;
while (cnt < 6)
{
if (cptr > (char*)&Md5Hash + sizeof(Md5Hash))
{
Md5Digest (&Md5Hash, sizeof(Md5Hash), &Md5Hash);
cptr = (char*)&Md5Hash;
}
*cptr = tolower(*cptr);
if (cnt == 5)
{
/* digit required */
if (*cptr >= '0' && *cptr <= '9')
{
*sptr++ = *cptr;
cnt++;
}
}
else
if (*cptr == 'a' || *cptr == 'e' || *cptr == 'i' ||
*cptr == 'o' || *cptr == 'u' || *cptr == 'y')
{
if (cnt % 2)
{
/* vowel required */
*sptr++ = *cptr;
cnt++;
}
}
else
if (*cptr >= 'a' && *cptr <= 'z' &&
*cptr != 'a' && *cptr != 'e' && *cptr != 'i' &&
*cptr != 'o' && *cptr != 'u' && *cptr != 'y')
{
if (!(cnt % 2))
{
/* consonant required */
*sptr++ = *cptr;
cnt++;
}
}
cptr++;
}
*sptr = '\0';
}
else
if (GeneratePIN)
{
/* generate a four-digit PIN */
sprintf (PasswordPtr = Passwd1, "%04.04d",
Time64[0] / 1000 % 10000);
}
else
if (!PasswordPtr || !PasswordPtr[0])
{
/* read password from user (without echo) */
Passwd1[0] = Passwd2[0] = '\0';
stdin = freopen ("SYS$INPUT", "r", stdin,
"ctx=rec", "rop=rne", "rop=tmo", "tmo=30");
if (!stdin) exit (vaxc$errno);
fprintf (stdout, "Enter password []: ");
fgets (Passwd1, sizeof(Passwd1), stdin);
fputc ('\n', stdout);
Passwd1 [sizeof(Passwd1)-1] = '\0';
if (!Passwd1[0]) exit (RMS$_TMO);
if (Passwd1[0]) Passwd1 [strlen(Passwd1)-1] = '\0';
if (!Passwd1[0]) exit (SS$_NORMAL);
fprintf (stdout, "Confirm password []: ");
fgets (Passwd2, sizeof(Passwd2), stdin);
fputc ('\n', stdout);
if (!Passwd2[0]) exit (RMS$_TMO);
Passwd2 [sizeof(Passwd2)-1] = '\0';
if (Passwd2[0]) Passwd2 [strlen(Passwd2)-1] = '\0';
if (!Passwd2[0]) exit (SS$_NORMAL);
if (!strsame (Passwd1, Passwd2, -1))
{
fprintf (stdout, "%%%s-E-PASSWORD, not confirmed\n", Utility);
exit (CLI$_INSFPRM | STS$M_INHIB_MSG);
}
PasswordPtr = Passwd1;
}
if (!(isdigit(PasswordPtr[0]) &&
isdigit(PasswordPtr[1]) &&
isdigit(PasswordPtr[2]) &&
isdigit(PasswordPtr[3]) &&
!PasswordPtr[4]) &&
strlen(PasswordPtr) < AUTH_MIN_PASSWORD)
{
/* not a four-digit PIN and less than the required characters */
fprintf (stdout, "%%%s-E-PASSWORD, too short\n", Utility);
exit (CLI$_INSFPRM | STS$M_INHIB_MSG);
}
/* force password to upper-case */
for (cptr = PasswordPtr; *cptr; cptr++) *cptr = toupper(*cptr);
PasswordDsc.dsc$a_pointer = PasswordPtr;
PasswordDsc.dsc$w_length = strlen(PasswordPtr);
UserNameDsc.dsc$a_pointer = UserNamePtr;
UserNameDsc.dsc$w_length = strlen(UserNamePtr);
memset (&HtaRecord.HashedPwd, 0, sizeof(HtaRecord.HashedPwd));
status = sys$hash_password (&PasswordDsc, UAI$C_PURDY_S, 0,
&UserNameDsc, &HtaRecord.HashedPwd);
if (VMSnok (status)) exit (status);
}
/*****************************************************************************/
/*
Get "command-line" parameters, whether from the command-line or from a
configuration symbol or logical containing the equivalent.
*/
GetParameters ()
{
static char CommandLine [256];
static unsigned long Flags = 0;
int status;
unsigned short Length;
char ch;
char *aptr, *cptr, *clptr, *sptr;
$DESCRIPTOR (CommandLineDsc, CommandLine);
/*********/
/* begin */
/*********/
if (!(clptr = getenv ("HTADMIN$PARAM")))
{
/* get the entire command line following the verb */
if (VMSnok (status =
lib$get_foreign (&CommandLineDsc, 0, &Length, &Flags)))
exit (status);
(clptr = CommandLine)[Length] = '\0';
}
aptr = NULL;
ch = *clptr;
for (;;)
{
if (aptr && *aptr == '/') *aptr = '\0';
if (!ch) break;
*clptr = ch;
while (*clptr && isspace(*clptr)) *clptr++ = '\0';
aptr = clptr;
if (*clptr == '/') clptr++;
while (*clptr && !isspace (*clptr) && *clptr != '/')
{
if (*clptr != '\"')
{
clptr++;
continue;
}
cptr = clptr;
clptr++;
while (*clptr)
{
if (*clptr == '\"')
if (*(clptr+1) == '\"')
clptr++;
else
break;
*cptr++ = *clptr++;
}
*cptr = '\0';
if (*clptr) clptr++;
}
ch = *clptr;
if (*clptr) *clptr = '\0';
if (!*aptr) continue;
if (strsame (aptr, "/ADD", 4))
{
AddUserName = true;
continue;
}
if (strsame (aptr, "/CONFIRM", 5))
{
CommandConfirmed = true;
continue;
}
if (strsame (aptr, "/CONTACT=", 5))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
ContactPtr = cptr;
continue;
}
if (strsame (aptr, "/CREATE", 4))
{
CreateDatabase = true;
continue;
}
if (strsame (aptr, "/CSV=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
ListCsv = true;
if (strsame (cptr, "TAB", -1))
CsvChar = '\t';
else
CsvChar = *cptr;
continue;
}
if (strsame (aptr, "/DATABASE=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
DatabaseNamePtr = cptr;
continue;
}
if (strsame (aptr, "/DELETE", 4))
{
DeleteUserName = DeleteDatabase = true;
continue;
}
if (strsame (aptr, "/DISABLED", 4))
{
FlagDisabled = true;
continue;
}
if (strsame (aptr, "/EMAIL=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
EmailPtr = cptr;
continue;
}
if (strsame (aptr, "/ENABLED", 4))
{
FlagEnabled = true;
continue;
}
if (strsame (aptr, "/FULL", 4))
{
ListFull = true;
continue;
}
if (strsame (aptr, "/GENERATE", 4))
{
GeneratePassword = true;
continue;
}
if (strsame (aptr, "/HELP", 4))
{
ShowHelp ();
exit (SS$_NORMAL);
}
if (strsame (aptr, "/HTTPS", 4))
{
FlagSslOnly = true;
continue;
}
if (strsame (aptr, "/NOHTTPS", 6))
{
FlagNoSslOnly = true;
continue;
}
if (strsame (aptr, "/LIST", 4))
{
ListDatabase = true;
continue;
}
if (strsame (aptr, "/MODIFY", 4))
{
UpdateUserName = true;
continue;
}
if (strsame (aptr, "/NAME=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
FullNamePtr = cptr;
continue;
}
if (strsame (aptr, "/OUTPUT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
OutputPtr = cptr;
continue;
}
if (strsame (aptr, "/PASSWORD=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
PasswordPtr = cptr;
continue;
}
if (strsame (aptr, "/PIN", 4))
{
GeneratePIN = true;
continue;
}
if (strsame (aptr, "/READ", 4))
{
FlagRead = true;
continue;
}
if (strsame (aptr, "/NOREAD", 6))
{
FlagNoRead = true;
continue;
}
if (strsame (aptr, "/SORT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
SortDatabase = true;
if (strsame (cptr, "COUNT", 4))
SortCount = true;
else
if (strsame (cptr, "DATE", 4))
SortDate = true;
else
if (strsame (cptr, "USERNAME", 4))
{
SortUserName = true;
continue;
}
else
if (*cptr)
{
fprintf (stdout, "%%%s-E-IVKEYW, unrecognized keyword\n \\%s\\\n",
Utility, cptr);
exit (CLI$_IVKEYW | STS$M_INHIB_MSG);
}
else
SortUserName = true;
while (*cptr && *cptr != '=') cptr++;
if (*cptr) cptr++;
if (strsame (cptr, "ACCESS", 5))
SortAccess = true;
else
if (strsame (cptr, "CHANGE", 5) ||
strsame (cptr, "MODIFY", 5))
SortChange = true;
else
if (strsame (cptr, "FAILURE", 5))
SortFailure = true;
else
if (*cptr)
{
fprintf (stdout, "%%%s-E-IVKEYW, unrecognized keyword\n \\%s\\\n",
Utility, cptr);
exit (CLI$_IVKEYW | STS$M_INHIB_MSG);
}
else
SortAccess = true;
continue;
}
if (strsame (aptr, "/SSL", 4))
{
FlagSslOnly = true;
continue;
}
if (strsame (aptr, "/NOSSL", 6))
{
FlagNoSslOnly = true;
continue;
}
if (strsame (aptr, "/WRITE", 4))
{
FlagWrite = true;
continue;
}
if (strsame (aptr, "/NOWRITE", 6))
{
FlagNoWrite = true;
continue;
}
if (strsame (aptr, "/UPDATE", 4))
{
UpdateUserName = true;
continue;
}
if (strsame (aptr, "/USER=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
/* force username to upper-case */
for (UserNamePtr = cptr; *cptr; cptr++) *cptr = toupper(*cptr);
continue;
}
if (strsame (aptr, "/VERSION", 4))
{
fprintf (stdout, "%%%s-I-VERSION, %s\n%s",
Utility, SOFTWAREID, Copyright);
exit (SS$_NORMAL);
}
if (*aptr == '/')
{
fprintf (stdout, "%%%s-E-IVQUAL, unrecognized qualifier\n \\%s\\\n",
Utility, aptr+1);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
if (!DatabaseNamePtr)
{
DatabaseNamePtr = aptr;
for (cptr = aptr; *cptr; cptr++) *cptr = toupper(*cptr);
continue;
}
if (!UserNamePtr)
{
UserNamePtr = aptr;
for (cptr = aptr; *cptr; cptr++) *cptr = toupper(*cptr);
continue;
}
fprintf (stdout, "%%%s-E-MAXPARM, too many parameters\n \\%s\\\n",
Utility, aptr);
exit (CLI$_MAXPARM | STS$M_INHIB_MSG);
}
}
/****************************************************************************/
/*
Does a case-insensitive, character-by-character string compare and returns
true if two strings are the same, or false if not. If a maximum number of
characters are specified only those will be compared, if the entire strings
should be compared then specify the number of characters as 0.
*/
BOOL strsame
(
char *sptr1,
char *sptr2,
int count
)
{
/*********/
/* begin */
/*********/
while (*sptr1 && *sptr2)
{
if (tolower(*sptr1++) != tolower(*sptr2++)) return (false);
if (count)
if (!--count) return (true);
}
if (*sptr1 || *sptr2)
return (false);
else
return (true);
}
/*****************************************************************************/
/*
*/
int ShowHelp ()
{
fprintf (stdout,
"Usage for HTADMIN Utility (%s)\n\
\n\
$ HTADMIN <database> [<username>] [<qualifiers>]\n\
\n\
Allows command-line administration of WASD .$HTA authorization databases.\n\
\n\
/ADD /CONFIRM /CONTACT=\"<string>\" /CREATE /CSV[=TAB|char] /DATABASE=<name>\n\
/DELETE /DISABLED /EMAIL=\"<string>\" /ENABLED /FULL /GENERATE /HELP /[NO]HTTPS\n\
/LIST /MODIFY /NAME=\"<string>\" /OUTPUT=<filename> /PASSWORD[=<string>] /PIN\n\
/[NO]READ /SORT[=<parameter>] /[NO]SSL /[NO]WRITE /UPDATE /USER=<name> /VERSION\n\
\n\
$ HTADMIN EXAMPLE !brief list of the EXAMPLE database records\n\
$ HTADMIN EXAMPLE /FULL !full (132 column) listing\n\
$ HTADMIN EXAMPLE /CSV !comma-separated value listing\n\
$ HTADMIN EXAMPLE DANIEL !full listing of record DANIEL\n\
$ HTADMIN EXAMPLE DANIEL /ADD /NAME=\"Mark Daniel\" !add a new record\n\
$ HTADMIN EXAMPLE DANIEL /UPDATE /EMAIL=\"Mark.Daniel@vsm.com.au\"\n\
$ HTADMIN EXAMPLE DANIEL /UPDATE /READ /WRITE !change user access\n\
$ HTADMIN EXAMPLE DANIEL /UPDATE /PASSWORD !prompts for password\n\
$ HTADMIN EXAMPLE DANIEL /DELETE !delete the record\n\
$ HTADMIN EXAMPLE /CREATE !create a new database\n\
$ HTADMIN EXAMPLE /DELETE /CONFIRM !delete the database\n\
\n",
SOFTWAREID);
return (SS$_NORMAL);
}
/****************************************************************************/