[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]
/*****************************************************************************/
/*
msg.c
Provide a site-configurable message database. This is particularly directed
towards non-English language sites. No attempt has been made to completely
internationalize the server, only messages the average client is likely to be
exposed to are currently provided.
The only way of reloading the database is to restart the server. This is not
of great concern for once customized the messages should remain completely
stable between releases.
When multiple languages are configured the message language processing may be
observed using the WATCH response-header item.
MULTIPLE LANGUAGE SPECIFICATIONS
--------------------------------
Multiple language messages can be specified in two ways:
1) within the one file
2) in multiple files specified by a multivalued logical name
Within The One File
~~~~~~~~~~~~~~~~~~~
Language availability is specified through the use of [Language] directives.
These must be numbered from 1 to the count of those supplied. The highest
numbered language must have the complete set of messages for this is the
fallback when obtaining any message (this would normally be 'en'). The
[Language] may be specified as a comma-separated list of equivalent or similar
specifications, which during request processing will be matched against a
client specified list of accepted-languages one at a time in specified order.
A wildcard may be specified which matches all fitting the template. In this
manner a single language can be used also to match minor variants or language
specification synonyms.
[Version] 9.0
[Language] 1 es,es-ES
[Language] 2 de,de-*
[Language] 3 en
In the above (rather contrived) example a client request with
Accept-Language: es-ES,de;q=0.6,en;q=0.3
would have language 1 selected, a client with
Accept-Language: de-ch,es;q=0.6,en;q=0.3
language 2 selected, with
Accept-Language: pt-br,de;q=0.6,en;q=0.3
also language 2 selected, with
Accept-Language: pt
language 3 (the default) selected, etc.
Note that the messages for each language must use the *first* language
specification provided in the [Language] list. In the example above all
messages for language 1 would be introduced using 'es', for language 2 with
'de' and for language 3 with 'en'.
Multiple Files - Multivalued Logical Name
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
With this approach a logical name containing multiple file names is defined
(more commonly described as a logical search list). The final file specified
must contain the full message set. Files specified prior to this, can contain
as many or as few of the full set as is desired. A [Language] number does not
need to be specified as they are processed in the order the logical name
specifies them in. Other language file directives are required.
The following is an example of a logical name providing the same three
languages in the examples above.
$ DEFINE /SYSTEM WASD_CONFIG_MSG WASD_ROOT:[LOCAL]HTTPD$MSG_ES.CONF, -
WASD_ROOT:[LOCAL]HTTPD$MSG_DE.CONF, -
WASD_ROOT:[LOCAL]HTTPD$MSG.CONF
The file contents would be as follows (very contrived examples :-)
# HTTPD$MSG_ES.CONF
[Version] 9.0
[Language] 0 es,es-ES
[auth]
es 01 Habla Espanol
es 02 Habla Inglesi
[dir]
es 03 Habla Espanol
es 04 Habla Inglesi
# HTTPD$MSG_DE.CONF
[Version] 9.0
[Language] 0 de,de-*
[auth]
de 01 Sprechen Sie Deutsches
de 02 Sprechen Sie Englisch
[dir]
de 03 Sprechen Sie Deutsches
de 04 Sprechen Sie Englisch
# HTTPD$MSG.CONF
[Version] 9.0
[Language] 0 en
[auth]
.
.
.(full set of messages)
The major ADVANTAGE of maintaining multiple files in this way is there is no
need to MERGE files when a new revision is required. Just update the version
number and add any new required messages to the existing secondary file.
messages to the existing
ADDITIONAL [LANGUAGE] PARAMETERS
--------------------------------
Two optional parameters can follow the language number and language
specification synonym. The first is a character set to be associated with the
message set. This is specified using the keyword 'charset=' followed by the
character set specification. For example
[Language] 2 charset=ISO-8859-5
The second optional parameter is a comma-separated list of host domain
specifications that the message set can be associated with. If there is no
"Accept-Language:" list associated with the request then this information will
be used to select the message set. For example
[Language] 2 charset=ISO-8859-5 hosts=cz,cz-*
CURRENT MESSAGE GROUPINGS
-------------------------
[auth] authentication/authorization
[dir] directory listing
[general] messages belonging to no particular module or category
[htadmin] authentication database administration
[http] http status messages
[mapping] mapping rules
[proxy] proxy module
[put] PUT/POST module
[request] request acceptance and initial parsing
[script] DCL/scripting module
[ssi] Server Side Includes
[status] error and other status reporting
[upd] update module
VERSION HISTORY
---------------
06-JUL-2016 MGD MsgConfigLoadCallback() make [ismap] optional
10-APR-2016 MGD [ismap] is now obsolete but retained to not break msg files
10-JUN-2010 MGD bugfix; allow METACON_TOKEN_INCLUDE for [IncludeFile]
04-MAR-2005 MGD allow WASD_CONFIG_MSG to be a logical search list to support
multiple, independent language files (also see METACON.C)
05-SEP-2003 MGD optional 'charset=<string>' [language] parameter
15-AUG-2003 MGD where CDATA constraints make using entity impossible
use a field name of hidden$lf and ^ substituted for it
04-APR-2003 MGD wildcard and comma-separated list of languages
can be specified (e.g. "[Language] es-ES,es,es-*")
12-OCT-2002 MGD refine metacon reporting
31-MAR-2002 MGD MsgForNoRequest() no longer required
22-JAN-2002 MGD bugfix; MsgFor() Accept-Lang: comparison (jpp@esme.fr)
29-SEP-2001 MGD instance support
15-SEP-2001 MGD meta-config
04-AUG-2001 MGD support module WATCHing
28-FEB-2001 MGD OdsLoadTextFile(), OdsParseTextFile(), [IncludeFile]
18-JUN-2000 MGD add MsgRevise()
08-APR-2000 MGD HTTP status messages, v7.0
04-MAR-2000 MGD use FaolToBuffer(), et.al.
02-JAN-2000 MGD config file opened via ODS module
04-DEC-1999 MGD additional messages for v6.1
05-MAY-1999 MGD proxy messages, v6.0
06-JUL-1998 MGD bugfix; MsgUnload(), VmFree() of 'HostListPtr'
14-FEB-1998 MGD message file format changed from v4.4 to v5.0
25-OCT-1997 MGD changes around MsgFor() when no request structure available
09-AUG-1997 MGD initial development (HTTPd v4.4)
*/
/*****************************************************************************/
#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 <lnmdef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application related header files */
#include "wasd.h"
#define WASD_MODULE "MSG"
/******************/
/* global storage */
/******************/
char MsgNotSet [] = "INTERNAL ERROR, please notify the administrator.";
char ErrorMsgDupLangNumber [] = "Duplicate [language] number",
ErrorMsgDupMsgNumber [] = "Duplicate message number",
ErrorMsgLangDisabled [] = "[language] disabled",
ErrorMsgLangName [] = "[language] name not specified",
ErrorMsgLangNotFound [] = "[language] not found",
ErrorMsgLangNotSpecified [] = "[language] not specified",
ErrorMsgLangNumber [] = "[language] number out-of-range",
ErrorMsgLangTooMany [] = "Too many [language]s",
ErrorMsgMessageNumber [] = "Message number out-of-range",
ErrorMsgNoGroup [] = "[group-name] has not been specified",
ErrorMsgNoLangNumber [] = "No [language] number",
ErrorMsgNoLangName [] = "No [language] name",
ErrorMsgNoMessageNumber [] = "No message number",
ErrorMsgObsoleteGroup [] = "Obsolete group",
ErrorMsgTooFew [] = "Too few messages",
ErrorMsgTooMany [] = "Too many messages",
ErrorMsgUnknownGroup [] = "Unknown [group-name]",
ErrorMsgVersion [] = "Message file [version] mismatch",
ErrorMsgVersionNotChecked [] = "No [version] for checking";
MSG_META MsgMeta;
MSG_META *MsgMetaPtr;
/********************/
/* external storage */
/********************/
#ifdef DBUG
extern BOOL Debug;
#else
#define Debug 0
#endif
extern BOOL HttpdServerStartup;
extern int ToLowerCase[],
ToUpperCase[];
extern char ErrorSanityCheck[],
SoftwareID[];
extern CONFIG_STRUCT Config;
extern META_CONFIG *MetaGlobalMsgPtr;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
*/
int MsgConfigLoad (META_CONFIG **MetaConPtrPtr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "MsgConfigLoad()");
status = MetaConLoad (MetaConPtrPtr,
v10orPrev10(CONFIG_MSG_FILE_NAME,-1),
&MsgConfigLoadCallback, false, false);
if (*MetaConPtrPtr == MetaGlobalMsgPtr)
{
/* server startup */
MetaConStartupReport (MetaGlobalMsgPtr, "MSG");
if (VMSnok (status)) exit (status);
}
return (status);
}
/*****************************************************************************/
/*
Called by MetaConUnload() to free resources allocated during msg
configuration.
*/
MsgConfigUnload (META_CONFIG *mcptr)
{
int Count,
LanguageCount;
MSG_META *mmptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "MsgConfigUnload()");
mmptr = mcptr->MsgMetaPtr;
for (LanguageCount = 1;
LanguageCount <= mmptr->LanguageCount;
LanguageCount++)
{
if (mmptr->Msgs[LanguageCount])
{
for (Count = 0; Count <= MSG_RANGE; Count++)
{
/* the '\b' backspace is a sentinal, will never occur in a message */
if (mmptr->Msgs[LanguageCount]->TextPtr[Count] &&
!SAME2(mmptr->Msgs[LanguageCount]->TextPtr[Count],'\b['))
{
/* remember that MsgCreate() returns allocation plus one! */
VmFree (mmptr->Msgs[LanguageCount]->TextPtr[Count]-1, FI_LI);
}
}
if (mmptr->Msgs[LanguageCount]->CharsetPtr)
VmFree (mmptr->Msgs[LanguageCount]->CharsetPtr, FI_LI);
if (mmptr->Msgs[LanguageCount]->HostListPtr)
VmFree (mmptr->Msgs[LanguageCount]->HostListPtr, FI_LI);
VmFree (mmptr->Msgs[LanguageCount], FI_LI);
}
}
/* clean it out completely, just in case it's to be reused! */
memset (mmptr, 0, sizeof(MSG_META));
}
/*****************************************************************************/
/*
*/
BOOL MsgConfigLoadCallback (META_CONFIG *mcptr)
{
static BOOL IgnoreIsMap;
static char ProblemOverflow [] = "Storage overflow",
ProblemUsage [] = "Cannot use during message configuration";
int status,
ConfigFileIndex,
Count,
MessageNumber;
char *cptr, *sptr, *zptr;
char LanguageName [128],
StringBuffer [512];
MSG_META *mmptr;
METACON_LINE *mclptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MSG))
{
WatchThis (WATCHALL, WATCH_MOD_MSG,
"MsgConfigLoadCallback() !&F !&X",
&MsgConfigLoadCallback, mcptr);
if (WATCH_MODULE(WATCH_MOD__DETAIL))
{
mclptr = mcptr->ParsePtr;
WatchDataFormatted ("!&X !UL !UL !UL !UL !&X !&Z !&Z\n",
mclptr, mclptr->Size, mclptr->Token, mclptr->Number,
mclptr->Length, mclptr->LineDataPtr, mclptr->TextPtr,
mclptr->InlineTextPtr);
}
}
if (mcptr->LnmIndex >= mcptr->LnmCount)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
/* get a pointer to the current "line" */
mclptr = mcptr->ParsePtr;
/* if this is during server startup then set the global msg pointer */
if (HttpdServerStartup)
mmptr = mcptr->MsgMetaPtr = MsgMetaPtr = &MsgMeta;
else
/* if a report then conjure one from the singularity */
if (!mcptr->MsgMetaPtr)
mmptr = mcptr->MsgMetaPtr = VmGet (sizeof(MSG_META));
else
/* not the first time through */
mmptr = mcptr->MsgMetaPtr;
if (mclptr->Token == METACON_TOKEN_PRE)
{
/******************/
/* pre-initialize */
/******************/
mmptr->CheckedLanguages = mmptr->VersionChecked = false;
mmptr->LanguageCount = 0;
mmptr->MessageBase = -1;
mmptr->MessageCount = 0;
return (true);
}
if (mclptr->Token == METACON_TOKEN_POST)
{
/****************/
/* post-process */
/****************/
if (mcptr->LnmIndex+1 == mcptr->LnmCount)
{
if (mmptr->MessageCount < MSG_TOTAL)
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgTooFew, FI_LI);
else
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgTooFew);
}
else
if (mmptr->MessageCount > MSG_TOTAL)
{
/* technically, this shouldn't be possible! */
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgTooMany, FI_LI);
else
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgTooMany);
}
mmptr->LanguageDefault = mmptr->LanguageCount;
mmptr->SearchListCount = mcptr->LnmCount;
}
strzcpy (mmptr->Msgs[mmptr->LanguageNumber]->FileName,
mcptr->LoadReport.FileName,
sizeof(mmptr->Msgs[mmptr->LanguageNumber]->FileName));
return (true);
}
if (mclptr->Token == METACON_TOKEN_INCLUDE) return (true);
if (mclptr->Token == METACON_TOKEN_VERSION) return (true);
if (mclptr->Token != METACON_TOKEN_TEXT)
{
/* only interested in directive text */
MetaConReport (mcptr, METACON_REPORT_ERROR, ProblemUsage);
return (false);
}
/***********/
/* process */
/***********/
/* buffer the text associated with the current "line" */
zptr = (sptr = StringBuffer) + sizeof(StringBuffer);
cptr = mclptr->TextPtr;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
if (sptr >= zptr)
{
MetaConReport (mcptr, METACON_REPORT_ERROR, ProblemOverflow);
return (false);
}
if (sptr > StringBuffer)
{
sptr--;
while (sptr > StringBuffer && ISLWS(*sptr)) sptr--;
sptr++;
}
*sptr = '\0';
cptr = StringBuffer;
if (*cptr == '[')
{
if (strsame (cptr, "[version]", 9))
{
/*************/
/* [version] */
/*************/
cptr += 9;
while (*cptr && ISLWS(*cptr)) cptr++;
if (!strsame (cptr, MSG_VERSION, -1))
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgVersion, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgVersion);
return (false);
}
}
mmptr->VersionChecked = true;
return (true);
}
if (strsame (cptr, "[language]", 10))
{
/**************/
/* [language] */
/**************/
/* allow for empty [Language] generated by configuration revise */
for (sptr = cptr+10; *sptr && !isalnum(*sptr); sptr++);
if (!*sptr) return (true);
/* step over the [language] and any trailing white-space */
cptr += 10;
while (*cptr && ISLWS(*cptr)) cptr++;
/* allow a dangling "charset="/"hosts=" for on-line configuration */
if (strsame (cptr, "charset=", 8) || strsame (cptr, "hosts=", 6))
return (true);
if (mcptr->LnmCount > 1)
mmptr->LanguageCount = mcptr->LnmIndex+1;
else
mmptr->LanguageCount++;
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG,
"LANG COUNT !UL", mmptr->LanguageCount);
/* check if the number of languages specified exceeds limits */
if (mmptr->LanguageCount > MAX_LANGUAGES)
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgLangTooMany, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR,
ErrorMsgLangTooMany);
return (false);
}
}
if (mcptr->LnmCount > 1)
{
/* with a language list it's from the index of the search list */
mmptr->LanguageNumber = mcptr->LnmIndex+1;
}
else
{
if (!isdigit(*cptr))
{
/* no language number (order) has been specified */
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgNoLangNumber, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR,
ErrorMsgNoLangNumber);
return (false);
}
}
/* language number (order) */
mmptr->LanguageNumber = atol(cptr);
}
/* check if the number of languages specified exceeds limits */
if (mmptr->LanguageNumber < 0 ||
mmptr->LanguageNumber > MAX_LANGUAGES)
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgLangNumber, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgLangNumber);
return (false);
}
}
for (Count = 1; Count < mmptr->LanguageCount; Count++)
{
if (!mmptr->Msgs[Count]) continue;
if (mmptr->Msgs[Count]->LanguageNumber == mmptr->LanguageNumber)
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgDupLangNumber, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR,
ErrorMsgDupLangNumber);
return (false);
}
}
}
/* allocate memory for this new language */
mmptr->Msgs[mmptr->LanguageNumber] =
(MSG_STRUCT*)VmGet(sizeof(MSG_STRUCT));
/* set all the messages in the language to NULL */
for (Count = 0; Count <= MSG_RANGE; Count++)
mmptr->Msgs[mmptr->LanguageNumber]->TextPtr[Count] = NULL;
/* set the language number */
mmptr->Msgs[mmptr->LanguageNumber]->LanguageNumber =
mmptr->LanguageNumber;
/* get language name (start by skipping over the languge number) */
while (*cptr && isdigit(*cptr)) cptr++;
while (*cptr && ISLWS(*cptr)) cptr++;
if (!*cptr)
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgNoLangName, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgNoLangName);
return (false);
}
}
zptr = (sptr = mmptr->Msgs[mmptr->LanguageNumber]->LanguageList) +
sizeof(mmptr->Msgs[mmptr->LanguageNumber]->LanguageList);
while (*cptr && !ISLWS(*cptr) && sptr < zptr) *sptr++ = *cptr++;
if (sptr > zptr) sptr--;
*sptr = '\0';
while (*cptr && ISLWS(*cptr)) cptr++;
if (strsame (cptr, "charset=", 8))
{
/* character set for the messages */
cptr += 8;
sptr = cptr;
while (*cptr && !ISLWS(*cptr)) cptr++;
/* empty charsets are permitted to allow on-line revision */
if (cptr - sptr)
{
zptr = mmptr->Msgs[mmptr->LanguageNumber]->CharsetPtr =
VmGet (cptr-sptr+1);
memcpy (zptr, sptr, cptr-sptr);
zptr[cptr-sptr] = '\0';
}
}
while (*cptr && ISLWS(*cptr)) cptr++;
if (*cptr)
{
/* trailing host list found */
if (strsame (cptr, "hosts=", 6)) cptr += 6;
sptr = cptr;
while (*cptr) cptr++;
/* trim trailing white-space */
if (cptr > sptr) cptr--;
while (cptr > sptr && ISLWS(*cptr)) cptr--;
if (cptr > sptr) cptr++;
zptr = mmptr->Msgs[mmptr->LanguageNumber]->HostListPtr =
VmGet (cptr-sptr+1);
memcpy (zptr, sptr, cptr-sptr);
zptr[cptr-sptr] = '\0';
}
if (mmptr->Msgs[mmptr->LanguageNumber]->LanguageNumber == 0)
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgLangDisabled);
/* get (any) primary language from (any) list */
zptr = (sptr = mmptr->Msgs[mmptr->LanguageNumber]->LanguageName) +
sizeof(mmptr->Msgs[mmptr->LanguageNumber]->LanguageName)-1;
for (cptr = mmptr->Msgs[mmptr->LanguageNumber]->LanguageList;
*cptr && *cptr != ',' && sptr < zptr;
*sptr++ = *cptr++);
*sptr = '\0';
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "!UL !&Z !&Z !&Z !&Z",
mmptr->Msgs[mmptr->LanguageNumber]->LanguageNumber,
mmptr->Msgs[mmptr->LanguageNumber]->LanguageName,
mmptr->Msgs[mmptr->LanguageNumber]->LanguageList,
mmptr->Msgs[mmptr->LanguageNumber]->CharsetPtr,
mmptr->Msgs[mmptr->LanguageNumber]->HostListPtr);
return (true);
}
/****************************/
/* check language numbering */
/****************************/
if (!mmptr->CheckedLanguages)
{
mmptr->CheckedLanguages = true;
for (Count = 1; Count <= mmptr->LanguageCount; Count++)
{
if (mmptr->Msgs[Count]->LanguageNumber < 0 ||
mmptr->Msgs[Count]->LanguageNumber > mmptr->LanguageCount)
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgLangNumber, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR,
ErrorMsgLangNumber);
return (false);
}
}
}
}
/****************/
/* [group-name] */
/****************/
IgnoreIsMap = false;
/* the '\b' backspace is a sentinal, will never occur in a message */
if (strsame (cptr, "[auth]", 6))
{
mmptr->MessageBase = MSG_AUTH__BASE;
mmptr->MessageMax = MSG_AUTH__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[auth]";
}
else
if (strsame (cptr, "[dir]", 6))
{
mmptr->MessageBase = MSG_DIR__BASE;
mmptr->MessageMax = MSG_DIR__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[dir]";
}
else
if (strsame (cptr, "[general]", 9))
{
mmptr->MessageBase = MSG_GENERAL__BASE;
mmptr->MessageMax = MSG_GENERAL__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[general]";
}
else
if (strsame (cptr, "[htadmin]", 9))
{
mmptr->MessageBase = MSG_HTADMIN__BASE;
mmptr->MessageMax = MSG_HTADMIN__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[htadmin]";
}
else
if (strsame (cptr, "[http]", 6))
{
mmptr->MessageBase = MSG_HTTP__BASE;
mmptr->MessageMax = MSG_HTTP__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[http]";
}
else
if (strsame (cptr, "[ismap]", 7))
{
IgnoreIsMap = true;
MetaConReport (mcptr, METACON_REPORT_INFORM, ErrorMsgObsoleteGroup);
}
else
if (strsame (cptr, "[mapping]", 9))
{
mmptr->MessageBase = MSG_MAPPING__BASE;
mmptr->MessageMax = MSG_MAPPING__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[mapping]";
}
else
if (strsame (cptr, "[proxy]", 7))
{
mmptr->MessageBase = MSG_PROXY__BASE;
mmptr->MessageMax = MSG_PROXY__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[proxy]";
}
else
if (strsame (cptr, "[put]", 5))
{
mmptr->MessageBase = MSG_PUT__BASE;
mmptr->MessageMax = MSG_PUT__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[put]";
}
else
if (strsame (cptr, "[request]", 9))
{
mmptr->MessageBase = MSG_REQUEST__BASE;
mmptr->MessageMax = MSG_REQUEST__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[request]";
}
else
if (strsame (cptr, "[script]", 8))
{
mmptr->MessageBase = MSG_SCRIPT__BASE;
mmptr->MessageMax = MSG_SCRIPT__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[script]";
}
else
if (strsame (cptr, "[ssi]", 5))
{
mmptr->MessageBase = MSG_SSI__BASE;
mmptr->MessageMax = MSG_SSI__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[ssi]";
}
else
if (strsame (cptr, "[status]", 8))
{
mmptr->MessageBase = MSG_STATUS__BASE;
mmptr->MessageMax = MSG_STATUS__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[status]";
}
else
if (strsame (cptr, "[upd]", 5))
{
mmptr->MessageBase = MSG_UPD__BASE;
mmptr->MessageMax = MSG_UPD__MAX;
mmptr->Msgs[1]->TextPtr[mmptr->MessageBase] = "\b[upd]";
}
else
{
mmptr->MessageBase = -1;
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgUnknownGroup, FI_LI);
else
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgUnknownGroup);
}
return (true);
}
/***********/
/* message */
/***********/
if (IgnoreIsMap) return (true);
if (!mmptr->VersionChecked)
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgVersionNotChecked, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR,
ErrorMsgVersionNotChecked);
return (false);
}
}
if (!mmptr->LanguageCount)
{
if (HttpdServerStartup)
ErrorExitVmsStatus (0, ErrorMsgLangNotSpecified, FI_LI);
else
{
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgLangNotSpecified);
return (false);
}
}
if (mmptr->MessageBase < 0)
{
/* before any [goup-name] has been specified */
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgNoGroup);
return (false);
}
if (!isalpha(*cptr))
{
/* language name is not being specified at start of line */
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgNoLangName);
return (false);
}
zptr = (sptr = LanguageName) + sizeof(LanguageName)-1;
while (*cptr && !ISLWS(*cptr) && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
/* find the index for the specified (perhaps leading) language */
for (Count = 1; Count <= mmptr->LanguageCount; Count++)
{
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "!UL !&Z !&Z",
Count, LanguageName,
mmptr->Msgs[mmptr->LanguageCount]->LanguageName);
if (strsame (LanguageName, mmptr->Msgs[Count]->LanguageName, -1))
{
mmptr->LanguageNumber = Count;
break;
}
}
if (Count > mmptr->LanguageCount)
{
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgLangNotFound);
return (false);
}
while (*cptr && !ISLWS(*cptr)) cptr++;
while (*cptr && ISLWS(*cptr)) cptr++;
if (!isdigit(*cptr))
{
/* no message number has been specified */
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgNoMessageNumber);
return (false);
}
MessageNumber = atol(cptr);
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "!UL", MessageNumber);
/* zero disables a message or whole language */
if (!MessageNumber || !mmptr->Msgs[mmptr->LanguageNumber]->LanguageNumber)
return (true);
if (MessageNumber < 0 || MessageNumber > mmptr->MessageMax)
{
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgMessageNumber);
return (false);
}
MessageNumber += mmptr->MessageBase;
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "!UL", MessageNumber);
while (*cptr && !ISLWS(*cptr)) cptr++;
while (*cptr && ISLWS(*cptr)) cptr++;
/* empty message (from configuration load) */
if (*cptr == '\0') return (true);
/* deliberately empty message */
if (SAME2(cptr,'#\0')) cptr++;
if (!mmptr->Msgs[mmptr->LanguageNumber]->TextPtr[MessageNumber])
{
mmptr->Msgs[mmptr->LanguageNumber]->TextPtr[MessageNumber] =
MsgCreate (cptr);
if (mmptr->LanguageNumber == mmptr->LanguageCount) mmptr->MessageCount++;
}
else
MetaConReport (mcptr, METACON_REPORT_ERROR, ErrorMsgDupMsgNumber);
return (true);
}
/*****************************************************************************/
/*
Allocate dynamic memory for the text of the message, copy it into it and
return a pointer to it. The MapUrl.c module (for horrible, historical reasons)
requires a leading null character before the message. Fudge this by creating
a one character longer string with that leading null and returning a pointer to
the first character. The MapUrl.c module will the just use the returned
pointer minus one! (Neat huh? Well it works anyway!)
*/
char* MsgCreate (char *Text)
{
char *MsgPtr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "MsgCreate() !&Z", Text);
MsgPtr = VmGet (strlen(Text)+2);
*MsgPtr = '\0';
strcpy (MsgPtr+1, Text);
return (MsgPtr+1);
}
/*****************************************************************************/
/*
Return a pointer to a character string for the message number supplied in
'Message'. If multiple languages are in use then use any supplied client list
of accepted languages ("Accept-Language:" request header field) to see if the
message can be supplied in a prefered language. If none supplied or if none
match then check if the language has geographical information against it (a
list of host/domain specifications that can be used to determine if a specific
language would be more appropriate. If none of the "hit" then return the
configuration-prefered language.
*/
char* MsgFor
(
REQUEST_STRUCT *rqptr,
int Message
)
{
BOOL LangMatch;
int Count,
Language;
char *cptr, *lptr, *sptr, *tptr;
/*********/
/* begin */
/*********/
if (WATCHMOD(rqptr, WATCH_MOD_MSG))
WatchThis (WATCHITM(rqptr), WATCH_MOD_MSG, "MsgFor() !UL", Message);
if (!rqptr)
{
/* no request structure, use the default language */
Language = MsgMeta.LanguageDefault;
}
else
if (rqptr->MsgLanguage)
{
/* request message language has previously been set */
Language = rqptr->MsgLanguage;
}
else
if (MsgMeta.LanguageCount == 1)
{
/* only one language in use, use it! */
Language = rqptr->MsgLanguage = MsgMeta.LanguageDefault;
}
else
{
if (rqptr->rqHeader.AcceptLangPtr)
{
/*******************************************/
/* look for the client's prefered language */
/*******************************************/
lptr = rqptr->rqHeader.AcceptLangPtr;
while (*lptr)
{
for (Count = 1; Count <= MsgMeta.LanguageCount; Count++)
{
sptr = MsgMeta.Msgs[Count]->LanguageList;
/* can be in the comma-separated form "es-ES,es,es-*" */
while (*sptr)
{
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "!UL !&Z !&Z",
Count, sptr, lptr);
/* compare to this language specified by the client */
tptr = sptr;
cptr = lptr;
while (*cptr && TOUP(*cptr) == TOUP(*sptr) &&
*cptr != ';' && *cptr != ',' && !ISLWS(*cptr))
{
cptr++;
sptr++;
}
LangMatch = true;
if (*sptr && *sptr != ',' && !ISLWS(*sptr) && *sptr != '*')
LangMatch = false;
else
if (*sptr != '*' &&
*cptr && *cptr != ';' && *cptr != ',' && !ISLWS(*cptr))
LangMatch = false;
if (!LangMatch)
{
while (*sptr && *sptr != ',') sptr++;
while (*sptr && (*sptr == ',' || ISLWS(*sptr))) sptr++;
continue;
}
/*********/
/* match */
/*********/
if (WATCHING (rqptr, WATCH_RESPONSE_HEADER))
{
while (*sptr && *sptr != ',') sptr++;
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER,
"LANG !UL:!AZ (\"!#AZ\" in \"!AZ\")",
MsgMeta.Msgs[Count]->LanguageNumber,
MsgMeta.Msgs[Count]->LanguageList,
sptr-tptr, tptr, rqptr->rqHeader.AcceptLangPtr);
}
Language = rqptr->MsgLanguage =
MsgMeta.Msgs[Count]->LanguageNumber;
break;
}
if (rqptr->MsgLanguage) break;
}
/* if we've found one */
if (rqptr->MsgLanguage) break;
/* step to the next language (if any) in the client list */
while (*lptr && *lptr != ',' && !ISLWS(*lptr)) lptr++;
while (*lptr && (*lptr == ',' || ISLWS(*lptr))) lptr++;
}
}
if (!rqptr->MsgLanguage)
{
/************************/
/* look for a host list */
/************************/
for (Count = 1; Count <= MsgMeta.LanguageCount; Count++)
{
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "!UL !&Z",
Count, MsgMeta.Msgs[Count]->LanguageList);
if (MsgMeta.Msgs[Count]->HostListPtr)
{
if (MsgInHostList (rqptr, MsgMeta.Msgs[Count]->HostListPtr))
{
if (WATCHING (rqptr, WATCH_RESPONSE_HEADER))
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER,
"LANG !UL:!AZ (!AZ)",
MsgMeta.Msgs[Count]->LanguageNumber,
MsgMeta.Msgs[Count]->LanguageList,
MsgMeta.Msgs[Count]->HostListPtr);
Language = rqptr->MsgLanguage =
MsgMeta.Msgs[Count]->LanguageNumber;
break;
}
}
}
}
/* if none matching then fall back to the default language */
if (!rqptr->MsgLanguage)
{
if (WATCHING (rqptr, WATCH_RESPONSE_HEADER))
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER,
"LANG !UL:!AZ (default)",
MsgMeta.Msgs[MsgMeta.LanguageDefault]->LanguageNumber,
MsgMeta.Msgs[MsgMeta.LanguageDefault]->LanguageList);
Language = rqptr->MsgLanguage = MsgMeta.LanguageDefault;
}
}
if (Message <= 0 || Message > MSG_RANGE ||
Language < 1 || Language > MsgMeta.LanguageCount)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
/*******************/
/* get the message */
/*******************/
/* if a message has been assigned then return it */
if (cptr = MsgMeta.Msgs[Language]->TextPtr[Message])
{
if (rqptr && MsgMeta.Msgs[Language]->CharsetPtr)
rqptr->rqResponse.MsgCharsetPtr = MsgMeta.Msgs[Language]->CharsetPtr;
if (MsgMeta.LanguageCount == 1) return (cptr);
if (WATCHING (rqptr, WATCH_RESPONSE_HEADER))
{
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER, "LANG !UL:!AZ",
Language, MsgMeta.Msgs[Language]->LanguageList);
WatchDataFormatted ("!AZ\n", cptr);
}
return (cptr);
}
/*********************************/
/* fallback to the base language */
/*********************************/
if (cptr = MsgMeta.Msgs[MsgMeta.LanguageCount]->TextPtr[Message])
{
if (rqptr && MsgMeta.Msgs[MsgMeta.LanguageCount]->CharsetPtr)
rqptr->rqResponse.MsgCharsetPtr =
MsgMeta.Msgs[MsgMeta.LanguageCount]->CharsetPtr;
if (MsgMeta.LanguageCount == 1) return (cptr);
if (WATCHING (rqptr, WATCH_RESPONSE_HEADER))
{
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER, "LANG !UL:!AZ",
MsgMeta.LanguageCount,
MsgMeta.Msgs[MsgMeta.LanguageCount]->LanguageList);
WatchDataFormatted ("!AZ\n", cptr);
}
return (cptr);
}
/**************************************/
/* no message was set for this event! */
/**************************************/
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "!UL !&Z", Language, MsgNotSet);
return (MsgNotSet);
}
/*****************************************************************************/
/*
If the client's IP host name or address matches the wildcard string in
'HostList' then return true, else return false.
*/
BOOL MsgInHostList
(
REQUEST_STRUCT *rqptr,
char *HostList
)
{
char ch;
char *cptr, *hptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCHMOD(rqptr, WATCH_MOD_MSG))
WatchThis (WATCHITM(rqptr), WATCH_MOD_MSG,
"MsgInHostList() !&Z !&Z !&Z",
rqptr->ClientPtr->Lookup.HostName,
&rqptr->ClientPtr->IpAddressString,
HostList);
hptr = HostList;
while (*hptr)
{
while (*hptr && (*hptr == ',' || ISLWS(*hptr))) hptr++;
sptr = hptr;
while (*hptr && *hptr != ',' && !ISLWS(*hptr)) hptr++;
ch = *hptr;
*hptr = '\0';
/* match against host address or name */
if (isdigit(*sptr))
cptr = &rqptr->ClientPtr->IpAddressString;
else
cptr = rqptr->ClientPtr->Lookup.HostName;
if (WATCH_MODULE(WATCH_MOD_MSG))
WatchThis (WATCHALL, WATCH_MOD_MSG, "!&Z !&Z", cptr, sptr);
if (StringMatch (rqptr, cptr, sptr))
{
*hptr = ch;
return (true);
}
*hptr = ch;
if (*hptr) hptr++;
}
return (false);
}
/*****************************************************************************/
/*
A server administration report on the server's configuration. This function
just wraps the reporting function, loading a temporary database if necessary
for reporting from the configuration file.
*/
MsgConfigReport
(
REQUEST_STRUCT *rqptr,
BOOL UseServerDatabase
)
{
int status;
META_CONFIG *mcptr;
/*********/
/* begin */
/*********/
if (WATCHMOD(rqptr, WATCH_MOD_MSG))
WatchThis (WATCHITM(rqptr), WATCH_MOD_MSG,
"MsgConfigReport() !&F !UL",
&MsgConfigReport, UseServerDatabase);
if (UseServerDatabase)
MsgConfigReportNow (rqptr, MetaGlobalMsgPtr);
else
{
status = MsgConfigLoad (&mcptr);
if (VMSnok (status))
{
/* severe error reported */
rqptr->rqResponse.HttpStatus = 403;
ErrorGeneral (rqptr, mcptr->LoadReport.TextPtr, FI_LI);
}
else
MsgConfigReportNow (rqptr, mcptr);
MetaConUnload (&mcptr, NULL);
}
AdminEnd (rqptr);
}
/*****************************************************************************/
/*
A server administration report on the message database.
*/
MsgConfigReportNow
(
REQUEST_STRUCT *rqptr,
META_CONFIG *mcptr
)
{
static char LanguageTable [] =
"<p><table class=\"ctgry\">\n\
<tr><th>Languages</th></tr>\n\
<tr><td>\n\
<table class=\"lftlft\">\n\
<tr>\
<th></th>\
<th class=\"sbttl\">Lang</th>\
<th class=\"sbttl\">Charset</th>\
<th class=\"sbttl\">Host List</th>\
!&@\
</tr>\n";
static char EndLanguageTable [] =
"</table>\n\
</td></tr>\n\
</table>\n";
static char OneLanguageFao [] =
"<tr>\
<td><b>!UL</b></td>\
<td>!AZ</td>\
<td>!AZ</td>\
<td>!AZ</td>\
!&@\
</tr>\n";
static char GroupFao [] =
"<p><table class=\"ctgry\">\n\
<tr><th style=\"font-size:110%\">!AZ</th></tr>\n\
<tr><td>\n\
<table class=\"lftlft\">\n";
static char MessageFao [] =
"<tr>!&@<th>!&;AZ</th><td>!&@</td></tr>\n";
char EndOfGroup [] =
"</table>\n\
</td></tr>\n\
</table>";
char EndOfPage [] =
"</table>\n\
</body>\n\
</html>\n";
BOOL MultipleLines;
int status,
GroupCount,
Count,
Language,
RowCount;
unsigned long FaoVector [32];
unsigned long *vecptr;
char *cptr;
MSG_META *mmptr;
/*********/
/* begin */
/*********/
if (WATCHMOD(rqptr, WATCH_MOD_MSG))
WatchThis (WATCHITM(rqptr), WATCH_MOD_MSG, "MsgConfigReportNow()");
/* get a pointer to the meta-config data */
mmptr = mcptr->MsgMetaPtr;
AdminPageTitle (rqptr, "Server Messages");
AdminMetaConReport (rqptr, mcptr, MetaGlobalMsgPtr);
AdminMetaConSource (rqptr, mcptr, MetaGlobalMsgPtr);
/********************/
/* language summary */
/********************/
vecptr = FaoVector;
if (mmptr->SearchListCount > 1)
*vecptr++ = "<th><u>File</u></th>";
else
*vecptr++ = "";
status = FaolToNet (rqptr, LanguageTable, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
for (Count = 1; Count <= mmptr->LanguageCount; Count++)
{
vecptr = FaoVector;
*vecptr++ = Count;
*vecptr++ = mmptr->Msgs[Count]->LanguageList;
if (mmptr->Msgs[Count]->CharsetPtr)
*vecptr++ = mmptr->Msgs[Count]->CharsetPtr;
else
*vecptr++ = "<i>(default)</i>";
if (mmptr->Msgs[Count]->HostListPtr)
*vecptr++ = mmptr->Msgs[Count]->HostListPtr;
else
*vecptr++ = "<i>(none)</i>";
if (mmptr->SearchListCount > 1)
{
*vecptr++ = "<td>!AZ</td>";
*vecptr++ = mmptr->Msgs[Count]->FileName;
}
else
*vecptr++ = "";
status = FaolToNet (rqptr, OneLanguageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
status = FaolToNet (rqptr, EndLanguageTable, NULL);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
/*****************************/
/* loop through all messages */
/*****************************/
Count = GroupCount = 0;
for (Count = 0; Count < MSG_RANGE; Count++)
{
if (mmptr->Msgs[1]->TextPtr[Count])
{
/* the '\b' backspace is a sentinal, will never occur in a message */
if (SAME2(mmptr->Msgs[1]->TextPtr[Count],'\b['))
{
if (GroupCount++)
{
status = FaolToNet (rqptr, EndOfGroup, NULL);
if (VMSnok (status))
ErrorNoticed (rqptr, status, NULL, FI_LI);
}
vecptr = FaoVector;
*vecptr++ = mmptr->Msgs[1]->TextPtr[Count]+1;
status = FaolToNet (rqptr, GroupFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
Count++;
mmptr->MessageCount = 0;
}
}
RowCount = 0;
for (Language = 1; Language <= mmptr->LanguageCount; Language++)
if (mmptr->Msgs[Language]->TextPtr[Count]) RowCount++;
for (Language = 1; Language <= mmptr->LanguageCount; Language++)
{
if (!mmptr->Msgs[Language]->TextPtr[Count]) continue;
/* '*cptr' will not be a pointer to a null character if linefeeds */
for (cptr = mmptr->Msgs[Language]->TextPtr[Count];
*cptr && *cptr != '\n';
cptr++);
if (*cptr)
MultipleLines = true;
else
MultipleLines = false;
vecptr = FaoVector;
if (RowCount > 1)
{
*vecptr++ = "<th rowspan=\"!UL\">!2ZL</th>";
*vecptr++ = RowCount;
*vecptr++ = ++mmptr->MessageCount;
RowCount = 0;
}
else
if (RowCount == 1)
{
*vecptr++ = "<th>!2ZL</th>";
*vecptr++ = ++mmptr->MessageCount;
}
else
*vecptr++ = "";
*vecptr++ = mmptr->Msgs[Language]->LanguageName;
if (MultipleLines)
*vecptr++ = "<pre>!&;AZ</pre>";
else
*vecptr++ = "<tt>!&;AZ</tt>";
*vecptr++ = mmptr->Msgs[Language]->TextPtr[Count];
status = FaolToNet (rqptr, MessageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
}
/**************/
/* end report */
/**************/
status = FaolToNet (rqptr, EndOfPage, NULL);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
rqptr->rqResponse.PreExpired = PRE_EXPIRE_ADMIN;
ResponseHeader200 (rqptr, "text/html", &rqptr->NetWriteBufferDsc);
}
/*****************************************************************************/
/*
A server administration menu for message configuration. This function just
wraps the revision function, loading a temporary database if necessary for
reporting from the message configuration file.
*/
MsgConfigRevise
(
REQUEST_STRUCT *rqptr,
BOOL UseServerDatabase
)
{
int status;
META_CONFIG *mcptr;
/*********/
/* begin */
/*********/
if (WATCHMOD(rqptr, WATCH_MOD_MSG))
WatchThis (WATCHITM(rqptr), WATCH_MOD_MSG,
"MsgConfigRevise() !&F !UL",
&MsgConfigRevise, UseServerDatabase);
if (UseServerDatabase)
MsgConfigReviseNow (rqptr, MetaGlobalMsgPtr);
else
{
status = MsgConfigLoad (&mcptr);
if (VMSnok (status))
{
/* severe error reported */
rqptr->rqResponse.HttpStatus = 403;
ErrorGeneral (rqptr, mcptr->LoadReport.TextPtr, FI_LI);
}
else
MsgConfigReviseNow (rqptr, mcptr);
MetaConUnload (&mcptr, NULL);
}
AdminEnd (rqptr);
}
/*****************************************************************************/
/*
A server administration revision for the message database.
*/
MsgConfigReviseNow
(
REQUEST_STRUCT *rqptr,
META_CONFIG *mcptr
)
{
static char LanguageTable [] =
"<p><table class=\"ctgry\">\n\
<tr><th>Languages</th></tr>\n\
<tr><td>\n\
<table class=\"lftlft\">\n\
<tr><th class=\"sbttl\">Order</th>\
<th class=\"sbttl\">Language</th>\
<th class=\"sbttl\">Charset</th>\
<th class=\"sbttl\">Host List</th></tr>\n\
<input type=\"hidden\" name=\"hidden$lf\" value=\"^[Version] !AZ\">\n";
static char EndLanguageTable [] =
"<tr><td colspan=\"4\" \
style=\"width:20em;white-space:normal;color:#ff0000;\">\n\
<b>IMPORTANT:</b> \n\
<i>The primary language (that with <u>all</u> message texts complete \
- usually "en") must be the <u>highest numbered</u> (order) \
language.\n\
Failure to ensure this will render the server unable to start!!</i>\n\
</td></tr>\n\
</table>\n</td></tr>\n</table>\n";
static char OneLanguageFao [] =
"<tr><td>\n\
<input type=\"hidden\" name=\"hidden$lf\" value=\"^[Language]  \">\n\
<input type=\"text\" size=\"3\" name=\"Order\" value=\"!&@\">\n\
</td><td>\n\
<input type=\"hidden\" name=\"hidden$lf\" value=\"  \">\n\
<input type=\"text\" size=\"20\" name=\"Language\" value=\"!AZ\">\n\
</td><td>\n\
<input type=\"hidden\" name=\"hidden$lf\" value=\"  charset=\">\n\
<input type=\"text\" size=\"20\" name=\"Charset\" value=\"!AZ\">\n\
</td><td>\n\
<input type=\"hidden\" name=\"hidden$lf\" value=\"  hosts=\">\n\
<input type=\"text\" size=\"3\"5 name=\"HostList\" value=\"!AZ\">\n\
</td></tr>\n";
static char GroupFao [] =
"<p><table class=\"ctgry\">\n\
<input type=\"hidden\" name=\"hidden$lf\" value=\"^^!AZ^\">\n\
<tr><th><font size=\"+1\">!AZ</font></th></tr>\n\
<tr><td>\n\
<table class=\"lftlft\">\n";
static char MessageFao [] =
"<tr><td>!2ZL<td>!&;AZ</td><td>!&@</td></tr>\n";
char EndOfGroup [] = "</table>\n</td></tr>\n</table>";
int status,
GroupCount,
Count,
Language,
LineCount;
unsigned long FaoVector [32];
unsigned long *vecptr;
char *cptr, *sptr, *zptr,
*MsgGroupPtr,
*MsgTextPtr;
char MultiLineBuffer [2048];
MSG_META *mmptr;
/*********/
/* begin */
/*********/
if (WATCHMOD(rqptr, WATCH_MOD_MSG))
WatchThis (WATCHITM(rqptr), WATCH_MOD_MSG, "MsgConfigReviseNow()");
/* get a pointer to the meta-config data */
mmptr = mcptr->MsgMetaPtr;
AdminPageTitle (rqptr, "Server Messages");
AdminMetaConReport (rqptr, mcptr, MetaGlobalMsgPtr);
AdminMetaConSource (rqptr, mcptr, MetaGlobalMsgPtr);
AdminMetaConBeginUpdateForm (rqptr);
/********************/
/* language summary */
/********************/
vecptr = FaoVector;
*vecptr++ = MSG_VERSION;
status = FaolToNet (rqptr, LanguageTable, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
for (Count = 1; Count <= mmptr->LanguageCount; Count++)
{
vecptr = FaoVector;
*vecptr++ = "!UL";
*vecptr++ = Count;
*vecptr++ = mmptr->Msgs[Count]->LanguageList;
if (mmptr->Msgs[Count]->CharsetPtr)
*vecptr++ = mmptr->Msgs[Count]->CharsetPtr;
else
*vecptr++ = "";
if (mmptr->Msgs[Count]->HostListPtr)
*vecptr++ = mmptr->Msgs[Count]->HostListPtr;
else
*vecptr++ = "";
status = FaolToNet (rqptr, OneLanguageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
vecptr = FaoVector;
*vecptr++ = "";
*vecptr++ = "";
*vecptr++ = "";
*vecptr++ = "";
status = FaolToNet (rqptr, OneLanguageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
status = FaolToNet (rqptr, EndLanguageTable, NULL);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
/*****************************/
/* loop through all messages */
/*****************************/
Count = GroupCount = 0;
for (Count = 0; Count < MSG_RANGE; Count++)
{
if (mmptr->Msgs[1]->TextPtr[Count])
{
/* the '\b' backspace is a sentinal, will never occur in a message */
if (SAME2(mmptr->Msgs[1]->TextPtr[Count],'\b['))
{
if (GroupCount++)
{
status = FaolToNet (rqptr, EndOfGroup, NULL);
if (VMSnok (status))
ErrorNoticed (rqptr, status, NULL, FI_LI);
}
vecptr = FaoVector;
*vecptr++ = MsgGroupPtr = mmptr->Msgs[1]->TextPtr[Count]+1;
*vecptr++ = mmptr->Msgs[1]->TextPtr[Count]+1;
status = FaolToNet (rqptr, GroupFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
Count++;
mmptr->MessageCount = 0;
}
}
mmptr->MessageCount++;
for (Language = 1; Language <= mmptr->LanguageCount; Language++)
{
if (!mmptr->Msgs[Language]->TextPtr[Count])
{
MsgTextPtr = "";
/* fall back to the size of the message in the base language */
cptr = mmptr->Msgs[mmptr->LanguageCount]->TextPtr[Count];
}
else
MsgTextPtr = cptr = mmptr->Msgs[Language]->TextPtr[Count];
/* count number of lines in message */
LineCount = 1;
for ( /*above*/ ; *cptr; cptr++) if (*cptr == '\n') LineCount++;
vecptr = FaoVector;
*vecptr++ = mmptr->MessageCount;
*vecptr++ = mmptr->Msgs[Language]->LanguageName;
if (LineCount > 1)
{
/* add a '\' (line continuation) character at each end-of-line */
cptr = MsgTextPtr;
zptr = (sptr = MultiLineBuffer) + sizeof(MultiLineBuffer);
while (*cptr && sptr < zptr)
{
if (*cptr == '\n' && sptr < zptr) *sptr++ = '\\';
if (sptr < zptr) *sptr++ = *cptr++;
}
if (sptr >= zptr)
{
ErrorGeneralOverflow (rqptr, FI_LI);
break;
}
if (sptr > MultiLineBuffer) sptr--;
while (sptr > MultiLineBuffer &&
(ISLWS(*sptr) || *sptr == '\n' || *sptr == '\\')) sptr--;
if (sptr > MultiLineBuffer) sptr++;
*sptr = '\0';
*vecptr++ =
"<input type=\"hidden\" name=\"hidden$lf\" value=\"^!AZ !2ZL \">\n\
<textarea name=\"!AZ!AZ!2ZL\" rows=\"!UL\" cols=\"60\">!&;AZ</textarea>";
*vecptr++ = mmptr->Msgs[Language]->LanguageList;
*vecptr++ = mmptr->MessageCount;
*vecptr++ = MsgGroupPtr;
*vecptr++ = mmptr->Msgs[Language]->LanguageList;
*vecptr++ = mmptr->MessageCount;
*vecptr++ = LineCount;
*vecptr++ = MultiLineBuffer;
}
else
{
*vecptr++ =
"<input type=\"hidden\" name=\"hidden$lf\" value=\"^!AZ !2ZL \">\n\
<input name=\"!AZ!AZ!2ZL\" type=\"text\" size=\"60\" value=\"!&;AZ\">";
*vecptr++ = mmptr->Msgs[Language]->LanguageList;
*vecptr++ = mmptr->MessageCount;
*vecptr++ = MsgGroupPtr;
*vecptr++ = mmptr->Msgs[Language]->LanguageList;
*vecptr++ = mmptr->MessageCount;
*vecptr++ = MsgTextPtr;
}
status = FaolToNet (rqptr, MessageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
}
}
/**************/
/* end revise */
/**************/
status = FaolToNet (rqptr, "</table>\n</td></tr>\n</table>\n", NULL);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
AdminMetaConEndUpdateForm (rqptr);
status = FaolToNet (rqptr, "</body>\n</html>\n", NULL);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
rqptr->rqResponse.PreExpired = PRE_EXPIRE_ADMIN;
ResponseHeader200 (rqptr, "text/html", &rqptr->NetWriteBufferDsc);
}
/*****************************************************************************/