[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
[1230]
[1231]
[1232]
[1233]
[1234]
[1235]
[1236]
[1237]
[1238]
[1239]
[1240]
[1241]
[1242]
[1243]
[1244]
[1245]
[1246]
[1247]
[1248]
[1249]
[1250]
[1251]
[1252]
[1253]
[1254]
[1255]
[1256]
[1257]
[1258]
[1259]
[1260]
[1261]
[1262]
[1263]
[1264]
[1265]
[1266]
[1267]
[1268]
[1269]
[1270]
[1271]
[1272]
[1273]
[1274]
[1275]
[1276]
[1277]
[1278]
[1279]
[1280]
[1281]
[1282]
[1283]
[1284]
[1285]
[1286]
[1287]
[1288]
[1289]
[1290]
[1291]
[1292]
[1293]
[1294]
[1295]
[1296]
[1297]
[1298]
[1299]
[1300]
[1301]
[1302]
[1303]
[1304]
[1305]
[1306]
[1307]
[1308]
[1309]
[1310]
[1311]
[1312]
[1313]
[1314]
[1315]
[1316]
[1317]
[1318]
[1319]
[1320]
[1321]
[1322]
[1323]
[1324]
[1325]
[1326]
[1327]
[1328]
[1329]
[1330]
[1331]
[1332]
[1333]
[1334]
[1335]
[1336]
[1337]
[1338]
[1339]
[1340]
[1341]
[1342]
[1343]
[1344]
[1345]
[1346]
[1347]
[1348]
[1349]
[1350]
[1351]
[1352]
[1353]
[1354]
[1355]
[1356]
[1357]
[1358]
[1359]
[1360]
[1361]
[1362]
[1363]
[1364]
[1365]
[1366]
[1367]
[1368]
[1369]
[1370]
[1371]
[1372]
[1373]
[1374]
[1375]
[1376]
[1377]
[1378]
[1379]
[1380]
[1381]
[1382]
[1383]
[1384]
[1385]
[1386]
[1387]
[1388]
[1389]
[1390]
[1391]
[1392]
[1393]
[1394]
[1395]
[1396]
[1397]
[1398]
[1399]
[1400]
[1401]
[1402]
[1403]
[1404]
[1405]
[1406]
[1407]
[1408]
[1409]
[1410]
[1411]
[1412]
[1413]
[1414]
[1415]
[1416]
[1417]
[1418]
[1419]
[1420]
[1421]
[1422]
[1423]
[1424]
[1425]
[1426]
[1427]
[1428]
[1429]
[1430]
[1431]
[1432]
[1433]
[1434]
[1435]
[1436]
[1437]
[1438]
[1439]
[1440]
[1441]
[1442]
[1443]
[1444]
[1445]
[1446]
[1447]
[1448]
[1449]
[1450]
[1451]
[1452]
[1453]
[1454]
[1455]
[1456]
[1457]
[1458]
[1459]
[1460]
[1461]
[1462]
[1463]
[1464]
[1465]
[1466]
[1467]
[1468]
[1469]
[1470]
[1471]
[1472]
[1473]
[1474]
[1475]
[1476]
[1477]
[1478]
[1479]
[1480]
[1481]
[1482]
[1483]
[1484]
[1485]
[1486]
[1487]
[1488]
[1489]
[1490]
[1491]
[1492]
[1493]
[1494]
[1495]
[1496]
[1497]
[1498]
[1499]
[1500]
[1501]
[1502]
[1503]
[1504]
[1505]
[1506]
[1507]
[1508]
[1509]
[1510]
[1511]
[1512]
[1513]
[1514]
[1515]
[1516]
[1517]
[1518]
[1519]
[1520]
[1521]
[1522]
[1523]
[1524]
[1525]
[1526]
[1527]
[1528]
[1529]
[1530]
[1531]
[1532]
[1533]
[1534]
[1535]
[1536]
[1537]
[1538]
[1539]
[1540]
[1541]
[1542]
[1543]
[1544]
[1545]
[1546]
[1547]
[1548]
[1549]
[1550]
[1551]
[1552]
[1553]
[1554]
[1555]
[1556]
[1557]
[1558]
[1559]
[1560]
[1561]
[1562]
[1563]
[1564]
[1565]
[1566]
[1567]
[1568]
[1569]
[1570]
[1571]
[1572]
[1573]
[1574]
[1575]
[1576]
[1577]
[1578]
[1579]
[1580]
[1581]
[1582]
[1583]
[1584]
[1585]
[1586]
[1587]
[1588]
[1589]
[1590]
[1591]
[1592]
[1593]
[1594]
[1595]
[1596]
[1597]
[1598]
[1599]
[1600]
[1601]
[1602]
[1603]
[1604]
[1605]
[1606]
[1607]
[1608]
[1609]
[1610]
[1611]
[1612]
[1613]
[1614]
[1615]
[1616]
[1617]
[1618]
[1619]
[1620]
[1621]
[1622]
[1623]
[1624]
[1625]
[1626]
[1627]
[1628]
[1629]
[1630]
[1631]
[1632]
[1633]
[1634]
[1635]
[1636]
[1637]
[1638]
[1639]
[1640]
[1641]
[1642]
[1643]
[1644]
[1645]
[1646]
[1647]
[1648]
[1649]
[1650]
[1651]
[1652]
[1653]
[1654]
[1655]
[1656]
[1657]
[1658]
[1659]
[1660]
[1661]
[1662]
[1663]
[1664]
[1665]
[1666]
[1667]
[1668]
[1669]
[1670]
[1671]
[1672]
[1673]
[1674]
[1675]
[1676]
[1677]
[1678]
[1679]
[1680]
[1681]
[1682]
[1683]
[1684]
[1685]
[1686]
[1687]
[1688]
[1689]
[1690]
[1691]
[1692]
[1693]
[1694]
[1695]
[1696]
[1697]
[1698]
[1699]
[1700]
[1701]
[1702]
[1703]
[1704]
[1705]
[1706]
[1707]
[1708]
[1709]
[1710]
[1711]
[1712]
[1713]
[1714]
[1715]
[1716]
[1717]
[1718]
[1719]
[1720]
[1721]
[1722]
[1723]
[1724]
[1725]
[1726]
[1727]
[1728]
[1729]
[1730]
[1731]
[1732]
[1733]
[1734]
[1735]
[1736]
[1737]
[1738]
[1739]
[1740]
[1741]
[1742]
[1743]
[1744]
[1745]
[1746]
[1747]
[1748]
[1749]
[1750]
[1751]
[1752]
[1753]
[1754]
[1755]
[1756]
[1757]
[1758]
[1759]
[1760]
[1761]
[1762]
[1763]
[1764]
[1765]
[1766]
[1767]
[1768]
[1769]
[1770]
[1771]
[1772]
[1773]
[1774]
[1775]
[1776]
[1777]
[1778]
[1779]
[1780]
[1781]
[1782]
[1783]
[1784]
[1785]
[1786]
[1787]
[1788]
[1789]
[1790]
[1791]
[1792]
[1793]
[1794]
[1795]
[1796]
[1797]
[1798]
[1799]
[1800]
[1801]
[1802]
[1803]
[1804]
[1805]
[1806]
[1807]
[1808]
[1809]
[1810]
[1811]
[1812]
[1813]
[1814]
[1815]
[1816]
[1817]
[1818]
[1819]
[1820]
[1821]
[1822]
[1823]
[1824]
[1825]
[1826]
[1827]
[1828]
[1829]
[1830]
[1831]
[1832]
[1833]
[1834]
[1835]
[1836]
[1837]
[1838]
[1839]
[1840]
[1841]
[1842]
[1843]
[1844]
[1845]
[1846]
[1847]
[1848]
[1849]
[1850]
[1851]
[1852]
[1853]
[1854]
[1855]
[1856]
[1857]
[1858]
[1859]
[1860]
[1861]
[1862]
[1863]
[1864]
[1865]
[1866]
[1867]
[1868]
[1869]
[1870]
[1871]
[1872]
[1873]
[1874]
[1875]
[1876]
[1877]
[1878]
[1879]
[1880]
[1881]
[1882]
[1883]
[1884]
[1885]
[1886]
[1887]
[1888]
[1889]
[1890]
[1891]
[1892]
[1893]
[1894]
[1895]
[1896]
[1897]
[1898]
[1899]
[1900]
[1901]
[1902]
[1903]
[1904]
[1905]
[1906]
[1907]
[1908]
[1909]
[1910]
[1911]
[1912]
[1913]
[1914]
[1915]
[1916]
[1917]
[1918]
[1919]
[1920]
[1921]
[1922]
[1923]
[1924]
[1925]
[1926]
[1927]
[1928]
[1929]
[1930]
[1931]
[1932]
[1933]
[1934]
[1935]
[1936]
[1937]
[1938]
[1939]
[1940]
[1941]
[1942]
[1943]
[1944]
[1945]
[1946]
[1947]
[1948]
[1949]
[1950]
[1951]
[1952]
[1953]
[1954]
[1955]
[1956]
[1957]
[1958]
[1959]
[1960]
[1961]
[1962]
[1963]
[1964]
[1965]
[1966]
[1967]
[1968]
[1969]
[1970]
[1971]
[1972]
[1973]
[1974]
[1975]
[1976]
[1977]
[1978]
[1979]
[1980]
[1981]
[1982]
[1983]
[1984]
[1985]
[1986]
[1987]
[1988]
[1989]
[1990]
[1991]
[1992]
[1993]
[1994]
[1995]
[1996]
[1997]
[1998]
[1999]
[2000]
[2001]
[2002]
[2003]
[2004]
[2005]
[2006]
[2007]
[2008]
[2009]
[2010]
[2011]
[2012]
[2013]
[2014]
[2015]
[2016]
[2017]
[2018]
[2019]
[2020]
[2021]
[2022]
[2023]
[2024]
[2025]
[2026]
[2027]
[2028]
[2029]
[2030]
[2031]
[2032]
[2033]
[2034]
[2035]
[2036]
[2037]
[2038]
[2039]
[2040]
[2041]
[2042]
[2043]
[2044]
[2045]
[2046]
[2047]
[2048]
[2049]
[2050]
[2051]
[2052]
[2053]
[2054]
[2055]
[2056]
[2057]
[2058]
[2059]
[2060]
[2061]
[2062]
[2063]
[2064]
[2065]
[2066]
[2067]
[2068]
[2069]
[2070]
[2071]
[2072]
[2073]
[2074]
[2075]
[2076]
[2077]
[2078]
[2079]
[2080]
[2081]
[2082]
[2083]
[2084]
[2085]
[2086]
[2087]
[2088]
[2089]
[2090]
[2091]
[2092]
[2093]
[2094]
[2095]
[2096]
[2097]
[2098]
[2099]
[2100]
[2101]
[2102]
[2103]
[2104]
[2105]
[2106]
[2107]
[2108]
[2109]
[2110]
[2111]
[2112]
[2113]
[2114]
[2115]
[2116]
[2117]
[2118]
[2119]
[2120]
[2121]
[2122]
[2123]
[2124]
[2125]
[2126]
[2127]
[2128]
[2129]
[2130]
[2131]
[2132]
[2133]
[2134]
[2135]
[2136]
[2137]
[2138]
[2139]
[2140]
[2141]
[2142]
[2143]
[2144]
[2145]
[2146]
[2147]
[2148]
[2149]
[2150]
[2151]
[2152]
[2153]
[2154]
[2155]
[2156]
[2157]
[2158]
[2159]
[2160]
[2161]
[2162]
[2163]
[2164]
[2165]
[2166]
[2167]
[2168]
[2169]
[2170]
[2171]
[2172]
[2173]
[2174]
[2175]
[2176]
[2177]
[2178]
[2179]
[2180]
[2181]
[2182]
[2183]
[2184]
[2185]
[2186]
[2187]
[2188]
[2189]
[2190]
[2191]
[2192]
[2193]
[2194]
[2195]
[2196]
[2197]
[2198]
[2199]
[2200]
[2201]
[2202]
[2203]
[2204]
[2205]
[2206]
[2207]
[2208]
[2209]
[2210]
[2211]
[2212]
[2213]
[2214]
[2215]
[2216]
[2217]
[2218]
[2219]
[2220]
[2221]
[2222]
[2223]
[2224]
[2225]
[2226]
[2227]
[2228]
[2229]
[2230]
[2231]
[2232]
[2233]
[2234]
[2235]
[2236]
[2237]
[2238]
[2239]
[2240]
[2241]
[2242]
[2243]
[2244]
[2245]
[2246]
[2247]
[2248]
[2249]
[2250]
[2251]
[2252]
[2253]
[2254]
[2255]
[2256]
[2257]
[2258]
[2259]
[2260]
[2261]
[2262]
[2263]
[2264]
[2265]
[2266]
[2267]
[2268]
[2269]
[2270]
[2271]
[2272]
[2273]
[2274]
[2275]
[2276]
[2277]
[2278]
[2279]
[2280]
[2281]
[2282]
[2283]
[2284]
[2285]
[2286]
[2287]
[2288]
[2289]
[2290]
[2291]
[2292]
[2293]
[2294]
[2295]
[2296]
[2297]
[2298]
[2299]
[2300]
[2301]
[2302]
[2303]
[2304]
[2305]
[2306]
[2307]
[2308]
[2309]
[2310]
[2311]
[2312]
[2313]
[2314]
[2315]
[2316]
[2317]
[2318]
[2319]
[2320]
[2321]
[2322]
[2323]
[2324]
[2325]
[2326]
[2327]
[2328]
[2329]
[2330]
[2331]
[2332]
[2333]
[2334]
[2335]
[2336]
[2337]
[2338]
[2339]
[2340]
[2341]
[2342]
[2343]
[2344]
[2345]
[2346]
[2347]
[2348]
[2349]
[2350]
[2351]
[2352]
[2353]
[2354]
[2355]
[2356]
[2357]
[2358]
[2359]
[2360]
[2361]
[2362]
[2363]
[2364]
[2365]
[2366]
[2367]
[2368]
[2369]
[2370]
[2371]
[2372]
[2373]
[2374]
[2375]
[2376]
[2377]
[2378]
[2379]
[2380]
[2381]
[2382]
[2383]
[2384]
[2385]
[2386]
[2387]
[2388]
[2389]
[2390]
[2391]
[2392]
[2393]
[2394]
[2395]
[2396]
[2397]
[2398]
[2399]
[2400]
[2401]
[2402]
[2403]
[2404]
[2405]
[2406]
[2407]
[2408]
[2409]
[2410]
[2411]
[2412]
[2413]
[2414]
[2415]
[2416]
[2417]
[2418]
[2419]
[2420]
[2421]
[2422]
[2423]
[2424]
[2425]
[2426]
[2427]
[2428]
[2429]
[2430]
[2431]
[2432]
[2433]
[2434]
[2435]
[2436]
[2437]
[2438]
[2439]
[2440]
[2441]
[2442]
[2443]
[2444]
[2445]
[2446]
[2447]
[2448]
[2449]
[2450]
[2451]
[2452]
[2453]
[2454]
[2455]
[2456]
[2457]
[2458]
[2459]
[2460]
[2461]
[2462]
[2463]
[2464]
[2465]
[2466]
[2467]
[2468]
[2469]
[2470]
[2471]
[2472]
[2473]
[2474]
[2475]
[2476]
[2477]
[2478]
[2479]
[2480]
[2481]
[2482]
[2483]
[2484]
[2485]
[2486]
[2487]
[2488]
[2489]
[2490]
[2491]
[2492]
[2493]
[2494]
[2495]
[2496]
[2497]
[2498]
[2499]
[2500]
[2501]
[2502]
[2503]
[2504]
[2505]
[2506]
[2507]
[2508]
[2509]
[2510]
[2511]
[2512]
[2513]
[2514]
[2515]
[2516]
[2517]
[2518]
[2519]
[2520]
[2521]
[2522]
[2523]
[2524]
[2525]
[2526]
[2527]
[2528]
[2529]
[2530]
[2531]
[2532]
[2533]
[2534]
[2535]
[2536]
[2537]
[2538]
[2539]
[2540]
[2541]
[2542]
[2543]
[2544]
[2545]
[2546]
[2547]
[2548]
[2549]
[2550]
[2551]
[2552]
[2553]
[2554]
[2555]
[2556]
[2557]
[2558]
[2559]
[2560]
[2561]
[2562]
[2563]
[2564]
[2565]
[2566]
[2567]
[2568]
[2569]
[2570]
[2571]
[2572]
[2573]
[2574]
[2575]
[2576]
[2577]
[2578]
[2579]
[2580]
[2581]
[2582]
[2583]
[2584]
[2585]
[2586]
[2587]
[2588]
[2589]
[2590]
[2591]
[2592]
[2593]
[2594]
[2595]
[2596]
[2597]
[2598]
[2599]
[2600]
[2601]
[2602]
[2603]
[2604]
[2605]
[2606]
[2607]
[2608]
[2609]
[2610]
[2611]
[2612]
[2613]
[2614]
[2615]
[2616]
[2617]
[2618]
[2619]
[2620]
[2621]
[2622]
[2623]
[2624]
[2625]
[2626]
[2627]
[2628]
[2629]
[2630]
[2631]
[2632]
[2633]
[2634]
[2635]
[2636]
[2637]
[2638]
[2639]
[2640]
[2641]
[2642]
[2643]
[2644]
[2645]
[2646]
[2647]
[2648]
[2649]
[2650]
[2651]
[2652]
[2653]
[2654]
[2655]
[2656]
[2657]
[2658]
[2659]
[2660]
[2661]
[2662]
[2663]
[2664]
[2665]
[2666]
[2667]
[2668]
[2669]
[2670]
[2671]
[2672]
[2673]
[2674]
[2675]
[2676]
[2677]
[2678]
[2679]
[2680]
[2681]
[2682]
[2683]
[2684]
[2685]
[2686]
[2687]
[2688]
[2689]
[2690]
[2691]
[2692]
[2693]
[2694]
[2695]
[2696]
[2697]
[2698]
[2699]
[2700]
[2701]
[2702]
[2703]
[2704]
[2705]
[2706]
[2707]
[2708]
[2709]
[2710]
[2711]
[2712]
[2713]
[2714]
[2715]
[2716]
[2717]
[2718]
[2719]
[2720]
[2721]
[2722]
[2723]
[2724]
[2725]
[2726]
[2727]
[2728]
[2729]
[2730]
[2731]
[2732]
[2733]
[2734]
[2735]
[2736]
[2737]
[2738]
[2739]
[2740]
[2741]
[2742]
[2743]
[2744]
[2745]
[2746]
[2747]
[2748]
[2749]
[2750]
[2751]
[2752]
[2753]
[2754]
[2755]
[2756]
[2757]
[2758]
[2759]
[2760]
[2761]
[2762]
[2763]
[2764]
[2765]
[2766]
[2767]
[2768]
[2769]
[2770]
[2771]
[2772]
[2773]
[2774]
[2775]
[2776]
[2777]
[2778]
[2779]
[2780]
[2781]
[2782]
[2783]
[2784]
[2785]
[2786]
[2787]
[2788]
[2789]
[2790]
[2791]
[2792]
[2793]
[2794]
[2795]
[2796]
[2797]
[2798]
[2799]
[2800]
[2801]
[2802]
[2803]
[2804]
[2805]
[2806]
[2807]
[2808]
[2809]
[2810]
[2811]
[2812]
[2813]
[2814]
[2815]
[2816]
[2817]
[2818]
[2819]
[2820]
[2821]
[2822]
[2823]
[2824]
[2825]
[2826]
[2827]
[2828]
[2829]
[2830]
[2831]
[2832]
[2833]
[2834]
[2835]
[2836]
[2837]
[2838]
[2839]
[2840]
[2841]
[2842]
[2843]
[2844]
[2845]
[2846]
[2847]
[2848]
[2849]
[2850]
[2851]
[2852]
[2853]
[2854]
[2855]
[2856]
[2857]
[2858]
[2859]
[2860]
[2861]
[2862]
[2863]
[2864]
[2865]
[2866]
[2867]
[2868]
[2869]
[2870]
[2871]
[2872]
[2873]
[2874]
[2875]
[2876]
[2877]
[2878]
[2879]
[2880]
[2881]
[2882]
[2883]
[2884]
[2885]
[2886]
[2887]
[2888]
[2889]
[2890]
[2891]
[2892]
[2893]
[2894]
[2895]
[2896]
[2897]
[2898]
[2899]
[2900]
[2901]
[2902]
[2903]
[2904]
[2905]
[2906]
[2907]
[2908]
[2909]
[2910]
[2911]
[2912]
[2913]
[2914]
[2915]
[2916]
[2917]
[2918]
[2919]
[2920]
[2921]
[2922]
[2923]
[2924]
[2925]
[2926]
[2927]
[2928]
[2929]
[2930]
[2931]
[2932]
[2933]
[2934]
[2935]
[2936]
[2937]
[2938]
[2939]
[2940]
[2941]
[2942]
[2943]
[2944]
[2945]
[2946]
[2947]
[2948]
[2949]
[2950]
[2951]
[2952]
[2953]
[2954]
[2955]
[2956]
[2957]
[2958]
[2959]
[2960]
[2961]
[2962]
[2963]
[2964]
[2965]
[2966]
[2967]
[2968]
[2969]
[2970]
[2971]
[2972]
[2973]
[2974]
[2975]
[2976]
[2977]
[2978]
[2979]
[2980]
[2981]
[2982]
[2983]
[2984]
[2985]
[2986]
[2987]
[2988]
[2989]
[2990]
[2991]
[2992]
[2993]
[2994]
[2995]
[2996]
[2997]
[2998]
[2999]
[3000]
[3001]
[3002]
[3003]
[3004]
[3005]
[3006]
[3007]
[3008]
[3009]
[3010]
[3011]
[3012]
[3013]
[3014]
[3015]
[3016]
[3017]
[3018]
[3019]
[3020]
[3021]
[3022]
[3023]
[3024]
[3025]
[3026]
[3027]
[3028]
[3029]
[3030]
[3031]
[3032]
[3033]
[3034]
[3035]
[3036]
[3037]
[3038]
[3039]
[3040]
[3041]
[3042]
[3043]
[3044]
[3045]
[3046]
[3047]
[3048]
[3049]
[3050]
[3051]
[3052]
[3053]
[3054]
[3055]
[3056]
[3057]
[3058]
[3059]
[3060]
[3061]
[3062]
[3063]
[3064]
[3065]
[3066]
[3067]
[3068]
[3069]
[3070]
[3071]
[3072]
[3073]
[3074]
[3075]
[3076]
[3077]
[3078]
[3079]
[3080]
[3081]
[3082]
[3083]
[3084]
[3085]
[3086]
[3087]
[3088]
[3089]
[3090]
[3091]
[3092]
[3093]
[3094]
[3095]
[3096]
[3097]
[3098]
[3099]
[3100]
[3101]
[3102]
[3103]
[3104]
[3105]
[3106]
[3107]
[3108]
[3109]
[3110]
[3111]
[3112]
[3113]
[3114]
[3115]
[3116]
[3117]
[3118]
[3119]
[3120]
[3121]
[3122]
[3123]
[3124]
[3125]
[3126]
[3127]
[3128]
[3129]
[3130]
[3131]
[3132]
[3133]
[3134]
[3135]
[3136]
[3137]
[3138]
[3139]
[3140]
[3141]
[3142]
[3143]
[3144]
[3145]
[3146]
[3147]
[3148]
[3149]
[3150]
[3151]
[3152]
[3153]
[3154]
[3155]
[3156]
[3157]
[3158]
[3159]
[3160]
[3161]
[3162]
[3163]
[3164]
[3165]
[3166]
[3167]
[3168]
[3169]
[3170]
[3171]
[3172]
[3173]
[3174]
[3175]
[3176]
[3177]
[3178]
[3179]
[3180]
[3181]
[3182]
[3183]
[3184]
[3185]
[3186]
[3187]
[3188]
[3189]
[3190]
[3191]
[3192]
[3193]
[3194]
[3195]
[3196]
[3197]
[3198]
[3199]
[3200]
[3201]
[3202]
[3203]
[3204]
[3205]
[3206]
[3207]
[3208]
[3209]
[3210]
[3211]
[3212]
[3213]
[3214]
[3215]
[3216]
[3217]
[3218]
[3219]
[3220]
[3221]
[3222]
[3223]
[3224]
[3225]
[3226]
[3227]
[3228]
[3229]
[3230]
[3231]
[3232]
[3233]
[3234]
[3235]
[3236]
[3237]
[3238]
[3239]
[3240]
[3241]
[3242]
[3243]
[3244]
[3245]
[3246]
[3247]
[3248]
[3249]
[3250]
[3251]
[3252]
[3253]
[3254]
[3255]
[3256]
[3257]
[3258]
[3259]
[3260]
[3261]
[3262]
[3263]
[3264]
[3265]
[3266]
[3267]
[3268]
[3269]
[3270]
[3271]
[3272]
[3273]
[3274]
[3275]
[3276]
[3277]
[3278]
[3279]
[3280]
[3281]
[3282]
[3283]
[3284]
[3285]
[3286]
[3287]
[3288]
[3289]
[3290]
[3291]
[3292]
[3293]
[3294]
[3295]
[3296]
[3297]
[3298]
[3299]
[3300]
[3301]
[3302]
[3303]
[3304]
[3305]
[3306]
[3307]
[3308]
[3309]
[3310]
[3311]
[3312]
[3313]
[3314]
[3315]
[3316]
[3317]
[3318]
[3319]
[3320]
[3321]
[3322]
[3323]
[3324]
[3325]
[3326]
[3327]
[3328]
[3329]
[3330]
[3331]
[3332]
[3333]
[3334]
[3335]
[3336]
[3337]
[3338]
[3339]
[3340]
[3341]
[3342]
[3343]
[3344]
[3345]
[3346]
[3347]
[3348]
[3349]
[3350]
[3351]
[3352]
[3353]
[3354]
[3355]
[3356]
[3357]
[3358]
[3359]
[3360]
[3361]
[3362]
[3363]
[3364]
[3365]
[3366]
[3367]
[3368]
[3369]
[3370]
[3371]
[3372]
[3373]
[3374]
[3375]
[3376]
[3377]
[3378]
[3379]
[3380]
[3381]
[3382]
[3383]
[3384]
[3385]
[3386]
[3387]
[3388]
[3389]
[3390]
[3391]
[3392]
[3393]
[3394]
[3395]
[3396]
[3397]
[3398]
[3399]
[3400]
[3401]
[3402]
[3403]
[3404]
[3405]
[3406]
[3407]
[3408]
[3409]
[3410]
[3411]
[3412]
[3413]
[3414]
[3415]
[3416]
[3417]
[3418]
[3419]
[3420]
[3421]
[3422]
[3423]
[3424]
[3425]
[3426]
[3427]
[3428]
[3429]
[3430]
[3431]
[3432]
[3433]
[3434]
[3435]
[3436]
[3437]
[3438]
[3439]
[3440]
[3441]
[3442]
[3443]
[3444]
[3445]
[3446]
[3447]
[3448]
[3449]
[3450]
[3451]
[3452]
[3453]
[3454]
[3455]
[3456]
[3457]
[3458]
[3459]
[3460]
[3461]
[3462]
[3463]
[3464]
[3465]
[3466]
[3467]
[3468]
[3469]
[3470]
[3471]
[3472]
[3473]
[3474]
[3475]
[3476]
[3477]
[3478]
[3479]
[3480]
[3481]
[3482]
[3483]
[3484]
[3485]
[3486]
[3487]
[3488]
[3489]
[3490]
[3491]
[3492]
[3493]
[3494]
[3495]
[3496]
[3497]
[3498]
[3499]
[3500]
[3501]
[3502]
[3503]
[3504]
[3505]
[3506]
[3507]
[3508]
[3509]
[3510]
[3511]
[3512]
[3513]
[3514]
[3515]
[3516]
[3517]
[3518]
[3519]
[3520]
[3521]
[3522]
[3523]
[3524]
[3525]
[3526]
[3527]
[3528]
[3529]
[3530]
[3531]
[3532]
[3533]
[3534]
[3535]
[3536]
[3537]
[3538]
[3539]
[3540]
[3541]
[3542]
[3543]
[3544]
[3545]
[3546]
[3547]
[3548]
[3549]
[3550]
[3551]
[3552]
[3553]
[3554]
[3555]
[3556]
[3557]
[3558]
[3559]
[3560]
[3561]
[3562]
[3563]
[3564]
[3565]
[3566]
[3567]
[3568]
[3569]
[3570]
[3571]
[3572]
[3573]
[3574]
[3575]
[3576]
[3577]
[3578]
[3579]
[3580]
[3581]
[3582]
[3583]
[3584]
[3585]
[3586]
[3587]
[3588]
[3589]
[3590]
[3591]
[3592]
[3593]
[3594]
[3595]
[3596]
[3597]
[3598]
[3599]
[3600]
[3601]
[3602]
[3603]
[3604]
[3605]
[3606]
[3607]
[3608]
[3609]
[3610]
[3611]
[3612]
[3613]
[3614]
[3615]
[3616]
[3617]
[3618]
[3619]
[3620]
[3621]
[3622]
[3623]
[3624]
[3625]
[3626]
[3627]
[3628]
[3629]
[3630]
[3631]
[3632]
[3633]
[3634]
[3635]
[3636]
[3637]
[3638]
[3639]
[3640]
[3641]
[3642]
[3643]
[3644]
[3645]
[3646]
[3647]
[3648]
[3649]
[3650]
[3651]
[3652]
[3653]
[3654]
[3655]
[3656]
[3657]
[3658]
[3659]
[3660]
[3661]
[3662]
[3663]
[3664]
[3665]
[3666]
[3667]
[3668]
[3669]
[3670]
[3671]
[3672]
[3673]
[3674]
[3675]
[3676]
[3677]
[3678]
[3679]
[3680]
[3681]
[3682]
[3683]
[3684]
[3685]
[3686]
[3687]
[3688]
[3689]
[3690]
[3691]
[3692]
[3693]
[3694]
[3695]
[3696]
[3697]
[3698]
[3699]
[3700]
[3701]
[3702]
[3703]
[3704]
[3705]
[3706]
[3707]
[3708]
[3709]
[3710]
[3711]
[3712]
[3713]
[3714]
[3715]
[3716]
[3717]
[3718]
[3719]
[3720]
[3721]
[3722]
[3723]
[3724]
[3725]
[3726]
[3727]
[3728]
[3729]
[3730]
[3731]
[3732]
[3733]
[3734]
[3735]
[3736]
[3737]
[3738]
[3739]
[3740]
[3741]
[3742]
[3743]
[3744]
[3745]
[3746]
[3747]
[3748]
[3749]
[3750]
[3751]
[3752]
[3753]
[3754]
[3755]
[3756]
[3757]
[3758]
[3759]
[3760]
[3761]
[3762]
[3763]
[3764]
[3765]
[3766]
[3767]
[3768]
[3769]
[3770]
[3771]
[3772]
[3773]
[3774]
[3775]
[3776]
[3777]
[3778]
[3779]
[3780]
[3781]
[3782]
[3783]
[3784]
[3785]
[3786]
[3787]
[3788]
[3789]
[3790]
[3791]
[3792]
[3793]
[3794]
[3795]
[3796]
[3797]
[3798]
[3799]
[3800]
[3801]
[3802]
[3803]
[3804]
[3805]
[3806]
[3807]
[3808]
[3809]
[3810]
[3811]
[3812]
[3813]
[3814]
[3815]
[3816]
[3817]
[3818]
[3819]
[3820]
[3821]
[3822]
[3823]
[3824]
[3825]
[3826]
[3827]
[3828]
[3829]
[3830]
[3831]
[3832]
[3833]
[3834]
[3835]
[3836]
[3837]
[3838]
[3839]
[3840]
[3841]
[3842]
[3843]
[3844]
[3845]
[3846]
[3847]
[3848]
[3849]
[3850]
[3851]
[3852]
[3853]
[3854]
[3855]
[3856]
[3857]
[3858]
[3859]
[3860]
[3861]
[3862]
[3863]
[3864]
[3865]
[3866]
[3867]
[3868]
[3869]
[3870]
[3871]
[3872]
[3873]
[3874]
[3875]
[3876]
[3877]
[3878]
[3879]
[3880]
[3881]
[3882]
[3883]
[3884]
[3885]
[3886]
[3887]
[3888]
[3889]
[3890]
[3891]
[3892]
[3893]
[3894]
[3895]
[3896]
[3897]
[3898]
[3899]
[3900]
[3901]
[3902]
[3903]
[3904]
[3905]
[3906]
[3907]
[3908]
[3909]
[3910]
[3911]
[3912]
[3913]
[3914]
[3915]
[3916]
[3917]
[3918]
[3919]
[3920]
[3921]
[3922]
[3923]
[3924]
[3925]
[3926]
[3927]
[3928]
[3929]
[3930]
[3931]
[3932]
[3933]
[3934]
[3935]
[3936]
[3937]
[3938]
[3939]
[3940]
[3941]
[3942]
[3943]
[3944]
[3945]
[3946]
[3947]
[3948]
[3949]
[3950]
[3951]
[3952]
[3953]
[3954]
[3955]
[3956]
[3957]
[3958]
[3959]
[3960]
[3961]
[3962]
[3963]
[3964]
[3965]
[3966]
[3967]
[3968]
[3969]
[3970]
[3971]
[3972]
[3973]
[3974]
[3975]
[3976]
[3977]
[3978]
[3979]
[3980]
[3981]
[3982]
[3983]
[3984]
[3985]
[3986]
[3987]
[3988]
[3989]
[3990]
[3991]
[3992]
[3993]
[3994]
[3995]
[3996]
[3997]
[3998]
[3999]
[4000]
[4001]
[4002]
[4003]
[4004]
[4005]
[4006]
[4007]
[4008]
[4009]
[4010]
[4011]
[4012]
[4013]
[4014]
[4015]
[4016]
[4017]
[4018]
[4019]
[4020]
[4021]
[4022]
[4023]
[4024]
[4025]
[4026]
[4027]
[4028]
[4029]
[4030]
[4031]
[4032]
[4033]
[4034]
[4035]
[4036]
[4037]
[4038]
[4039]
[4040]
[4041]
[4042]
[4043]
[4044]
[4045]
[4046]
[4047]
[4048]
[4049]
[4050]
[4051]
[4052]
[4053]
[4054]
[4055]
[4056]
[4057]
[4058]
[4059]
[4060]
[4061]
[4062]
[4063]
[4064]
[4065]
[4066]
[4067]
[4068]
[4069]
[4070]
[4071]
[4072]
[4073]
[4074]
[4075]
[4076]
[4077]
[4078]
[4079]
[4080]
/*****************************************************************************/
/*
ProxyFTP.c
*************
** CAUTION **
*************
THIS MODULE IS TASK-ORIENTED, NOT REQUEST-ORIENTED.
That is, most of the functions take a pointer to proxy task rather than a
pointer to request as do other modules. Many of these functions deal primarily
and immediately with task rather than request data.
Proxied FTP access (well surprise, surprise! - in Gomer Pyle intonation)
This is a moderately long and complex module providing a basic FTP proxy
service capable of stand-alone use (i.e. standard browser) as well with
non-browser applications such as "Windows Commander".
CONTENT TYPE
------------
The content-type of a remote file is determined by the proxy FTP server using
the loaded configuration content types. Why? Well, why not? FTP contains so
information as to the file type or how it should be treated. The proxy server
interpreting it at the local end from the file type (extension) is probably as
good as anything. To provide some further control on how a file is transfered
the {AddType] and [MimeTypes] directives support syntax to indicated how FTP
should transfer the file. If the proxy server interpretation is incorrect then
the client can explicitly specify how the file should be handled.
FILE PATHS
----------
By default all file paths are relative to the login directory. That is path
"/dir2/dir3/file.txt" in anonymous login to "/pub/" refers to the file
"/pub/dir2/dir3/file.txt". The server would do a "CWD ./pub/dir2/dir3/" before
beginning any other activity. If the request file path begins with consecutive
forward-slashes then it will be considered an absolute path and for path
"//pub/dir2/dir3/file.txt" it would do a "CWD /pub/dir2/dir3/" before any
other activity.
QUERY STRING MODIFIERS
----------------------
The following query string keywords may be used to control the behaviour of the
FTP proxy. One or more may be used in appropriate combinations. Unknown
strings are ignored without warning. Many of these are provided to assist in
working around proxy server misinterpretation of remote resources. The client
may explicitly specify how the resource will be accessed or interpreted.
dos process listing as if DOS format
unix process listing as if Unix format
vms process listing as if VMS format
text file(s) returned as "text/plain"
octet file(s) returned as "application/octet-stream"
ascii retrieve file as ASCII (i.e. text)
image retrieve file as a bag-o'-bytes (i.e. binary)
content:string content-type of file(s) (e.g. "?content:text/plain")
content=string content-type of file(s) (e.g. "?content=text/plain")
alt provide alternate access via listing icon
email:string for anonymous FTP servers insisting on a valid email-password
email=string for anonymous FTP servers insisting on a valid email-password
list display in plain-text the LIST command transfer
login server to get username/password via HTTP authentication
raw do not munge file name/size/date
upload supply a form that allows a file to be uploaded
Keywords parsing is designed so that they can be supplied as "?keyword",
"?keyword1+keyword2", "keyword=anything", or
"keyword1=anything&keyword2=anything", or where the keyword occurs as the value
of a form field, for example "?type=ascii". This allows for simply adding the
keyword to the URL or use in an HTML form.
USING THE "LOGIN" QUERY STRING
------------------------------
The usual mechanism for supplying the username and password for access to a
non-anonymous proxied FTP server area is to place it as part of the request
line (i.e. "ftp://username:password@the.host.name/path/"). This has the
obvious disadvantage that it's there for all and sundry to see, in the browser
URL field, in the server logs, in any other caching agent along the network.
Of course all plain-text authentication suffers this fate to a greater or
lesser extent.
The "login" query string is provided to work around the more obvious of these
issues, having the authentication credentials as part of the request URL. When
this string is placed in the request query string the FTP proxy requests the
browser to prompt for authentication (i.e. returns a 401 status). When request
header authentication data is present it decodes the username and password and
uses this as the remote FTP server username and password. Hence the remote
username and password never need to appear in plain-text on screen or in server
logs.
NON-BROWSER PROXY BEHAVIOUR
---------------------------
The ability to interact with non-bowser clients has been refined and tested
against "Windows Commander v4.54". Other clients YMMV.
VERSION HISTORY
---------------
27-APR-2021 MGD BSD 4.4 sockaddr.. IO$M_EXTEND to $QIO
15-AUG-2015 MGD ProxyFtpListOutput() update in line with directory listing
23-JAN-2010 MGD ProxyFtpListProcessUnix() file names containing white-space
04-MAY-2007 MGD ProxyFtpLifeCycle() process HEAD as for GET
10-JUL-2004 MGD bugfix; ProxyFtpPasvData() if PASV response address
is 0.0.0.0 then use connect address
10-APR-2004 MGD modifications to support IPv6
12-JAN-2004 MGD bugfix; ProxyFtpListProcessUnix() maximum fields handling
(thanks Jean-Pierre Petit, jpp@esme.fr)
08-MAR-2003 MGD set html= FTP directory listing header and footer,
add column headings to FTP Index of,
bugfix; ResponseHeader() content-length of zero
29-MAY-2002 MGD allow for a server disconnecting immediately upon QUIT
23-MAR-2002 MGD FTP agent specifics, starting with "MadGoat" DELE (arghh!)
18-MAR-2002 MGD rework directory list processing
26-JAN-2002 MGD initial
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
/* VMS related header files */
#include <descrip.h>
#include <dvidef.h>
#include <iodef.h>
#include <psldef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application-related header files */
#include "wasd.h"
#define WASD_MODULE "PROXYFTP"
/******************/
/* global storage */
/******************/
/********************/
/* external storage */
/********************/
extern int EfnWait,
EfnNoWait,
HttpdTickSecond,
NetReadBufferSize,
ProxyReadBufferSize;
extern int ToLowerCase[],
ToUpperCase[];
extern char ConfigContentTypeBlank[],
ConfigContentTypeDir[],
ConfigDefaultFileContentType[],
ErrorSanityCheck[],
ServerHostPort[],
SoftwareID[];
extern struct dsc$descriptor TcpIpDeviceDsc;
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern MSG_STRUCT Msgs;
extern PROXY_ACCOUNTING_STRUCT *ProxyAccountingPtr;
extern TCP_SOCKET_ITEM TcpIpSocket4,
TcpIpSocket6;
extern VMS_ITEM_LIST2 TcpIpFullDuplexCloseOption;
extern WATCH_STRUCT Watch;
/****************************************************************************/
/*
Controls the state and state transitions of a proxied FTP request.
Generally it's from top to bottom but of course different paths may be taken.
*/
ProxyFtpLifeCycle (PROXY_TASK *tkptr)
{
char *cptr, *sptr, *zptr;
char String [256];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpLifeCycle() !&F !UL !UL",
&ProxyFtpLifeCycle, tkptr->FtpState, tkptr->FtpResponseCode);
rqptr = tkptr->RequestPtr;
switch (tkptr->FtpState)
{
/*********/
/* login */
/*********/
case PROXY_FTP_STATE_NONE : /* actually zero! */
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpCount);
if (!ProxyFtpFilePath (tkptr)) goto QuitNow;
/* determine if a directory listing or file transfer */
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
while (cptr > tkptr->FtpFilePathPtr &&
*cptr != '/' && *cptr != '*') cptr--;
if (*cptr == '*')
{
tkptr->FtpDirList = true;
while (cptr > tkptr->FtpFilePathPtr && *cptr != '/') cptr--;
if (*cptr == '/') cptr++;
tkptr->FtpWildPtr = cptr;
}
else
if (SAME2(cptr,'/\0'))
{
tkptr->FtpDirList = true;
tkptr->FtpWildPtr = "";
}
else
tkptr->FtpDirList = false;
/* read the FTP server's announcement */
tkptr->FtpState = PROXY_FTP_STATE_USER;
ProxyFtpResponse (tkptr);
break;
case PROXY_FTP_STATE_USER :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
tkptr->FtpState = PROXY_FTP_STATE_USER_DONE;
if (rqptr->RemoteUser[0])
ProxyFtpCommand (tkptr, true, "USER !AZ", rqptr->RemoteUser);
else
if (tkptr->UrlUserName[0])
ProxyFtpCommand (tkptr, true, "USER !AZ", tkptr->UrlUserName);
else
ProxyFtpCommand (tkptr, true, "USER anonymous");
break;
case PROXY_FTP_STATE_USER_DONE :
if (tkptr->FtpResponseClass > 3)
{
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpLoginFailCount);
goto QuitNow;
}
if (tkptr->FtpResponseCode == 331)
{
tkptr->FtpState = PROXY_FTP_STATE_PASS_DONE;
if (rqptr->RemoteUser[0])
ProxyFtpCommand (tkptr, true, "PASS !AZ",
rqptr->RemoteUserPassword);
else
if (tkptr->UrlPassword[0])
ProxyFtpCommand (tkptr, true, "PASS !AZ",
tkptr->UrlPassword);
else
if (tkptr->UrlUserName[0])
ProxyFtpCommand (tkptr, true, "PASS !AZ@!AZ",
tkptr->UrlUserName,
rqptr->ServicePtr->ServerIpAddressString);
else
{
cptr = rqptr->rqHeader.QueryStringPtr;
if (cptr[0] && (sptr = ProxyFtpInQueryString (cptr, "email:")))
{
/* keyword style */
cptr = sptr + 6;
zptr = (sptr = String) + sizeof(String)-1;
while (*cptr && *cptr != '+' && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
ProxyFtpCommand (tkptr, true, "PASS !AZ", String);
}
else
if (cptr[0] && (sptr = ProxyFtpInQueryString (cptr, "email=")))
{
/* form field style */
cptr = sptr + 6;
zptr = (sptr = String) + sizeof(String)-1;
while (*cptr && *cptr != '&' && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
ProxyFtpCommand (tkptr, true, "PASS !AZ", String);
}
else
ProxyFtpCommand (tkptr, true, "PASS proxy@!AZ",
rqptr->ServicePtr->ServerHostName);
}
break;
}
/* otherwise just drop thru, password not required! */
case PROXY_FTP_STATE_PASS_DONE :
if (tkptr->FtpResponseClass > 3)
{
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpLoginFailCount);
goto QuitNow;
}
if (tkptr->FtpResponseCode == 230) ProxyFtpResponse230 (tkptr);
tkptr->FtpState = PROXY_FTP_STATE_SYST_DONE;
ProxyFtpCommand (tkptr, true, "SYST");
break;
/*****************/
/* now logged in */
/*****************/
case PROXY_FTP_STATE_SYST_DONE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
zptr = (sptr = tkptr->FtpSYST) + sizeof(tkptr->FtpSYST)-1;
for (cptr = tkptr->FtpResponsePtr+4; *cptr && ISLWS(*cptr); cptr++);
while (*cptr && NOTEOL(*cptr) && sptr < zptr)
{
if (*cptr == '\"')
*sptr++ = '\'';
else
*sptr++ = *cptr;
cptr++;
}
*sptr = '\0';
if (strstr (tkptr->FtpSYST, "MadGoat"))
tkptr->FtpSpecific = PROXY_FTP_SPECIFIC_MADGOAT;
tkptr->FtpState = PROXY_FTP_STATE_PWD_DONE;
ProxyFtpCommand (tkptr, true, "PWD");
break;
case PROXY_FTP_STATE_PWD_DONE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
ProxyFtpRemoteFileSystem (tkptr);
if (tkptr->HttpMethod == HTTP_METHOD_DELETE)
tkptr->FtpState = PROXY_FTP_STATE_DELE;
else
tkptr->FtpState = PROXY_FTP_STATE_CWD_DONE;
ProxyFtpCwd (tkptr);
break;
case PROXY_FTP_STATE_CWD_DONE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
zptr = (sptr = tkptr->FtpCWD) + sizeof(tkptr->FtpCWD)-1;
for (cptr = tkptr->FtpResponsePtr+4; *cptr && ISLWS(*cptr); cptr++);
while (*cptr && NOTEOL(*cptr) && sptr < zptr)
{
if (*cptr == '\"')
*sptr++ = '\'';
else
*sptr++ = *cptr;
cptr++;
}
*sptr = '\0';
tkptr->FtpState = PROXY_FTP_STATE_PASV_DONE;
ProxyFtpCommand (tkptr, true, "PASV");
break;
case PROXY_FTP_STATE_PASV_DONE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* process the IP address and port supplied by the PASV response */
if (!ProxyFtpPasvData (tkptr))
{
ProxyFtpResponseInvalid (tkptr);
goto QuitNow;
}
if (tkptr->HttpMethod == HTTP_METHOD_POST ||
tkptr->HttpMethod == HTTP_METHOD_PUT)
tkptr->FtpState = PROXY_FTP_STATE_STOR;
else
if (tkptr->HttpMethod == HTTP_METHOD_GET ||
tkptr->HttpMethod == HTTP_METHOD_HEAD)
{
/* determine if a directory listing or file transfer */
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
while (cptr > tkptr->FtpFilePathPtr &&
*cptr != '/' && *cptr != '*') cptr--;
if (*cptr == '*' || SAME2(cptr,'/\0'))
tkptr->FtpState = PROXY_FTP_STATE_LIST;
else
tkptr->FtpState = PROXY_FTP_STATE_RETR_MODE;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
/* connect to the address and port specified by the PASV response */
ProxyFtpDataConnect (tkptr);
break;
/*********************/
/* directory listing */
/*********************/
case PROXY_FTP_STATE_LIST :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* send the file system specific command for a directory listing */
tkptr->FtpState = PROXY_FTP_STATE_LIST_RECEIVE;
ProxyFtpList (tkptr);
break;
case PROXY_FTP_STATE_LIST_RECEIVE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
tkptr->FtpState = PROXY_FTP_STATE_LIST_CHECK;
/* transfer the listing */
ProxyFtpListReceive (tkptr);
break;
case PROXY_FTP_STATE_LIST_CHECK :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* get so we can check the transfer complete response */
tkptr->FtpState = PROXY_FTP_STATE_LIST_PROCESS;
ProxyFtpResponse (tkptr);
break;
case PROXY_FTP_STATE_LIST_PROCESS :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* format and output the directory listing */
tkptr->FtpState = PROXY_FTP_STATE_QUIT;
ProxyFtpListProcess (tkptr);
break;
/*********************/
/* retrieving a file */
/*********************/
case PROXY_FTP_STATE_RETR_MODE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* send the command for binary or ASCII transfer */
tkptr->FtpState = PROXY_FTP_STATE_RETR;
ProxyFtpRetrieveMode (tkptr);
break;
case PROXY_FTP_STATE_RETR :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* send the command to retrieve the file */
tkptr->FtpState = PROXY_FTP_STATE_RETR_FILE;
ProxyFtpRetrieve (tkptr);
break;
case PROXY_FTP_STATE_RETR_FILE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
tkptr->FtpState = PROXY_FTP_STATE_RETR_DONE;
/* transfer the file */
ProxyFtpRetrieveAst (tkptr);
break;
case PROXY_FTP_STATE_RETR_DONE :
/* get the response to the file transfer */
tkptr->FtpState = PROXY_FTP_STATE_QUIT;
ProxyFtpResponse (tkptr);
break;
/******************/
/* storing a file */
/******************/
case PROXY_FTP_STATE_STOR :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* begin request body (file), will initiate the STOR command */
tkptr->FtpState = PROXY_FTP_STATE_STOR_TYPE;
ProxyFtpStoreBodyReadBegin (tkptr);
break;
case PROXY_FTP_STATE_STOR_TYPE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* TYPE sent, go back to transfering the request body (file) */
tkptr->FtpState = PROXY_FTP_STATE_STOR_FILE;
ProxyFtpStoreBodyReadAst (tkptr->RequestPtr);
break;
case PROXY_FTP_STATE_STOR_FILE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* STOR sent, go back to transfering the request body (file) */
tkptr->FtpState = PROXY_FTP_STATE_STOR_CHECK;
ProxyFtpStoreBodyReadAst (tkptr->RequestPtr);
break;
case PROXY_FTP_STATE_STOR_CHECK :
/* get the response to the file transfer */
tkptr->FtpState = PROXY_FTP_STATE_STOR_DONE;
ProxyFtpResponse (tkptr);
break;
case PROXY_FTP_STATE_STOR_DONE :
/* get the response to the file transfer */
if (tkptr->FtpResponseClass > 3) goto QuitNow;
for (cptr = tkptr->FtpResponsePtr; NOTEOL(*cptr); cptr++);
*cptr = '\0';
for (cptr = tkptr->FtpResponsePtr+4; ISLWS(*cptr); cptr++);
ReportSuccess (rqptr, "!AZ !&;AZ",
MsgFor(rqptr,MSG_PROXY_FTP_SERVER_REPLIED), cptr);
tkptr->FtpState = PROXY_FTP_STATE_QUIT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
break;
/*******************/
/* deleting a file */
/*******************/
case PROXY_FTP_STATE_DELE :
if (tkptr->FtpResponseClass > 3) goto QuitNow;
/* just delete the file */
tkptr->FtpState = PROXY_FTP_STATE_DELE_DONE;
ProxyFtpDelete (tkptr);
break;
case PROXY_FTP_STATE_DELE_DONE :
/* get the response to the file transfer */
if (tkptr->FtpResponseClass > 3) goto QuitNow;
for (cptr = tkptr->FtpResponsePtr; NOTEOL(*cptr); cptr++);
*cptr = '\0';
for (cptr = tkptr->FtpResponsePtr+4; ISLWS(*cptr); cptr++);
ReportSuccess (rqptr, "!AZ !&;AZ",
MsgFor(rqptr,MSG_PROXY_FTP_SERVER_REPLIED), cptr);
tkptr->FtpState = PROXY_FTP_STATE_QUIT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
break;
/********/
/* quit */
/********/
case PROXY_FTP_STATE_QUIT :
tkptr->FtpState = PROXY_FTP_STATE_QUIT_DONE;
ProxyFtpCommand (tkptr, true, "QUIT");
break;
case PROXY_FTP_STATE_ABORT :
case PROXY_FTP_STATE_QUIT_DONE :
ProxyFtpDataCloseSocket (tkptr);
ProxyEnd (tkptr);
break;
default :
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
return;
/* where's Dijkstra when you really need him? */
QuitNow :
for (cptr = tkptr->FtpResponsePtr; NOTEOL(*cptr); cptr++);
*cptr = '\0';
for (cptr = tkptr->FtpResponsePtr+4; ISLWS(*cptr); cptr++);
/* bogus status code 599 is used to represent WASD generated errors */
if (tkptr->FtpResponseCode < 599)
{
ProxyFtpHttpStatus (tkptr);
FaoToBuffer (String, sizeof(String), NULL, "!AZ !&;AZ",
MsgFor(rqptr,MSG_PROXY_FTP_SERVER_REPLIED), cptr);
ErrorGeneral (rqptr, String, FI_LI);
}
else
{
rqptr->rqResponse.HttpStatus = 502;
ErrorGeneral (rqptr, tkptr->FtpResponsePtr+4, FI_LI);
}
tkptr->FtpState = PROXY_FTP_STATE_QUIT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
Format a command string and write it to the FTP server. Optionally get a
response back from the server. If 'GetResponse' is true this function will AST
to ProxyFtpResponse() to initiate the read. In this case the AST function
should check the read IO status block for success. If no response is required
the AST function should check the write IO status block. If 'FormatString' is
NULL then consider the command buffer to already contain a formatted command.
*/
ProxyFtpCommand
(
PROXY_TASK *tkptr,
BOOL GetResponse,
char *FormatString,
...
)
{
int argcnt, status;
unsigned long *vecptr;
unsigned long FaoVector [32];
PROXY_AST AstFunction;
REQUEST_STRUCT *rqptr;
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpCommand() !&B !UL !&Z",
GetResponse, argcnt, FormatString);
rqptr = tkptr->RequestPtr;
if (!tkptr->FtpCommandPtr)
{
/* first command issued, allocate buffer space */
tkptr->FtpCommandSize = PROXY_FTP_COMMAND_SIZE;
tkptr->FtpCommandPtr = VmGetHeap (rqptr, tkptr->FtpCommandSize);
}
if (FormatString)
{
if (argcnt > 32+3)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 3; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, unsigned long);
va_end (argptr);
status = FaolSAK (NULL,
tkptr->FtpCommandPtr,
tkptr->FtpCommandSize-2,
&tkptr->FtpCommandCount,
FormatString, &FaoVector);
if (VMSnok (status))
{
tkptr->NetIoPtr->WriteStatus = status;
tkptr->NetIoPtr->WriteCount = 0;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
return;
}
/* append required carriage-control */
tkptr->FtpCommandPtr[tkptr->FtpCommandCount++] = '\r';
tkptr->FtpCommandPtr[tkptr->FtpCommandCount++] = '\n';
}
if (WATCHING (tkptr, WATCH_PROXY))
{
char *cptr, *sptr;
cptr = sptr = tkptr->FtpCommandPtr;
while (*cptr && *cptr != '\r' && *cptr != '\n') cptr++;
if (MATCH4 (sptr, "PASS"))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
">>PASS !#**", cptr-sptr-5);
else
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
">>!#AZ", cptr-sptr, sptr);
}
if (GetResponse)
AstFunction = &ProxyFtpCommandResponseAst;
else
AstFunction = &ProxyFtpCommandAst;
ProxyNetWrite (tkptr, AstFunction,
tkptr->FtpCommandPtr,
tkptr->FtpCommandCount);
}
/****************************************************************************/
/*
Check the write status and if successful AST back to the function originally
supplied to ProxyFtpCommand(). If command write unsuccessful terminate the
request.
*/
ProxyFtpCommandAst (PROXY_TASK *tkptr)
{
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpCommandAst() !&F !&S !UL", &ProxyFtpCommandAst,
tkptr->NetIoPtr->WriteStatus, tkptr->NetIoPtr->WriteCount);
if (VMSok (tkptr->NetIoPtr->WriteStatus))
{
SysDclAst (&ProxyFtpLifeCycle, tkptr);
return;
}
/* error writing to the remote FTP server */
rqptr = tkptr->RequestPtr;
rqptr->rqResponse.HttpStatus = 502;
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
ErrorVmsStatus (rqptr, tkptr->NetIoPtr->WriteStatus, FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_ABORT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
This is AST is used only if 'GetResponse' was true. Check the write status and
if successful read the FTP server's response. If command write unsuccessful
terminate the request.
*/
ProxyFtpCommandResponseAst (PROXY_TASK *tkptr)
{
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpCommandResponseAst() !&F !&S !UL",
&ProxyFtpCommandAst,
tkptr->NetIoPtr->WriteStatus, tkptr->NetIoPtr->WriteCount);
if (VMSok (tkptr->NetIoPtr->WriteStatus))
{
ProxyFtpResponse (tkptr);
return;
}
/* error writing to the remote FTP server */
rqptr = tkptr->RequestPtr;
rqptr->rqResponse.HttpStatus = 502;
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
ErrorVmsStatus (rqptr, tkptr->NetIoPtr->WriteStatus, FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_ABORT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
Read the response from the remote FTP server.
*/
ProxyFtpResponse (PROXY_TASK *tkptr)
{
char *cptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpResponse() !&F !&S !UL !&X", &ProxyFtpResponse,
tkptr->NetIoPtr->WriteStatus, tkptr->NetIoPtr->WriteCount,
tkptr->FtpNextResponsePtr);
rqptr = tkptr->RequestPtr;
if (!tkptr->FtpResponsePtr)
{
/* first response, allocate receive buffer */
tkptr->FtpResponseSize = ProxyReadBufferSize;
tkptr->FtpResponsePtr = VmGetHeap (rqptr, tkptr->FtpResponseSize);
tkptr->FtpResponseCurrentPtr = tkptr->FtpResponsePtr;
}
if (tkptr->FtpResponseCurrentPtr == tkptr->FtpResponsePtr)
{
/* start of new response, reset buffer and data */
tkptr->FtpResponseRemaining = tkptr->FtpResponseSize;
tkptr->FtpResponseCode = tkptr->FtpResponseClass =
tkptr->FtpResponseCount = tkptr->FtpResponseLineCount = 0;
}
if (tkptr->FtpNextResponsePtr)
{
/* previous "response" contained at least two responses! */
for (cptr = tkptr->FtpNextResponsePtr; *cptr; cptr++);
memcpy (tkptr->FtpResponsePtr,
tkptr->FtpNextResponsePtr,
cptr - tkptr->FtpNextResponsePtr+1);
/* fudge this an an actual network read! */
tkptr->NetIoPtr->ReadStatus = SS$_NORMAL;
tkptr->NetIoPtr->ReadCount = cptr - tkptr->FtpNextResponsePtr;
SysDclAst (&ProxyFtpResponseAst, tkptr);
return;
}
if (tkptr->FtpResponseRemaining < PROXY_FTP_RESPONSE_LOW_BUFFER)
{
/* buffer space is getting a bit low, reallocate */
tkptr->FtpResponseSize += ProxyReadBufferSize;
tkptr->FtpResponseRemaining += ProxyReadBufferSize;
tkptr->FtpResponsePtr =
VmReallocHeap (rqptr, tkptr->FtpResponsePtr,
tkptr->FtpResponseSize, FI_LI);
tkptr->FtpResponseCurrentPtr = tkptr->FtpResponsePtr +
tkptr->FtpResponseSize -
tkptr->FtpResponseRemaining;
}
ProxyNetRead (tkptr, &ProxyFtpResponseAst,
tkptr->FtpResponseCurrentPtr,
tkptr->FtpResponseRemaining);
}
/****************************************************************************/
/*
A response has been read from the FTP server. If successful AST to the
function originally supplied to ProxyFtpRequest(), if unsuccessful just
terminate the request.
*/
ProxyFtpResponseAst (PROXY_TASK *tkptr)
{
BOOL ResponseContinued;
int ResponseCount;
char *cptr, *dptr, *sptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpResponseAst() !&F !&S !UL", &ProxyFtpResponseAst,
tkptr->NetIoPtr->ReadStatus, tkptr->NetIoPtr->ReadCount);
ResponseCount = 0;
tkptr->FtpNextResponsePtr = NULL;
if (VMSok (tkptr->NetIoPtr->ReadStatus))
{
cptr = tkptr->FtpResponseCurrentPtr;
tkptr->FtpResponseCount += tkptr->NetIoPtr->ReadCount;
tkptr->FtpResponseCurrentPtr += tkptr->NetIoPtr->ReadCount;
tkptr->FtpResponseRemaining -= tkptr->NetIoPtr->ReadCount;
*tkptr->FtpResponseCurrentPtr = '\0';
for (sptr = cptr; *sptr; sptr++)
{
if (*sptr != '\r' && *sptr != '\n') continue;
/* some Microsoft servers seem to "\r\r\n" (?) e.g. Compaq */
if (MATCH3 (sptr, "\r\r\n"))
{
/* just turn the leading '\r' into a (hopefully) harmless space */
*sptr = ' ';
continue;
}
while (*sptr == '\r' || *sptr == '\n') sptr++;
if (!*sptr)
{
sptr = NULL;
break;
}
}
if (sptr)
{
/* response not yet terminated by carriage control, get more */
ProxyFtpResponse (tkptr);
return;
}
/* non-continued response terminated by carriage-control */
ResponseContinued = false;
cptr = tkptr->FtpResponsePtr;
for (;;)
{
if (cptr > tkptr->FtpResponsePtr && *cptr == ' ')
{
/* a 'logical' line with embedded carriage-control */
cptr++;
}
else
if ((cptr[0] == '1' ||
cptr[0] == '2' ||
cptr[0] == '3' ||
cptr[0] == '4' ||
cptr[0] == '5') &&
isdigit(cptr[1]) &&
isdigit(cptr[2]))
{
/* establish the success or otherwise of the response */
if (!tkptr->FtpResponseCode)
{
/* use the status of the first response line */
tkptr->FtpResponseClass = cptr[0] - '0';
tkptr->FtpResponseCode = atoi(cptr);
}
if (cptr[3] == '-')
ResponseContinued = true;
else
{
ResponseContinued = false;
if (ResponseCount++) tkptr->FtpNextResponsePtr = cptr;
}
}
else
{
if (WATCHING (tkptr, WATCH_PROXY))
WatchDataDump (tkptr->FtpResponsePtr,
tkptr->FtpResponseCount);
ProxyFtpResponseInvalid (tkptr);
return;
}
/* find the start of the next 'physical' line */
while (*cptr && *cptr != '\r' && *cptr != '\n') cptr++;
while (*cptr == '\r' || *cptr == '\n') cptr++;
tkptr->FtpResponseLineCount++;
if (!*cptr) break;
}
/* end of buffer */
if (ResponseContinued)
{
/* this response is to be continued with at least another line */
ProxyFtpResponse (tkptr);
}
else
{
/* indicate that the next response read is a totally fresh one */
tkptr->FtpResponseCurrentPtr = tkptr->FtpResponsePtr;
if (WATCHING (tkptr, WATCH_PROXY))
{
sptr = tkptr->FtpResponsePtr;
cptr--;
while (cptr > sptr && *cptr == '\r' || *cptr == '\n') cptr--;
if (cptr > sptr) cptr++;
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"<<!#AZ", cptr-sptr, sptr);
}
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
return;
}
if (tkptr->FtpState == PROXY_FTP_STATE_QUIT_DONE &&
tkptr->FtpDataReadIOsb.Status == SS$_LINKDISCON)
{
/* can live with the FTP server disconnecting immediately upon QUIT */
tkptr->FtpDataReadIOsb.Status = SS$_NORMAL;
tkptr->FtpResponseClass = 2;
tkptr->FtpResponseCode = 221;
tkptr->FtpResponsePtr = "221 Session was disconnected by remote server!";
tkptr->FtpResponseCurrentPtr = tkptr->FtpResponsePtr;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
return;
}
/* error reading from the remote FTP server */
rqptr = tkptr->RequestPtr;
rqptr->rqResponse.HttpStatus = 502;
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
ErrorVmsStatus (rqptr, tkptr->NetIoPtr->ReadStatus, FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_ABORT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
Couldn't understand the FTP server's response. Create a bogus FTP-like status
line and appropriate status values to indicate this. Set the state to QUIT and
declare the state processor so that the calling routine should return
imediately after calling this function.
*/
ProxyFtpResponseInvalid (PROXY_TASK *tkptr)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpResponseInvalid()");
tkptr->FtpResponseClass = 5;
tkptr->FtpResponseCode = 599;
strcpy (tkptr->FtpResponsePtr, "599 Invalid response from FTP server.");
tkptr->FtpResponseCount = strlen(tkptr->FtpResponsePtr);
tkptr->FtpState = PROXY_FTP_STATE_QUIT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
The server has returned a 230 response status. This is where site
announcements are often delivered. Get the contents of this response for use
in the directory listing page.
*/
ProxyFtpResponse230 (PROXY_TASK *tkptr)
{
char *cptr, *sptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpResponse230() !UL", tkptr->FtpResponseLineCount);
if (tkptr->FtpResponseLineCount <= 2) return;
rqptr = tkptr->RequestPtr;
/* won't be using -more- than this memory */
sptr = tkptr->Ftp230Ptr = VmGetHeap (rqptr, tkptr->FtpResponseCount);
cptr = tkptr->FtpResponsePtr;
while (*cptr)
{
if (cptr[3] == '-')
{
cptr += 4;
while (*cptr)
{
while (*cptr && *cptr != '\r' && *cptr != '\n') *sptr++ = *cptr++;
while (*cptr == '\r') cptr++;
if (*cptr == '\n') *sptr++ = *cptr++;
if (*cptr != ' ') break;
}
}
else
{
while (*cptr)
{
while (*cptr && *cptr != '\r' && *cptr != '\n') cptr++;
while (*cptr == '\n' || *cptr == '\r') cptr++;
if (*cptr != ' ') break;
}
}
}
/* looks better on the page if trailing newlines are suppressed */
while (sptr > tkptr->Ftp230Ptr && *(sptr-1) == '\n') sptr--;
*sptr = '\0';
tkptr->Ftp230Length = sptr - tkptr->Ftp230Ptr;
}
/****************************************************************************/
/*
Generate a URL-decoded file path from the request URI.
*/
BOOL ProxyFtpFilePath (PROXY_TASK *tkptr)
{
int Length;
char *cptr, *sptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpFilePath() !&Z", tkptr->RequestUriPtr);
rqptr = tkptr->RequestPtr;
for (sptr = tkptr->RequestUriPtr; *sptr && *sptr != '?'; sptr++);
Length = sptr - tkptr->RequestUriPtr;
tkptr->FtpFilePathPtr = VmGetHeap (rqptr, Length+1);
memcpy (tkptr->FtpFilePathPtr, tkptr->RequestUriPtr, Length);
tkptr->FtpFilePathPtr[Length] = '\0';
/* we know the decode will be OK because the path has already been done! */
Length = StringUrlDecode (tkptr->FtpFilePathPtr);
if (Length == -1) return (false);
tkptr->FtpFilePathLength = Length;
return (true);
}
/****************************************************************************/
/*
Try and determine the remote file system type from the PWD response.
*/
ProxyFtpRemoteFileSystem (PROXY_TASK *tkptr)
{
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpRemoteFileSystem()");
tkptr->FtpFileSystem = PROXY_FTP_FILE_SYSTEM_UNKNOWN;
tkptr->FtpFileSystemPtr = "unknown";
cptr = tkptr->FtpResponsePtr + 4;
while (*cptr)
{
if (*cptr == '/')
{
tkptr->FtpFileSystem = PROXY_FTP_FILE_SYSTEM_UNIX;
tkptr->FtpFileSystemPtr = "Unix";
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpUnixCount);
break;
}
if (*cptr == '\\')
{
tkptr->FtpFileSystem = PROXY_FTP_FILE_SYSTEM_DOS;
tkptr->FtpFileSystemPtr = "DOS";
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpDosCount);
break;
}
if (SAME2(cptr,':['))
{
tkptr->FtpFileSystem = PROXY_FTP_FILE_SYSTEM_VMS;
tkptr->FtpFileSystemPtr = "VMS";
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpVmsCount);
break;
}
cptr++;
}
if (!*cptr) InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpUnknownCount);
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"FILE-SYSTEM !AZ", tkptr->FtpFileSystemPtr);
}
/****************************************************************************/
/*
Issue a Change Working Directory (CWD) command. The URI path specification
needs to be massaged according to file system specifics.
*/
ProxyFtpCwd (PROXY_TASK *tkptr)
{
int DirCount;
char *cptr, *dptr, *sptr, *zptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY, "ProxyFtpCwd()");
rqptr = tkptr->RequestPtr;
DirCount = 0;
for (cptr = tkptr->FtpFilePathPtr + 1; *cptr; *cptr++)
if (*cptr == '/') DirCount++;
if (!DirCount)
{
/* root of FTP directory structure, no CWD required */
SysDclAst (&ProxyFtpLifeCycle, tkptr);
return;
}
zptr = (sptr = tkptr->FtpCommandPtr) + tkptr->FtpCommandSize - 1;
SET4(sptr,'CWD ');
sptr += 4;
cptr = tkptr->FtpFilePathPtr;
if (tkptr->FtpFileSystem == PROXY_FTP_FILE_SYSTEM_VMS)
{
if (SAME2(cptr,'//'))
{
/* absolute path */
cptr += 2;
while (*cptr && *cptr != '/' && sptr < zptr) *sptr++ = *cptr++;
if (*cptr) cptr++;
if (sptr < zptr) *sptr++ = ':';
if (sptr < zptr) *sptr++ = '[';
DirCount = 0;
dptr = sptr;
while (*cptr && sptr < zptr)
{
while (*cptr && *cptr != '/' && sptr < zptr) *sptr++ = *cptr++;
if (*cptr)
{
/* just another directory */
DirCount++;
cptr++;
dptr = sptr;
if (sptr < zptr) *sptr++ = '.';
}
}
sptr = dptr;
if (!DirCount)
{
if (sptr < zptr) *sptr++ = '0';
if (sptr < zptr) *sptr++ = '0';
if (sptr < zptr) *sptr++ = '0';
if (sptr < zptr) *sptr++ = '0';
if (sptr < zptr) *sptr++ = '0';
if (sptr < zptr) *sptr++ = '0';
}
*sptr++ = ']';
}
else
{
if (*cptr) cptr++;
*sptr++ = '[';
*sptr++ = '.';
dptr = sptr;
while (*cptr && sptr < zptr)
{
while (*cptr && *cptr != '/' && sptr < zptr) *sptr++ = *cptr++;
if (*cptr)
{
/* just another directory */
cptr++;
dptr = sptr;
if (sptr < zptr) *sptr++ = '.';
}
}
sptr = dptr;
*sptr++ = ']';
}
}
else
{
if (!SAME2(cptr,'//'))
{
/* if not an absolute path */
*sptr++ = '.';
*sptr++ = '/';
}
if (*cptr) cptr++;
dptr = sptr;
while (*cptr && sptr < zptr)
{
if (*cptr == '/') dptr = sptr;
*sptr++ = *cptr++;
}
sptr = dptr;
if (tkptr->FtpFileSystem == PROXY_FTP_FILE_SYSTEM_DOS)
{
/* for DOS, turn each forward slash into a back-slash */
*sptr = '\0';
for (cptr = tkptr->FtpCommandPtr + 4; *cptr; cptr++)
if (*cptr == '/') *cptr = '\\';
}
}
if (sptr < zptr) *sptr++ = '\r';
if (sptr < zptr) *sptr++ = '\n';
*sptr = '\0';
if (sptr >= zptr) ErrorNoticed (rqptr, SS$_BUFFEROVF, NULL, FI_LI);
/* length must be set if we're going to play with the buffer directly */
tkptr->FtpCommandCount = sptr - tkptr->FtpCommandPtr;
ProxyFtpCommand (tkptr, true, NULL);
}
/****************************************************************************/
/*
Parse the IP address and port from the PASV response into the FTP data IP
address and port storage. If there's a problem return false otherwise true.
*/
BOOL ProxyFtpPasvData (PROXY_TASK *tkptr)
{
int cnt;
int PasvOctets [6];
char *cptr, *sptr;
unsigned char *optr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpPasvData() !&Z", tkptr->FtpResponsePtr);
cptr = tkptr->FtpResponsePtr + 4;
while (*cptr != '(') cptr++;
cnt = sscanf (cptr, "(%d,%d,%d,%d,%d,%d)",
&PasvOctets[0], &PasvOctets[1], &PasvOctets[2],
&PasvOctets[3], &PasvOctets[4], &PasvOctets[5]);
if (cnt != 6) return (false);
if (IPADDRESS_IS_V4 (&tkptr->ConnectIpAddress))
{
IPADDRESS_ZERO4 (&tkptr->FtpDataIpAddress)
optr = IPADDRESS_ADR4 (&tkptr->FtpDataIpAddress);
for (cnt = 0; cnt < 4; cnt++)
{
if (PasvOctets[cnt] < 0 || PasvOctets[cnt] > 255) return (false);
*optr++ = PasvOctets[cnt];
}
/* if PASV response address is 0.0.0.0 then use connect address */
if (!IPADDRESS_IS_SET (&tkptr->FtpDataIpAddress))
IPADDRESS_COPY (&tkptr->FtpDataIpAddress, &tkptr->ConnectIpAddress)
}
else
if (IPADDRESS_IS_V6 (&tkptr->ConnectIpAddress))
{
/* the convention is for IPv6 clients to ignore the supplied address */
IPADDRESS_COPY (&tkptr->FtpDataIpAddress, &tkptr->ConnectIpAddress)
}
else
return (false);
tkptr->FtpDataIpPort = 0;
optr = &tkptr->FtpDataIpPort;
for (cnt = 4; cnt < 6; cnt++)
{
if (PasvOctets[cnt] < 0 || PasvOctets[cnt] > 255) return (false);
*optr++ = PasvOctets[cnt];
}
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"!&I,!UL", &tkptr->FtpDataIpAddress, tkptr->FtpDataIpPort);
if (IPADDRESS_IS_SET (&tkptr->FtpDataIpAddress) && tkptr->FtpDataIpPort)
return (true);
else
return (false);
}
/****************************************************************************/
/*
Generate a directory listing command appropriate to the environment.
*/
ProxyFtpList (PROXY_TASK *tkptr)
{
int status;
char *cptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY, "ProxyFtpList()");
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpListCount);
switch (tkptr->FtpFileSystem)
{
case PROXY_FTP_FILE_SYSTEM_DOS :
ProxyFtpCommand (tkptr, true, "NLIST!AZ!AZ",
tkptr->FtpWildPtr[0] ? " " : "", tkptr->FtpWildPtr);
break;
case PROXY_FTP_FILE_SYSTEM_UNIX :
ProxyFtpCommand (tkptr, true, "LIST!AZ!AZ",
tkptr->FtpWildPtr[0] ? " " : "", tkptr->FtpWildPtr);
break;
case PROXY_FTP_FILE_SYSTEM_VMS :
if (tkptr->FtpWildPtr[0])
{
/* need to constrain or allow version numbers */
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
while (cptr > tkptr->FtpFilePathPtr &&
*cptr != '/' && *cptr != ';') cptr--;
if (*cptr == ';')
ProxyFtpCommand (tkptr, true, "LIST !AZ", tkptr->FtpWildPtr);
else
ProxyFtpCommand (tkptr, true, "LIST !AZ;0", tkptr->FtpWildPtr);
}
else
ProxyFtpCommand (tkptr, true, "LIST *.*;0");
break;
default :
ProxyFtpCommand (tkptr, true, "NLIST!AZ!AZ",
tkptr->FtpWildPtr[0] ? " " : "", tkptr->FtpWildPtr);
}
/* reset the IO status block for the first read */
tkptr->FtpDataReadIOsb.Status = tkptr->FtpDataReadIOsb.Count = 0;
}
/****************************************************************************/
/*
Received a chunk of a directory lsiting from the remote server. After checking
the netwrok read status and it being OK add this to the dynamically allocated
listing buffer and then read some more.
*/
ProxyFtpListReceive (PROXY_TASK *tkptr)
{
int status;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpListReceive() !&S !UL",
tkptr->FtpDataReadIOsb.Status, tkptr->FtpDataReadIOsb.Count);
rqptr = tkptr->RequestPtr;
if (tkptr->FtpDataReadIOsb.Status == SS$_LINKDISCON)
{
/* transfer is complete (or aborted!) */
ProxyFtpDataCloseSocket (tkptr);
SysDclAst (&ProxyFtpLifeCycle, tkptr);
return;
}
if (!tkptr->FtpDataReadIOsb.Status)
{
/* first time the function has been called */
if (!tkptr->ResponseBufferPtr)
{
tkptr->ResponseBufferSize = ProxyReadBufferSize;
tkptr->ResponseBufferPtr = VmGetHeap (rqptr, ProxyReadBufferSize);
}
tkptr->ResponseBufferCount = 0;
tkptr->ResponseBufferRemaining = tkptr->ResponseBufferSize - 1;
tkptr->ResponseBufferCurrentPtr = tkptr->ResponseBufferPtr;
/* plus, fudge the first IO status block appropriately */
tkptr->FtpDataReadIOsb.Status = SS$_NORMAL;
}
if (VMSnok (tkptr->FtpDataReadIOsb.Status))
{
/* check the previous read status */
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
rqptr->rqResponse.HttpStatus = 502;
ErrorVmsStatus (rqptr, tkptr->FtpDataReadIOsb.Status, FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_ABORT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
return;
}
tkptr->ResponseBufferCount += tkptr->FtpDataReadIOsb.Count;
tkptr->ResponseBufferCurrentPtr += tkptr->FtpDataReadIOsb.Count;
tkptr->ResponseBufferRemaining -= tkptr->FtpDataReadIOsb.Count;
if (tkptr->ResponseBufferRemaining < PROXY_FTP_LIST_LOW_BUFFER)
{
tkptr->ResponseBufferSize += ProxyReadBufferSize;
tkptr->ResponseBufferRemaining += ProxyReadBufferSize;
tkptr->ResponseBufferPtr =
VmReallocHeap (rqptr, tkptr->ResponseBufferPtr,
tkptr->ResponseBufferSize, FI_LI);
tkptr->ResponseBufferCurrentPtr = tkptr->ResponseBufferPtr +
tkptr->ResponseBufferCount;
}
*tkptr->ResponseBufferCurrentPtr = '\0';
ProxyFtpDataReadRaw (tkptr, &ProxyFtpListReceive,
tkptr->ResponseBufferCurrentPtr,
tkptr->ResponseBufferRemaining);
}
/****************************************************************************/
/*
The directory listing has been received and is currently stored in memory
pointed to by ->ResponseBufferPtr, is ->ResponseBufferCount in size, and is
null-terminated. Format this according to the type of file system. Write this
to the proxy client.
*/
ProxyFtpListProcess (PROXY_TASK *tkptr)
{
int status;
char *cptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpListProcess()");
rqptr = tkptr->RequestPtr;
if (tkptr->FtpFileSystem == PROXY_FTP_FILE_SYSTEM_UNIX)
{
/* first let's double-check it's not DOS masquerading as Unix */
cptr = tkptr->ResponseBufferPtr;
if (isdigit(cptr[0]) && isdigit(cptr[1]) &&
(cptr[2] == '-' || cptr[2] == '/'))
{
/* hmmm, looks suspiciously like a ... */
while (!ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
while (ISLWS(*cptr)) cptr++;
if (isdigit(cptr[0]) && isdigit(cptr[1]) && cptr[2] == ':' &&
isdigit(cptr[3]) && isdigit(cptr[4]))
{
/* ... DOS date and time (dd/mm/yy hh:mm) */
tkptr->FtpFileSystem = PROXY_FTP_FILE_SYSTEM_DOS;
tkptr->FtpFileSystemPtr = "DOS";
/* (and nothing like Unix file permissions!) */
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
ProxyAccountingPtr->FtpUnixCount--;
ProxyAccountingPtr->FtpDosCount++;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
}
}
}
if (*(cptr = rqptr->rqHeader.QueryStringPtr))
{
if (ProxyFtpInQueryString (cptr, "dos"))
tkptr->FtpFileSystem = PROXY_FTP_FILE_SYSTEM_DOS;
else
if (ProxyFtpInQueryString (cptr, "unix"))
tkptr->FtpFileSystem = PROXY_FTP_FILE_SYSTEM_UNIX;
else
if (ProxyFtpInQueryString (cptr, "vms"))
tkptr->FtpFileSystem = PROXY_FTP_FILE_SYSTEM_VMS;
else
if (ProxyFtpInQueryString (cptr, "list"))
{
rqptr->rqResponse.PreExpired = PRE_EXPIRE_FTP_PROXY;
ResponseHeader (rqptr, 200, "text/plain", 0, NULL, NULL);
NetWrite (rqptr, &ProxyFtpListWriteAst,
tkptr->ResponseBufferPtr, tkptr->ResponseBufferCount);
return;
}
if (ProxyFtpInQueryString (cptr, "alt"))
tkptr->FtpListAlt = true;
if (ProxyFtpInQueryString (cptr, "hide"))
tkptr->FtpListHide = true;
if (ProxyFtpInQueryString (cptr, "raw"))
tkptr->FtpListRaw = true;
}
switch (tkptr->FtpFileSystem)
{
case PROXY_FTP_FILE_SYSTEM_DOS :
ProxyFtpListProcessDOS (tkptr);
break;
case PROXY_FTP_FILE_SYSTEM_UNIX :
ProxyFtpListProcessUnix (tkptr);
break;
case PROXY_FTP_FILE_SYSTEM_VMS :
ProxyFtpListProcessVMS (tkptr);
break;
default :
/* unknown format */
rqptr->rqResponse.PreExpired = PRE_EXPIRE_FTP_PROXY;
ResponseHeader (rqptr, 200, "text/plain", 0, NULL, NULL);
NetWrite (rqptr, &ProxyFtpListWriteAst,
tkptr->ResponseBufferPtr, tkptr->ResponseBufferCount);
return;
}
ProxyFtpListOutput (tkptr);
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
************
*** NOTE *** This function takes a pointer to a request!!!
************
*/
ProxyFtpListWriteAst (REQUEST_STRUCT *rqptr)
{
PROXY_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_PROXY, "ProxyFtpListWriteAst()");
tkptr = rqptr->ProxyTaskPtr;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
Process the native DOS directory listing into the standard format used by
ProxyFtpListOutput().
*/
ProxyFtpListProcessDOS (PROXY_TASK *tkptr)
{
#define FORMAT_DOS_DATE 1
static char *MonthName [] = { NULL, "Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec" };
BOOL IsDirectory,
MonthDayOrdering;
int DateDay,
DateHour,
DateMinute,
DateMonth,
DateYear;
char *cptr, *sptr, *tptr, *zptr;
char FileDate [64],
FileName [256],
FileSize [64];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpListProcessDOS()");
rqptr = tkptr->RequestPtr;
#if FORMAT_DOS_DATE
if (!tkptr->FtpListRaw)
{
MonthDayOrdering = false;
cptr = tkptr->ResponseBufferPtr;
while (*cptr)
{
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("-!&E\n", cptr);
/* skip leading white-space, blank lines, etc. */
while (ISLWS(*cptr)) cptr++;
if (!*cptr) break;
if (ISEOL(*cptr))
{
while (*cptr && ISEOL(*cptr)) cptr++;
continue;
}
if (isdigit(cptr[0]) && isdigit(cptr[1]) &&
(cptr[2] == '-' || cptr[2] == '/'))
{
DateDay = atoi(cptr);
cptr += 3;
DateMonth = atoi(cptr);
if (DateDay > 0 && DateDay <= 31 &&
DateMonth > 0 && DateMonth <= 31 &&
DateMonth > 12 && DateMonth <= 31)
{
MonthDayOrdering = true;
break;
}
}
/* skip to start of next line */
while (NOTEOL(*cptr)) cptr++;
while (*cptr && ISEOL(*cptr)) cptr++;
}
}
#endif /* FORMAT_DOS_DATE */
tkptr->ResponseBufferCount = 0;
cptr = tkptr->ResponseBufferPtr;
while (*cptr)
{
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("-!&E\n", cptr);
/* skip leading white-space, blank lines, etc. */
while (ISLWS(*cptr)) cptr++;
if (!*cptr) break;
if (ISEOL(*cptr))
{
while (*cptr && ISEOL(*cptr)) cptr++;
continue;
}
/* file date and time */
zptr = (sptr = FileDate) + sizeof(FileDate)-1;
while (!ISLWS(*cptr) && NOTEOL(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
while (ISLWS(*cptr) && sptr < zptr) *sptr++ = *cptr++;
while (!ISLWS(*cptr) && NOTEOL(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
/* absorb intervening white-space */
while (ISLWS(*cptr)) cptr++;
if (*cptr == '<' && MATCH5 (cptr, "<DIR>"))
{
IsDirectory = true;
FileSize[0] = '\0';
while (!ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
while (ISLWS(*cptr)) cptr++;
}
else
{
IsDirectory = false;
zptr = (sptr = FileSize) + sizeof(FileSize)-1;
while (!ISLWS(*cptr) && NOTEOL(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
}
/* absorb intervening white-space */
while (ISLWS(*cptr)) cptr++;
zptr = (sptr = FileName) + sizeof(FileName)-1;
/* allow for the likes of "Copy of file.name" */
while (NOTEOL(*cptr) && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
/* skip to start of next line */
while (NOTEOL(*cptr)) cptr++;
while (*cptr && ISEOL(*cptr)) cptr++;
/* if all components not present then just ignore */
if (!FileName[0] || !FileDate[0] || (!FileSize[0] && !IsDirectory))
continue;
/* try to eliminate other lines ... file size really look like one? */
for (sptr = FileSize; isdigit(*sptr) || *sptr == ','; sptr++);
if (*sptr) continue;
/* try to eliminate other lines ... file date really look like one? */
sptr = FileDate;
if (!(isdigit(sptr[0]) && isdigit(sptr[1]) &&
(sptr[2] == '/' || sptr[2] == '-'))) continue;
#if FORMAT_DOS_DATE
if (!tkptr->FtpListRaw)
{
sptr = FileDate;
if (MonthDayOrdering)
{
DateMonth = atoi(sptr);
sptr += 3;
DateDay = atoi(sptr);
}
else
{
DateDay = atoi(sptr);
sptr += 3;
DateMonth = atoi(sptr);
}
sptr += 3;
DateYear = atoi(sptr);
if (DateYear <= 99)
{
DateYear += 1900;
if (DateYear < 1970) DateYear += 100;
}
while (*sptr && isdigit(*sptr)) sptr++;
while (*sptr && ISLWS(*sptr)) sptr++;
DateHour = atoi(sptr);
sptr += 3;
DateMinute = atoi(sptr);
sptr += 2;
if (TOLO(*sptr) == 'p')
{
/* allow for "12:00PM" i.e. midday */
if (DateHour <= 11) DateHour += 12;
}
else
/* if it's not PM or AM then force an error */
if (TOLO(*sptr) != 'a')
DateHour = -1;
if (DateMinute >= 0 && DateMinute < 59 &&
DateHour >= 0 && DateHour <= 23 &&
DateDay > 0 && DateDay <= 31 &&
DateMonth > 0 && DateMonth <= 12 &&
DateYear > 1970 && DateYear <= 2099)
{
/* seems to make sense, reformat */
if (DateYear == rqptr->rqTime.BeginTime7[0])
FaoToBuffer (FileDate, sizeof(FileDate), NULL,
"!AZ !AZ!UL !2ZL:!2ZL",
MonthName[DateMonth],
DateDay < 10 ? " " : "", DateDay,
DateHour, DateMinute);
else
FaoToBuffer (FileDate, sizeof(FileDate), NULL,
"!AZ !AZ!UL !UL",
MonthName[DateMonth],
DateDay < 10 ? " " : "", DateDay,
DateYear);
}
}
#endif /* FORMAT_DOS_DATE */
sptr = tkptr->ResponseBufferPtr + tkptr->ResponseBufferCount;
zptr = tkptr->ResponseBufferPtr + tkptr->ResponseBufferSize - 1;
tptr = FileName;
while (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = '\t';
tptr = FileSize;
while (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = '\t';
tptr = FileDate;
while (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = '\n';
if (sptr >= cptr)
{
tkptr->ResponseBufferPtr[tkptr->ResponseBufferCount = 0] = '\0';
rqptr->rqResponse.HttpStatus = 500;
ErrorGeneral (rqptr, ErrorSanityCheck, FI_LI);
return;
}
*sptr = '\0';
tkptr->ResponseBufferCount = sptr - tkptr->ResponseBufferPtr;
}
tkptr->ResponseBufferPtr[tkptr->ResponseBufferCount] = '\0';
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("!&Z\n", tkptr->ResponseBufferPtr);
}
/****************************************************************************/
/*
Process the native Unix directory listing into the standard format used by
ProxyFtpListOutput().
*/
ProxyFtpListProcessUnix (PROXY_TASK *tkptr)
{
#define MAX_FIELDS 16
#define SIZE_FIELDS 128
#define SIZE_INTER_FIELDS 32
static char *MonthName [] = { "Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec" };
BOOL IsDirectory;
int idx, status,
FieldCount,
FileNameLength,
MonthField;
char *cptr, *sptr, *tptr, *zptr;
char Fields [MAX_FIELDS][SIZE_FIELDS],
InterFields [MAX_FIELDS][SIZE_INTER_FIELDS];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpListProcessUnix()");
rqptr = tkptr->RequestPtr;
tkptr->ResponseBufferCount = 0;
cptr = tkptr->ResponseBufferPtr;
while (*cptr)
{
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("-!&E\n", cptr);
/* skip leading white-space, blank lines, etc. */
while (ISLWS(*cptr)) cptr++;
if (!*cptr) break;
if (ISEOL(*cptr))
{
while (*cptr && ISEOL(*cptr)) cptr++;
continue;
}
FieldCount = 0;
while (*cptr && NOTEOL(*cptr))
{
if (FieldCount < MAX_FIELDS)
{
zptr = (sptr = Fields[FieldCount]) + SIZE_FIELDS-1;
while (*cptr && !ISLWS(*cptr) && NOTEOL(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
}
while (*cptr && !ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
if (FieldCount < MAX_FIELDS)
{
zptr = (sptr = InterFields[FieldCount]) + SIZE_INTER_FIELDS-1;
while (*cptr == ' ' && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
}
while (ISLWS(*cptr)) cptr++;
FieldCount++;
}
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
for (idx = 1; idx < FieldCount; idx++)
WatchDataFormatted ("!UL !&Z !&Z\n",
idx, Fields[idx], InterFields[idx]);
/* skip to start of next line */
while (NOTEOL(*cptr)) cptr++;
while (*cptr && ISEOL(*cptr)) cptr++;
/* won't make any sense at all unless there are at least six fields */
if (FieldCount < 6) continue;
/* find field containing month name */
for (MonthField = 1; MonthField < FieldCount; MonthField++)
{
for (idx = 0; idx < 12; idx++)
if (strsame (Fields[MonthField], MonthName[idx], 3))
break;
if (idx < 12) break;
}
/* doesn't make sense if it doesn't contain a month name somewhere */
if (MonthField >= FieldCount) continue;
/* dot and double-dot directories are ignored */
tptr = Fields[MonthField+3];
if (SAME2(tptr,'.\0')) continue;
if (SAME2(tptr,'./')) continue;
if (SAME2(tptr,'..')) continue;
if (Fields[0][0] == '-')
IsDirectory = false;
else
if (Fields[0][0] == 'd')
IsDirectory = true;
else
if (Fields[0][0] == 'l')
{
/* a symbolic link, check if it looks like a file (i.e. has type) */
for (tptr = Fields[MonthField+5]; *tptr && *tptr != '.'; tptr++);
if (!*tptr) IsDirectory = true;
}
else
/* doesn't make sense, ignore */
continue;
sptr = tkptr->ResponseBufferPtr + tkptr->ResponseBufferCount;
zptr = tkptr->ResponseBufferPtr + tkptr->ResponseBufferSize - 1;
/* file name - all remaining fields (for names containing white-space) */
for (idx = MonthField+3; idx < FieldCount; idx++)
{
for (tptr = Fields[idx]; *tptr && sptr < zptr; *sptr++ = *tptr++);
for (tptr = InterFields[idx]; *tptr && sptr < zptr; *sptr++ = *tptr++);
}
if (sptr < zptr) *sptr++ = '\t';
/* file size */
if (!IsDirectory)
{
tptr = Fields[MonthField-1];
while (*tptr && sptr < zptr) *sptr++ = *tptr++;
}
if (sptr < zptr) *sptr++ = '\t';
/* file date/time */
tptr = Fields[MonthField];
while (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = ' ';
if (!Fields[MonthField+1][1] && sptr < zptr)
*sptr++ = ' ';
else
if (Fields[MonthField+1][0] == '0')
Fields[MonthField+1][0] = ' ';
tptr = Fields[MonthField+1];
while (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = ' ';
if (strlen(Fields[MonthField+2]) == 4 && sptr < zptr) *sptr++ = ' ';
tptr = Fields[MonthField+2];
while (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = '\n';
if (sptr >= cptr)
{
tkptr->ResponseBufferPtr[tkptr->ResponseBufferCount = 0] = '\0';
rqptr->rqResponse.HttpStatus = 500;
ErrorGeneral (rqptr, ErrorSanityCheck, FI_LI);
return;
}
*sptr = '\0';
tkptr->ResponseBufferCount = sptr - tkptr->ResponseBufferPtr;
}
tkptr->ResponseBufferPtr[tkptr->ResponseBufferCount] = '\0';
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("!&Z\n", tkptr->ResponseBufferPtr);
#undef MAX_FIELDS
}
/****************************************************************************/
/*
Process the native VMS directory listing into the standard format used by
ProxyFtpListOutput(). Needless-to-say this is the more complicated of the
reformatting functions. To ease integration with non-browser applications it
attempts to make the standard VMS listing look more generic (particularly as
far as date/time goes). If there is a version component in the path it then
reverts back displaying version infomation, size and date/time in a more
VMS-like fashion.
*/
ProxyFtpListProcessVMS (PROXY_TASK *tkptr)
{
BOOL IsDirectory,
LooksOk;
int year,
FileSizeBytes;
unsigned short Length;
char *cptr, *sptr, *tptr, *zptr;
char DateDay [4],
DateMonth [4],
DateTime [16],
DateYear [8],
FileName [128],
FileSize [32];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpListProcessVMS()");
rqptr = tkptr->RequestPtr;
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
while (cptr > tkptr->FtpFilePathPtr && *cptr != '/' && *cptr != ';') cptr--;
if (*cptr == ';')
tkptr->FtpHasVersion = true;
else
tkptr->FtpHasVersion = false;
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("!&Z\n", tkptr->ResponseBufferPtr);
tkptr->ResponseBufferCount = 0;
cptr = tkptr->ResponseBufferPtr;
while (*cptr)
{
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("-!&E\n", cptr);
/* skip leading white-space, blank lines, etc. */
while (ISLWS(*cptr)) cptr++;
if (!*cptr) break;
if (ISEOL(*cptr))
{
while (*cptr && ISEOL(*cptr)) cptr++;
continue;
}
LooksOk = true;
zptr = (sptr = FileName) + sizeof(FileName)-1;
if (tkptr->FtpHasVersion || tkptr->FtpListRaw)
{
while (!ISLWS(*cptr) && NOTEOL(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
}
else
{
while (!ISLWS(*cptr) && *cptr != ';' && NOTEOL(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
if (*cptr == ';')
{
/* skip version number in file specification */
while (!ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
}
}
*sptr = '\0';
if (!FileName[0]) LooksOk = false;
while (sptr > FileName && *sptr != '.') sptr--;
if (strsame (sptr, ".DIR", -1) ||
strsame (sptr, ".DIR;", 5))
{
/* terminate to eliminate the ".DIR" */
*sptr = '\0';
IsDirectory = true;
}
else
IsDirectory = false;
/* absorb white-space after filename and before size */
while (ISLWS(*cptr)) cptr++;
if (ISEOL(*cptr))
{
/* file name too long for one line, try size/date on next line */
while (NOTEOL(*cptr)) cptr++;
while (*cptr && ISEOL(*cptr)) cptr++;
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("+!&E\n", cptr);
/* absorb leading white-space */
while (ISLWS(*cptr)) cptr++;
}
zptr = (sptr = FileSize) + sizeof(FileSize)-1;
while (!ISLWS(*cptr) && NOTEOL(*cptr) && sptr < zptr)
{
if (!isdigit(*cptr) && *cptr != '/') LooksOk = false;
*sptr++ = *cptr++;
}
/* a null file size indicates it's a directory */
if (IsDirectory)
sptr = FileSize;
else
if (!(tkptr->FtpHasVersion || tkptr->FtpListRaw))
{
/* not a VMS specification, convert from blocks to bytes */
*sptr = '\0';
FileSizeBytes = atoi(FileSize) * 512;
FaoToBuffer (FileSize, sizeof(FileSize), &Length,
"!UL", FileSizeBytes);
sptr = FileSize + Length;
}
*sptr = '\0';
if (!FileSize[0] && !IsDirectory) LooksOk = false;
/* absorb white-space between size and date */
while (ISLWS(*cptr)) cptr++;
/* note that we are retrieving the date into working storage here */
sptr = DateDay;
if (cptr[1] == '-') *sptr++ = ' ';
if (*cptr && NOTEOL(*cptr)) *sptr++ = *cptr++;
if (*cptr && *cptr != '-') *sptr++ = *cptr++;
*sptr = '\0';
if (*cptr == '-')
cptr++;
else
LooksOk = false;
sptr = DateMonth;
if (*cptr && NOTEOL(*cptr)) *sptr++ = *cptr++;
if (*cptr && NOTEOL(*cptr)) *sptr++ = *cptr++;
if (*cptr && NOTEOL(*cptr)) *sptr++ = *cptr++;
*sptr = '\0';
if (*cptr == '-')
cptr++;
else
LooksOk = false;
sptr = DateYear;
if (*cptr && NOTEOL(*cptr)) *sptr++ = *cptr++;
if (*cptr && NOTEOL(*cptr)) *sptr++ = *cptr++;
if (*cptr && NOTEOL(*cptr)) *sptr++ = *cptr++;
if (*cptr && NOTEOL(*cptr)) *sptr++ = *cptr++;
*sptr = '\0';
if (*cptr == ' ')
cptr++;
else
LooksOk = false;
tptr = (sptr = DateTime) + sizeof(DateTime)-1;
while (!ISLWS(*cptr) && NOTEOL(*cptr) && sptr < tptr)
{
if (!isdigit(*cptr) && *cptr != ':' && *cptr != '.') LooksOk = false;
*sptr++ = *cptr++;
}
*sptr = '\0';
/* if all components do not appear present */
if (!(DateDay[0] && DateMonth[0] &&
DateYear[0] && DateTime[0])) LooksOk = false;
/* skip to start of next line */
while (NOTEOL(*cptr)) cptr++;
while (*cptr && ISEOL(*cptr)) cptr++;
/* if it doesn't look right then just ignore */
if (!LooksOk) continue;
sptr = tkptr->ResponseBufferPtr + tkptr->ResponseBufferCount;
zptr = tkptr->ResponseBufferPtr + tkptr->ResponseBufferSize - 1;
for (tptr = FileName; *tptr && sptr < zptr; *sptr++ = *tptr++);
if (sptr < zptr) *sptr++ = '\t';
for (tptr = FileSize; *tptr && sptr < zptr; *sptr++ = *tptr++);
if (sptr < zptr) *sptr++ = '\t';
if (tkptr->FtpHasVersion || tkptr->FtpListRaw)
{
tptr = DateDay;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = '-';
tptr = DateMonth;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = '-';
tptr = DateYear;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = ' ';
tptr = DateTime;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
}
else
{
tptr = DateMonth;
if (*tptr && sptr < zptr) *sptr++ = *tptr++;
if (*tptr && sptr < zptr) *sptr++ = TOLO(*tptr++);
if (*tptr && sptr < zptr) *sptr++ = TOLO(*tptr++);
if (sptr < zptr) *sptr++ = ' ';
if (!DateDay[1] && sptr < zptr) *sptr++ = ' ';
for (tptr = DateDay; *tptr && sptr < zptr; *sptr++ = *tptr++);
if (sptr < zptr) *sptr++ = ' ';
year = atoi(DateYear);
if (year == rqptr->rqTime.BeginTime7[0])
{
tptr = DateTime;
if (sptr < zptr) *sptr++ = *tptr++;
}
else
{
tptr = DateYear;
if (sptr < zptr) *sptr++ = ' ';
}
if (sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = *tptr++;
if (sptr < zptr) *sptr++ = *tptr++;
}
if (sptr < zptr) *sptr++ = '\n';
if (sptr >= cptr)
{
tkptr->ResponseBufferPtr[tkptr->ResponseBufferCount = 0] = '\0';
rqptr->rqResponse.HttpStatus = 500;
ErrorGeneral (rqptr, ErrorSanityCheck, FI_LI);
return;
}
*sptr = '\0';
tkptr->ResponseBufferCount = sptr - tkptr->ResponseBufferPtr;
}
tkptr->ResponseBufferPtr[tkptr->ResponseBufferCount] = '\0';
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchDataFormatted ("!&Z\n", tkptr->ResponseBufferPtr);
}
/****************************************************************************/
/*
Output the reformatted directory listing, directories first, then files.
The reformatted version is "<filename><TAB><size><TAB><date><LF>" as in the
following file example "EXAMPLE.TXT\t1560\tOct 28 2001\n" and directory
example "EXAMPLE\t\tOct 28 2001\n". As can be seen from the example a
directory is indicated by an empty size field.
*/
ProxyFtpListOutput (PROXY_TASK *tkptr)
{
#define NAME_WIDTH 30
#define SIZE_WIDTH 15
static char DirFao [] =
"<tr><td>!AZ</td>\
<td><a href=\"!#&;AZ/!&;AZ!AZ\">!#&;AZ/</a></td>\
<td></td>\
<td>!#AZ</td></tr>\n";
static char FileFao [] =
"<tr><td>!&@</td>\
<td><a href=\"!#&;AZ!AZ\">!#&;AZ</a></td>\
<td class=\"rghtd\">!#AZ</td>\
<td>!#AZ</td></tr>\n";
static char BeginPage1Fao [] =
"!AZ\
<html>\n\
<head>\n\
<meta name=\"SYST\" value=\"!AZ\">\n\
<meta name=\"CWD\" value=\"!AZ\">\n\
<meta name=\"file\" value=\"!AZ\">\n\
<style type=\"text/css\">\n\
.tblst { min-width:40%; border-collapse:collapse; }\n\
.tblst th, .tblst td { font-family:!AZ; }\n\
.tblst td { padding:0 1.5em 0 0; margin:0; white-space:pre-wrap;\
vertical-align:top; }\n\
.tblst.list2 thead td { padding-bottom:0.5em; white-space:pre-wrap;\
vertical-align:top; }\n\
.rghtd { text-align:right; }\n\
.rnwtd { text-align:right; white-space:nowrap!!important; }\n\
hr { width:105%; margin:1em 1em 1em 0; height: 2px; color:#000000;\
background-color:#000000; border:1px; }\n\
</style>\n\
!&@\
<title>!AZ//!AZ!AZ</title>\n\
</head>\n\
!&@\
!&@",
BeginPage2Fao [] =
"!&@\
!AZ\
<p><table class=\"tblst\">\n\
<thead>\n\
<tr><td></td>\
<td><b>!AZ</b></td>\
<td class=\"rghtd\"><b>!AZ</b></td>\
<td><b>!AZ</b></td></tr>\n\
<tr><td colspan=\"4\"><hr size=\"1\" noshade></td></tr>\n\
</thead>\n\
<tbody>\n";
static char EndPageFao [] =
"<tr><td colspan=\"4\"><hr size=\"1\" noshade></td></tr>\n\
</tbody>\n\
!&@\
</body>\n\
</html>\n";
int status,
DirCount,
FileCount;
unsigned short Length,
FileDateLength,
FileNameLength,
FileSizeLength;
unsigned long *vecptr;
unsigned long FaoVector [32];
char *cptr, *sptr,
*AltTextPtr,
*FileDatePtr,
*FileNamePtr,
*FileSizePtr,
*IconUriPtr,
*IndexOfPtr;
char CommaSize [32],
IconImg [256],
PrevContentType [128];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpListOutput()");
rqptr = tkptr->RequestPtr;
IconImg[0] = PrevContentType[0] = '\0';
rqptr->rqResponse.PreExpired = PRE_EXPIRE_FTP_PROXY;
ResponseHeader (rqptr, 200, "text/html", -1, NULL, NULL);
IndexOfPtr = MsgFor(rqptr,MSG_PROXY_FTP_INDEX_OF);
sptr = MsgFor(rqptr,MSG_DIR_COLUMN_HEADINGS);
cptr = VmGetHeap (rqptr, strlen(sptr)+1);
strcpy (cptr, sptr);
while (*cptr && *cptr != '|') cptr++;
if (*cptr = '|') cptr++;
while (*cptr && *cptr != '|') cptr++;
if (*cptr = '|') cptr++;
FileNamePtr = cptr;
while (*cptr && *cptr != '|') cptr++;
if (*cptr = '|') *cptr++ = '\0';
while (*cptr && *cptr != '|') cptr++;
if (*cptr = '|') cptr++;
while (*cptr && *cptr != '|') cptr++;
if (*cptr = '|') cptr++;
FileDatePtr = cptr;
while (*cptr && *cptr != '|') cptr++;
if (*cptr = '|') *cptr++ = '\0';
FileSizePtr = cptr;
vecptr = FaoVector;
*vecptr++ = WASD_DOCTYPE;
*vecptr++ = tkptr->FtpSYST;
*vecptr++ = tkptr->FtpCWD;
*vecptr++ = tkptr->FtpFileSystemPtr;
if (rqptr->rqPathSet.DirFont)
*vecptr++ = rqptr->rqPathSet.DirFont;
else
*vecptr++ = "monospace";
if (rqptr->rqPathSet.StyleSheetPtr)
{
*vecptr++ =
"<link rel=\"stylesheet\" type=\"text/css\" href=\"!AZ\">\n";
*vecptr++ = rqptr->rqPathSet.StyleSheetPtr;
}
else
*vecptr++ = "";
*vecptr++ = IndexOfPtr;
if (rqptr->rqHeader.HostPtr &&
rqptr->rqHeader.HostPtr[0])
*vecptr++ = rqptr->rqHeader.HostPtr;
else
*vecptr++ = rqptr->ServicePtr->ServerHostPort;
*vecptr++ = tkptr->FtpFilePathPtr;
if (rqptr->rqPathSet.HtmlBodyTagPtr)
{
/* <body..> */
if (rqptr->rqPathSet.HtmlBodyTagPtr[0] == '<')
*vecptr++ = "!AZ\n";
else
*vecptr++ = "<body!&+AZ>\n";
*vecptr++ = rqptr->rqPathSet.HtmlBodyTagPtr;
}
else
{
*vecptr++ = "!AZ\n";
*vecptr++ = Config.cfDir.BodyTag;
}
if (rqptr->rqPathSet.HtmlHeaderPtr ||
rqptr->rqPathSet.HtmlHeaderTagPtr)
{
if (rqptr->rqPathSet.HtmlHeaderTagPtr &&
rqptr->rqPathSet.HtmlHeaderTagPtr[0] == '<')
*vecptr++ = "!AZ\n!&/AZ";
else
*vecptr++ =
"<table cellpadding=\"5\" cellspacing=\"0\" border=\"0\" width=\"100%\">\
<tr><td!&+AZ>\n!&/AZ";
*vecptr++ = rqptr->rqPathSet.HtmlHeaderTagPtr;
*vecptr++ = rqptr->rqPathSet.HtmlHeaderPtr;
}
else
*vecptr++ = "";
status = FaolToNet (rqptr, BeginPage1Fao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
ProxyFtpIndexOf (tkptr, IndexOfPtr);
vecptr = FaoVector;
if (tkptr->Ftp230Ptr)
{
*vecptr++ =
"<span style=\"font-family:!AZ;white-space:pre;\">!&;AZ</span>\n";
if (rqptr->rqPathSet.DirFont)
*vecptr++ = rqptr->rqPathSet.DirFont;
else
*vecptr++ = "monospace";
*vecptr++ = tkptr->Ftp230Ptr;
}
else
*vecptr++ = "";
if (rqptr->rqPathSet.HtmlHeaderPtr ||
rqptr->rqPathSet.HtmlHeaderTagPtr)
*vecptr++ = "</td></tr></table>\n";
else
*vecptr++ = "";
*vecptr++ = FileNamePtr;
*vecptr++ = FileSizePtr;
*vecptr++ = FileDatePtr;
status = FaolToNet (rqptr, BeginPage2Fao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
/***************/
/* directories */
/***************/
DirCount = 0;
cptr = tkptr->ResponseBufferPtr;
while (*cptr)
{
FileNamePtr = cptr;
while (*cptr && *cptr != '\t') cptr++;
FileNameLength = cptr - FileNamePtr;
if (*cptr) cptr++;
FileSizePtr = cptr;
while (*cptr && *cptr != '\t') cptr++;
FileSizeLength = cptr - FileSizePtr;
if (*cptr) cptr++;
FileDatePtr = cptr;
while (*cptr && *cptr != '\n') cptr++;
FileDateLength = cptr - FileDatePtr;
if (*cptr) cptr++;
/* empty file size indicates a directory */
if (*FileSizePtr != '\t') continue;
if (tkptr->FtpListHide && *FileNamePtr == '.') continue;
if (!IconImg[0])
{
ConfigIconFor (ConfigContentTypeDir, &IconUriPtr, &AltTextPtr);
FaoToBuffer (IconImg, sizeof(IconImg), NULL,
"<img src=\"!AZ//!AZ!AZ\" align=\"top\" border=\"0\" alt=\"!AZ\">",
rqptr->ServicePtr->RequestSchemeNamePtr,
rqptr->ServicePtr->ServerHostPort,
IconUriPtr, AltTextPtr);
}
vecptr = FaoVector;
*vecptr++ = IconImg;
*vecptr++ = FileNameLength;
*vecptr++ = FileNamePtr;
*vecptr++ = tkptr->FtpWildPtr;
*vecptr++ = tkptr->RequestUriQueryStringPtr;
*vecptr++ = FileNameLength;
*vecptr++ = FileNamePtr;
*vecptr++ = FileDateLength;
*vecptr++ = FileDatePtr;
status = FaolToNet (rqptr, DirFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
DirCount++;
}
/*********/
/* files */
/*********/
FileCount = 0;
cptr = tkptr->ResponseBufferPtr;
while (*cptr)
{
FileNamePtr = cptr;
while (*cptr && *cptr != '\t') cptr++;
FileNameLength = cptr - FileNamePtr;
if (*cptr) cptr++;
FileSizePtr = cptr;
while (*cptr && *cptr != '\t') cptr++;
FileSizeLength = cptr - FileSizePtr;
if (*cptr) cptr++;
FileDatePtr = cptr;
while (*cptr && *cptr != '\n') cptr++;
FileDateLength = cptr - FileDatePtr;
if (*cptr) cptr++;
/* empty file size indicates a directory */
if (*FileSizePtr == '\t') continue;
if (tkptr->FtpListHide && *FileNamePtr == '.') continue;
FileNamePtr[FileNameLength] = '\0';
for (sptr = FileNamePtr + FileNameLength;
sptr > FileNamePtr && *sptr != '.';
sptr--);
if (*sptr == '.')
sptr = ConfigContentType (NULL, sptr);
else
sptr = ConfigDefaultFileContentType;
FileNamePtr[FileNameLength] = '\t';
if (!PrevContentType[0] || !strsame (sptr, PrevContentType, -1))
{
strzcpy (PrevContentType, sptr, sizeof(PrevContentType));
ConfigIconFor (sptr, &IconUriPtr, &AltTextPtr);
FaoToBuffer (IconImg, sizeof(IconImg), NULL,
"<img src=\"!AZ//!AZ!AZ\" align=\"top\" border=\"0\" alt=\"!AZ\">",
rqptr->ServicePtr->RequestSchemeNamePtr,
rqptr->ServicePtr->ServerHostPort,
IconUriPtr, AltTextPtr);
}
if (DirCount && !FileCount)
FaoToNet (rqptr, "<tr><td> </td></tr>\n");
vecptr = FaoVector;
if (tkptr->FtpListAlt)
{
*vecptr++ = "<a href=\"!#&%AZ!AZ!AZ!AZ\">!AZ</a>";
*vecptr++ = FileNameLength;
*vecptr++ = FileNamePtr;
*vecptr++ = tkptr->RequestUriQueryStringPtr;
*vecptr++ = tkptr->RequestUriQueryStringPtr[0] ? "" : "?";
*vecptr++ = strsame(sptr, "text/", 5) ? "+octet+image" : "+text+ascii";
*vecptr++ = IconImg;
}
else
*vecptr++ = IconImg;
*vecptr++ = FileNameLength;
*vecptr++ = FileNamePtr;
*vecptr++ = tkptr->RequestUriQueryStringPtr;
*vecptr++ = FileNameLength;
*vecptr++ = FileNamePtr;
for (sptr = FileSizePtr;
*sptr && *sptr != '\t' && *sptr != ',';
sptr++);
if (!(tkptr->FtpHasVersion || tkptr->FtpListRaw) && *sptr != ',')
{
FileSizePtr[FileSizeLength] = '\0';
FaoToBuffer (CommaSize, sizeof(CommaSize), &Length,
"!&,AZ", FileSizePtr);
FileSizePtr[FileSizeLength] = '\t';
*vecptr++ = Length;
*vecptr++ = CommaSize;
}
else
{
*vecptr++ = FileSizeLength;
*vecptr++ = FileSizePtr;
}
*vecptr++ = FileDateLength;
*vecptr++ = FileDatePtr;
status = FaolToNet (rqptr, FileFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
FileCount++;
}
vecptr = &FaoVector;
if (rqptr->rqPathSet.HtmlFooterPtr ||
rqptr->rqPathSet.HtmlFooterTagPtr)
{
if (rqptr->rqPathSet.HtmlFooterTagPtr &&
rqptr->rqPathSet.HtmlFooterTagPtr[0] == '<')
*vecptr++ = "!AZ\n!&@";
else
*vecptr++ =
"<table cellpadding=\"5\" cellspacing=\"0\" border=\"0\" width=\"100%\"><tr><td!&+AZ>\n!&@";
*vecptr++ = rqptr->rqPathSet.HtmlFooterTagPtr;
*vecptr++ = "!&/AZ</td></tr></table>\n";
*vecptr++ = rqptr->rqPathSet.HtmlFooterPtr;
}
else
*vecptr++ = "";
status = FaolToNet (rqptr, EndPageFao, &FaoVector);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
#undef NAME_WIDTH
#undef SIZE_WIDTH
}
/*****************************************************************************/
/*
Provide the "Index of" page heading in any of the post-v8.2, traditional WASD,
or the "ABI" styles.
*/
int ProxyFtpIndexOf
(
PROXY_TASK *tkptr,
char *IndexOfPtr
)
{
/* allows as directory nesting of up to 64 (should be enough ;^) */
static char DotDotSlash64 [] =
"<a href=\"./\
../../../../../../../../../../../../../../../../\
../../../../../../../../../../../../../../../../\
../../../../../../../../../../../../../../../../\
../../../../../../../../../../../../../../../../";
int cnt, status,
SlashCount;
unsigned long FaoVector [32];
unsigned long *vecptr;
char *cptr, *sptr, *zptr,
*FinalSlashPtr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpIndexOf() !&Z !AZ",
IndexOfPtr, tkptr->FtpFilePathPtr);
rqptr = tkptr->RequestPtr;
if (rqptr->rqPathSet.DirStyle == MAPURL_DIR_STYLE_ORIGINAL)
{
/**************************/
/* traditional WASD style */
/**************************/
vecptr = &FaoVector;
*vecptr++ = IndexOfPtr;
*vecptr++ = tkptr->FtpFilePathPtr;
status = FaolToNet (rqptr, "<h2><nobr>!AZ !AZ</nobr></h2>\n",
&FaoVector);
return (status);
}
/****************/
/* other styles */
/****************/
/* calculate the number of directory elements */
SlashCount = 0;
FinalSlashPtr = "";
for (cptr = tkptr->FtpFilePathPtr; *cptr; cptr++)
{
if (*cptr == '/')
{
SlashCount++;
FinalSlashPtr = cptr;
}
}
if (SlashCount > 64) return (SS$_BUGCHECK);
if (*FinalSlashPtr) FinalSlashPtr++;
vecptr = &FaoVector;
if (rqptr->rqPathSet.DirStyle == MAPURL_DIR_STYLE_HTDIR)
{
/* ABI's style begins with the server name as a 'root' anchor */
if (rqptr->rqHeader.HostPtr &&
rqptr->rqHeader.HostPtr[0])
*vecptr++ = rqptr->rqHeader.HostPtr;
else
*vecptr++ = rqptr->ServicePtr->ServerHostPort;
*vecptr++ = tkptr->RequestUriQueryStringPtr;
status = FaolToNet (rqptr, "<h3><nobr><a href=\"/\">//!AZ!AZ/</a>",
&FaoVector);
}
else
{
/* WASD style provides an "Index of" heading */
*vecptr++ = IndexOfPtr;
*vecptr++ = tkptr->RequestUriQueryStringPtr;
if (rqptr->rqHeader.HostPtr &&
rqptr->rqHeader.HostPtr[0])
*vecptr++ = rqptr->rqHeader.HostPtr;
else
*vecptr++ = rqptr->ServicePtr->ServerHostPort;
status = FaolToNet (rqptr,
"<h3><nobr>!AZ //<a href=\"/!AZ\">!AZ</a>/",
&FaoVector);
}
if (VMSnok (status)) return (status);
cptr = tkptr->FtpFilePathPtr;
/* provide a self-relative (../) anchor for each directory element */
if (SlashCount) SlashCount--;
while (SlashCount-- > 0)
{
vecptr = &FaoVector;
*vecptr++ = 11 + (SlashCount * 3);
*vecptr++ = DotDotSlash64;
if (SlashCount)
*vecptr++ = FinalSlashPtr;
else
*vecptr++ = "";
*vecptr++ = tkptr->RequestUriQueryStringPtr;
if (*cptr == '/') cptr++;
for (sptr = cptr; *sptr && *sptr != '/'; sptr++);
if (rqptr->rqPathSet.DirStyle == MAPURL_DIR_STYLE_HTDIR)
{
/* ABI's style, trailing slashes are part of the link */
if (*sptr) sptr++;
*vecptr++ = sptr - cptr;
*vecptr++ = cptr;
*vecptr++ = 0;
*vecptr++ = "";
}
else
{
/* WASD style, trailing slashes are not part of the link */
*vecptr++ = sptr - cptr;
*vecptr++ = cptr;
*vecptr++ = 1;
*vecptr++ = sptr;
}
if (VMSnok (status)) return (status);
status = FaolToNet (rqptr, "!#AZ!AZ!&;AZ\">!#AZ</a>!#AZ", &FaoVector);
cptr = sptr;
}
if (rqptr->rqPathSet.DirStyle == MAPURL_DIR_STYLE_HTDIR)
{
/* ABI's style, 'file' name and type element as an anchor */
if (*cptr == '/') cptr++;
vecptr = &FaoVector;
*vecptr++ = cptr;
status = FaolToNet (rqptr, "<a href=\"!AZ\">!-!AZ</a></nobr></h3>\n",
&FaoVector);
}
else
{
/* WASD style, 'file' name and type just displayed */
if (*cptr == '/') cptr++;
vecptr = &FaoVector;
*vecptr++ = cptr;
status = FaolToNet (rqptr, "!AZ</nobr></h3>\n", &FaoVector);
}
return (status);
}
/****************************************************************************/
/*
Before retrieving a file set the FTP server transfer TYPE to ASCII or IMAGE
depending on whether carriage-control is require to be translated (at least in
some cases) or whether the file should be considered a bag-o'-bytes.
*/
ProxyFtpRetrieveMode (PROXY_TASK *tkptr)
{
char *cptr;
CONTENT_TYPE ContentType;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpRetrieveMode()");
rqptr = tkptr->RequestPtr;
/* find the start of the file type (if any) */
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
while (cptr > tkptr->FtpFilePathPtr && *cptr != '.' && *cptr != '/') cptr--;
/* content type will subsequently be used by ProxyFtpRetrieve() */
if (*cptr == '.')
tkptr->FtpContentTypePtr = ConfigContentType (&ContentType, cptr);
else
tkptr->FtpContentTypePtr = ConfigDefaultFileContentType;
/* is the client explicitly setting the transfer TYPE? */
cptr = rqptr->rqHeader.QueryStringPtr;
if (ContentType.FtpMode == 'A' ||
ProxyFtpInQueryString (cptr, "ascii"))
ProxyFtpCommand (tkptr, true, "TYPE A");
else
if (ContentType.FtpMode == 'I' ||
ContentType.FtpMode == 'B' ||
ProxyFtpInQueryString (cptr, "image"))
ProxyFtpCommand (tkptr, true, "TYPE I");
else
if (strsame (tkptr->FtpContentTypePtr, "text/", 5))
ProxyFtpCommand (tkptr, true, "TYPE A");
else
ProxyFtpCommand (tkptr, true, "TYPE I");
}
/****************************************************************************/
/*
Retrieve a file from the remote FTP server. This function initializes the
required data and issues a RETR command to the FTP server. If successful
ProxyFtpLifeCycle() will then call ProxyFtpRetrieveAst() to start retrieving
the file and writing it to the client.
*/
ProxyFtpRetrieve (PROXY_TASK *tkptr)
{
int status;
char *cptr, *sptr, *zptr;
char ContentType [64];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpRetrieve()");
rqptr = tkptr->RequestPtr;
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpRetrCount);
cptr = rqptr->rqHeader.QueryStringPtr;
if (cptr[0] && ProxyFtpInQueryString (cptr, "text"))
ResponseHeader (rqptr, 200, "text/plain", -1, NULL, NULL);
else
if (cptr[0] && ProxyFtpInQueryString (cptr, "octet"))
ResponseHeader (rqptr, 200, "application/octet-stream", -1, NULL, NULL);
else
if (cptr[0] && (sptr = ProxyFtpInQueryString (cptr, "content:")))
{
/* keyword style */
cptr = sptr + 9;
zptr = (sptr = ContentType) + sizeof(ContentType)-1;
while (*cptr && *cptr != '+' && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
ResponseHeader (rqptr, 200, ContentType, -1, NULL, NULL);
}
else
if (cptr[0] && (sptr = ProxyFtpInQueryString (cptr, "content=")))
{
/* form field style */
cptr = sptr + 9;
zptr = (sptr = ContentType) + sizeof(ContentType)-1;
while (*cptr && *cptr != '&' && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
ResponseHeader (rqptr, 200, ContentType, -1, NULL, NULL);
}
else
/* content type has been set up by ProxyFtpRetrieveMode() */
ResponseHeader (rqptr, 200, tkptr->FtpContentTypePtr, -1, NULL, NULL);
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
/* find the start of the file name */
while (cptr > tkptr->FtpFilePathPtr && *cptr != '/') cptr--;
cptr++;
if (!tkptr->ResponseBufferPtr)
{
tkptr->ResponseBufferSize = ProxyReadBufferSize;
tkptr->ResponseBufferPtr = VmGetHeap (rqptr, ProxyReadBufferSize);
}
/* reset the IO status block for the first read */
tkptr->FtpDataReadIOsb.Status = tkptr->FtpDataReadIOsb.Count = 0;
ProxyFtpCommand (tkptr, true, "RETR !AZ", cptr);
}
/****************************************************************************/
/*
When a read from the remote FTP server completes this function is called as an
AST. Check the read status. If OK then write it to the client, with an AST to
ProxyFtpRetrieveWriteAst(). If not OK check if the status is reset. If so
it's the first call and so kick off the loop with an initial read. If a real
error then abort the transfer.
*/
ProxyFtpRetrieveAst (PROXY_TASK *tkptr)
{
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpRetrieveAst() !&F !&S !UL", &ProxyFtpRetrieveAst,
tkptr->FtpDataReadIOsb.Status, tkptr->FtpDataReadIOsb.Count);
rqptr = tkptr->RequestPtr;
if (VMSok (tkptr->FtpDataReadIOsb.Status))
{
/* write it to the client */
NetWrite (rqptr, &ProxyFtpRetrieveWriteAst,
tkptr->ResponseBufferPtr,
tkptr->FtpDataReadIOsb.Count);
return;
}
if (!tkptr->FtpDataReadIOsb.Status)
{
/* first call for the retrieve, kick off the first read */
ProxyFtpDataReadRaw (tkptr, &ProxyFtpRetrieveAst,
tkptr->ResponseBufferPtr,
tkptr->ResponseBufferSize);
return;
}
if (tkptr->FtpDataReadIOsb.Status == SS$_LINKDISCON)
{
/* transfer is complete (or aborted!) */
ProxyFtpDataCloseSocket (tkptr);
SysDclAst (&ProxyFtpLifeCycle, tkptr);
return;
}
rqptr->rqResponse.HttpStatus = 502;
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
ErrorVmsStatus (rqptr, tkptr->FtpDataReadIOsb.Status, FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_ABORT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
************
*** NOTE *** This function takes a pointer to a request!!!
************
Called as an AST when a write to the client, queued by ProxyFtpRetrieveAst(),
completes. Check the status of the write and if OK queue another read from the
FTP server. If an error abort the transfer.
*/
ProxyFtpRetrieveWriteAst (REQUEST_STRUCT *rqptr)
{
PROXY_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_PROXY,
"ProxyFtpRetrieveWriteAst() !&S !UL",
rqptr->NetIoPtr->WriteStatus,
rqptr->NetIoPtr->WriteCount);
tkptr = rqptr->ProxyTaskPtr;
if (VMSok (rqptr->NetIoPtr->WriteStatus))
{
ProxyFtpDataReadRaw (tkptr, &ProxyFtpRetrieveAst,
tkptr->ResponseBufferPtr,
tkptr->ResponseBufferSize);
return;
}
/* write to client failed, just abandon the request */
tkptr->FtpState = PROXY_FTP_STATE_ABORT;
SysDclAst (ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
Begin to read the request body.
*/
ProxyFtpStoreBodyReadBegin (PROXY_TASK *tkptr)
{
int status;
char *cptr, *sptr, *zptr;
char ContentType [64];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpStoreBodyReadBegin()");
rqptr = tkptr->RequestPtr;
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpStorCount);
/* initialize the data transfer data */
if (ConfigSameContentType (rqptr->rqHeader.ContentTypePtr,
"application/x-www-form-urlencoded", -1))
BodyReadBegin (rqptr, &ProxyFtpStoreBodyReadAst,
&BodyProcessUrlEncoded);
else
if (ConfigSameContentType (rqptr->rqHeader.ContentTypePtr,
"multipart/", 10))
BodyReadBegin (rqptr, &ProxyFtpStoreBodyReadAst,
&BodyProcessMultipartFormData);
else
BodyReadBegin (rqptr, &ProxyFtpStoreBodyReadAst, NULL);
}
/****************************************************************************/
/*
A chunk of the request body has been read from the client. This function will
be called at least twice. After the first read, and the file name has been
resolved from the request body, it needs to issue the STOR command. It does
this and after the response ProxyFtpLifeCycle() calls this same function (which
untouched body data) again. Write the body data to the remote FTP server.
*/
ProxyFtpStoreBodyReadAst (REQUEST_STRUCT *rqptr)
{
char *cptr, *sptr;
BODY_PROCESS *prptr;
PROXY_TASK *tkptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_PROXY,
"ProxyFtpStoreBodyReadAst() !&F !&X !&S !&X !UL",
&ProxyFtpStoreBodyReadAst, rqptr->rqBody.ProcessPtr,
rqptr->rqBody.DataStatus, rqptr->rqBody.DataPtr,
rqptr->rqBody.DataCount);
tkptr = rqptr->ProxyTaskPtr;
prptr = rqptr->rqBody.ProcessPtr;
if (!(tkptr->FtpTypeDone && tkptr->FtpTypeDone))
{
cptr = NULL;
if (prptr)
{
if (prptr->MultipartFileName[0])
cptr = prptr->MultipartFileName;
if (prptr->MultipartUploadFileName[0])
cptr = prptr->MultipartUploadFileName;
if (sptr = cptr)
{
/* all we're interested is the name component */
while (*cptr) cptr++;
while (cptr > sptr && *cptr != '/' &&
*cptr != '\\' && *cptr != ']') cptr--;
if (*cptr == '/' || *cptr == '\\' || *cptr == ']') cptr++;
}
}
if (!cptr)
{
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
/* find the start of the file name */
while (cptr > tkptr->FtpFilePathPtr && *cptr != '/') cptr--;
cptr++;
}
if (!cptr || !*cptr)
{
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_PROXY_FTP_NO_FILENAME), FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_QUIT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
}
if (!tkptr->FtpTypeDone)
{
/*********************/
/* send TYPE command */
/*********************/
tkptr->FtpTypeDone = true;
if (WATCHMOD (rqptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_PROXY, "!&Z",
prptr ? prptr->FtpFileType : "");
/* is the client explicitly setting the transfer TYPE? */
cptr = rqptr->rqHeader.QueryStringPtr;
if (ProxyFtpInQueryString (cptr, "ascii") ||
(prptr && TOLO(prptr->FtpFileType[0]) == 'a'))
ProxyFtpCommand (tkptr, true, "TYPE A");
else
if (ProxyFtpInQueryString (cptr, "image") ||
(prptr && TOLO(prptr->FtpFileType[0]) == 'i'))
ProxyFtpCommand (tkptr, true, "TYPE I");
else
if (prptr && prptr->MultipartContentTypePtr)
{
if (ConfigSameContentType (prptr->MultipartContentTypePtr, "text/", 5))
ProxyFtpCommand (tkptr, true, "TYPE A");
else
ProxyFtpCommand (tkptr, true, "TYPE I");
}
else
if (rqptr->rqHeader.ContentTypePtr)
{
if (ConfigSameContentType (rqptr->rqHeader.ContentTypePtr, "text/", 5))
ProxyFtpCommand (tkptr, true, "TYPE A");
else
ProxyFtpCommand (tkptr, true, "TYPE I");
}
else
ProxyFtpCommand (tkptr, true, "TYPE I");
/* will return to this function with the STOR command done! */
return;
}
if (!tkptr->FtpStorDone)
{
/*********************/
/* send STOR command */
/*********************/
tkptr->FtpStorDone = true;
cptr = NULL;
if (prptr)
{
if (prptr->MultipartFileName[0])
cptr = prptr->MultipartFileName;
if (prptr->MultipartUploadFileName[0])
cptr = prptr->MultipartUploadFileName;
if (sptr = cptr)
{
/* all we're interested is the name component */
while (*cptr) cptr++;
while (cptr > sptr && *cptr != '/' &&
*cptr != '\\' && *cptr != ']') cptr--;
if (*cptr == '/' || *cptr == '\\' || *cptr == ']') cptr++;
}
}
if (!cptr)
{
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
/* find the start of the file name */
while (cptr > tkptr->FtpFilePathPtr && *cptr != '/') cptr--;
cptr++;
}
if (!cptr || !*cptr)
{
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_PROXY_FTP_NO_FILENAME), FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_QUIT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
ProxyFtpCommand (tkptr, true, "STOR !AZ", cptr);
/* will return to this function with the STOR command done! */
return;
}
/*****************/
/* transfer data */
/*****************/
if (VMSok (rqptr->rqBody.DataStatus))
{
/* write this buffered chunk of the request body to the FTP server */
ProxyFtpDataWriteRaw (tkptr, &ProxyFtpStoreAst,
rqptr->rqBody.DataPtr, rqptr->rqBody.DataCount);
return;
}
if (rqptr->rqBody.DataStatus == SS$_ENDOFFILE)
{
/* end of body */
ProxyFtpDataCloseSocket (tkptr);
SysDclAst (&ProxyFtpLifeCycle, tkptr);
return;
}
rqptr->rqResponse.HttpStatus = 502;
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
ErrorVmsStatus (rqptr, rqptr->rqBody.DataStatus, FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_ABORT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
A chunk of the request body has been written to the remote FTP server.
*/
ProxyFtpStoreAst (PROXY_TASK *tkptr)
{
int DataCount;
char *DataPtr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpStoreAst() !&F !&S !UL", &ProxyFtpStoreAst,
tkptr->FtpDataWriteIOsb.Status, tkptr->FtpDataWriteIOsb.Count);
rqptr = tkptr->RequestPtr;
if (VMSok (tkptr->FtpDataWriteIOsb.Status))
{
BodyRead (rqptr);
return;
}
rqptr->rqResponse.HttpStatus = 502;
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
ErrorVmsStatus (rqptr, tkptr->FtpDataWriteIOsb.Status, FI_LI);
tkptr->FtpState = PROXY_FTP_STATE_ABORT;
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/****************************************************************************/
/*
Delete a file from the remote FTP server. This function initializes the
required data and issues a DELE command to the FTP server.
*/
ProxyFtpDelete (PROXY_TASK *tkptr)
{
int status;
char *cptr, *sptr;
char ContentType [64];
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpRetrieve()");
rqptr = tkptr->RequestPtr;
InstanceGblSecIncrLong (&ProxyAccountingPtr->FtpDeleCount);
if (tkptr->FtpFileSystem == PROXY_FTP_FILE_SYSTEM_VMS)
{
/* of course, VMS requires a version number! */
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
while (cptr > tkptr->FtpFilePathPtr && *cptr != '/' && *cptr != ';')
cptr--;
if (cptr[0] == ';')
{
if (cptr[1])
sptr = "";
else
sptr = "*";
}
else
if (tkptr->FtpSpecific == PROXY_FTP_SPECIFIC_MADGOAT)
sptr = "";
else
sptr = ";*";
}
else
sptr = "";
/* find the start of the file name */
cptr = tkptr->FtpFilePathPtr + tkptr->FtpFilePathLength;
while (cptr > tkptr->FtpFilePathPtr && *cptr != '/') cptr--;
cptr++;
if (!tkptr->ResponseBufferPtr)
{
tkptr->ResponseBufferSize = ProxyReadBufferSize;
tkptr->ResponseBufferPtr = VmGetHeap (rqptr, ProxyReadBufferSize);
}
/* reset the IO status block for the first read */
tkptr->FtpDataReadIOsb.Status = tkptr->FtpDataReadIOsb.Count = 0;
ProxyFtpCommand (tkptr, true, "DELE !AZ!AZ", cptr, sptr);
}
/****************************************************************************/
/*
Searches the query string for the keyword. Keywords are designed to be
detected whether supplied as "?keyword", "?keyword1+keyword2",
"keyword=anything", "keyword1=anything&keyword2=anything", or where the keyword
occurs as the value of a form field, for example "?type=ascii". This allows
for simply adding the keyword to the URL or use in an HTML form. Needless to
say, the keywords must be unique. Returns a pointer to the start of the
keyword if found or NULL if not.
*/
char* ProxyFtpInQueryString
(
char *QueryStringPtr,
char *KeywordPtr
)
{
int KeywordLength;
char *cptr, *sptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_PROXY))
WatchThis (WATCHALL, WATCH_MOD_PROXY,
"ProxyFtpInQueryString() !&Z !&Z",
QueryStringPtr, KeywordPtr);
KeywordLength = strlen(KeywordPtr);
cptr = QueryStringPtr;
while (*cptr)
{
/* "content=" is a special case for field value processing */
if (strsame (cptr, "content=", 8) && strsame (KeywordPtr, "content", 7))
return (cptr);
/* all other the keywords can be anywhere in the string */
if (strsame (cptr, KeywordPtr, KeywordLength)) return (cptr);
while (*cptr && *cptr != '+' && !cptr != '&' && *cptr != '=') cptr++;
if (*cptr) cptr++;
}
return (NULL);
}
/****************************************************************************/
/*
************
*** NOTE *** This function takes a pointer to a request!!!
************
This function is called from ProxyRequestBegin() and so has nothing to do with
ProxyFtpLifeCycle().
*/
ProxyFtpStoreForm (REQUEST_STRUCT *rqptr)
{
static char FormFao [] =
"!AZ\
<html>\n\
<head>\n\
<title>FTP Upload</title>\n\
</head>\n\
<body>\n\
<form action=\"!AZ\" method=\"POST\" ENCtype=\"multipart/form-data\">\n\
<input type=\"radio\" name=type value=\"default\" checked>default\n\
<input type=\"radio\" name=type value=\"ascii\">ASCII\n\
<input type=\"radio\" name=type value=\"image\">image\n\
<br><input type=\"file\" name=name size=\"20\">\n\
<br><input type=\"submit\" value=\" !AZ \">\n\
</form>\n\
</body>\n\
</html>\n";
char *cptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_PROXY, "ProxyFtpStoreForm()");
/* make sure this form is only called the once! */
for (cptr = rqptr->rqHeader.RequestUriPtr; *cptr && *cptr != '?'; cptr++);
if (*cptr) cptr++;
cptr = ProxyFtpInQueryString (cptr, "upload");
if (cptr) *cptr = 'v';
rqptr->rqResponse.PreExpired = PRE_EXPIRE_FTP_PROXY;
ResponseHeader (rqptr, 200, "text/html", -1, NULL, NULL);
FaoToNet (rqptr, FormFao,
WASD_DOCTYPE, rqptr->rqHeader.RequestUriPtr, "Upload");
}
/****************************************************************************/
/*
Attempt to open a socket connected to the IP address and port specified by the
PASV response. This will become the data transfer connection. ASTs to
ProxyFtpDataConnect().
*/
ProxyFtpDataConnect (PROXY_TASK *tkptr)
{
static BOOL UseFullDuplexClose = true;
int qiofun, status;
void *BindSocketNamePtr;
SOCKADDRIN *sin4ptr;
SOCKADDRIN6 *sin6ptr;
TCP_SOCKET_ITEM *TcpSocketPtr;
VMS_ITEM_LIST2 *il2ptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpDataConnect()");
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_PROXY,
"FTP-DATA connect !&I,!UL",
&tkptr->FtpDataIpAddress, tkptr->FtpDataIpPort);
if (IPADDRESS_IS_SET (&tkptr->BindIpAddress))
{
/* bind the FTP data socket to a specific IP address */
if (IPADDRESS_IS_V4 (&tkptr->BindIpAddress))
{
SOCKADDRESS_ZERO4 (&tkptr->FtpDataBindSocketName)
sin4ptr = &tkptr->FtpDataBindSocketName.sa.v4;
sin4ptr->SIN$B_FAMILY = TCPIP$C_AF_INET;
sin4ptr->SIN$W_PORT = 0;
IPADDRESS_SET4 (&sin4ptr->SIN$L_ADDR, &tkptr->BindIpAddress)
il2ptr = &tkptr->FtpDataBindSocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN);
il2ptr->item = 0;
il2ptr->buf_addr = &tkptr->FtpDataBindSocketName.sa.v4;
}
else
if (IPADDRESS_IS_V6 (&tkptr->BindIpAddress))
{
SOCKADDRESS_ZERO6 (&tkptr->FtpDataBindSocketName)
sin6ptr = &tkptr->FtpDataBindSocketName.sa.v6;
sin6ptr->SIN6$B_FAMILY = TCPIP$C_AF_INET;
sin6ptr->SIN6$W_PORT = 0;
IPADDRESS_SET6 (sin6ptr->SIN6$R_ADDR_OVERLAY.SIN6$T_ADDR,
&tkptr->BindIpAddress)
il2ptr = &tkptr->FtpDataBindSocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN6);
il2ptr->item = 0;
il2ptr->buf_addr = &tkptr->FtpDataBindSocketName.sa.v6;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
BindSocketNamePtr = (void*)il2ptr;
}
else
BindSocketNamePtr = 0;
if (IPADDRESS_IS_V4 (&tkptr->FtpDataIpAddress))
{
TcpSocketPtr = &TcpIpSocket4;
qiofun = IO$_SETMODE;
}
else
if (IPADDRESS_IS_V6 (&tkptr->FtpDataIpAddress))
{
TcpSocketPtr = &TcpIpSocket6;
qiofun = IO$_SETMODE | IO$M_EXTEND;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
for (;;)
{
/* assign a channel to the internet template device */
status = sys$assign (&TcpIpDeviceDsc, &tkptr->FtpDataChannel, 0, 0);
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->FtpDataConnectIOsb.Status = status;
SysDclAst (ProxyFtpDataConnectAst, tkptr);
return;
}
/* make the channel a TCP, connection-oriented socket */
status = sys$qiow (EfnWait, tkptr->FtpDataChannel,
qiofun, &tkptr->FtpDataConnectIOsb, 0, 0,
TcpSocketPtr, 0, BindSocketNamePtr,
0, UseFullDuplexClose ?
&TcpIpFullDuplexCloseOption : 0,
0);
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"sys$qiow() !&X !&X",
status, tkptr->FtpDataConnectIOsb.Status);
if (VMSok (status) && VMSok (tkptr->FtpDataConnectIOsb.Status)) break;
if (!UseFullDuplexClose) break;
UseFullDuplexClose = false;
/* Multinet 3.2 UCX driver barfs on FULL_DUPLEX_CLOSE, try without */
sys$dassgn (tkptr->FtpDataChannel);
}
/* it's a $QIOW so the IO status block is valid */
if (VMSok (status) && VMSnok (tkptr->FtpDataConnectIOsb.Status))
status = tkptr->FtpDataConnectIOsb.Status;
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->FtpDataConnectIOsb.Status = status;
SysDclAst (ProxyFtpDataConnectAst, tkptr);
return;
}
if (IPADDRESS_IS_V4 (&tkptr->FtpDataIpAddress))
{
SOCKADDRESS_ZERO4 (&tkptr->FtpDataSocketName)
sin4ptr = &tkptr->FtpDataSocketName.sa.v4;
sin4ptr->SIN$B_FAMILY = TCPIP$C_AF_INET;
sin4ptr->SIN$W_PORT = tkptr->FtpDataIpPort;
IPADDRESS_SET4 (&sin4ptr->SIN$L_ADDR, &tkptr->FtpDataIpAddress)
il2ptr = &tkptr->FtpDataSocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN);
il2ptr->item = TCPIP$C_SOCK_NAME;
il2ptr->buf_addr = sin4ptr;
qiofun = IO$_ACCESS;
}
else
if (IPADDRESS_IS_V6 (&tkptr->FtpDataIpAddress))
{
SOCKADDRESS_ZERO6 (&tkptr->FtpDataSocketName)
sin6ptr = &tkptr->FtpDataSocketName.sa.v6;
sin6ptr->SIN6$B_FAMILY = TCPIP$C_AF_INET6;
sin6ptr->SIN6$W_PORT = tkptr->FtpDataIpPort;
IPADDRESS_SET6 (sin6ptr->SIN6$R_ADDR_OVERLAY.SIN6$T_ADDR,
&tkptr->FtpDataIpAddress)
il2ptr = &tkptr->FtpDataSocketNameItem;
il2ptr->buf_len = sizeof(SOCKADDRIN6);
il2ptr->item = TCPIP$C_SOCK_NAME;
il2ptr->buf_addr = sin6ptr;
qiofun = IO$_ACCESS | IO$M_EXTEND;
}
else
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
status = sys$qio (EfnNoWait, tkptr->FtpDataChannel, qiofun,
&tkptr->FtpDataConnectIOsb, &ProxyFtpDataConnectAst, tkptr,
0, 0, &tkptr->FtpDataSocketNameItem, 0, 0, 0);
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"sys$qiow() !&X", status);
if (VMSnok (status))
{
/* leave it to the AST function to report! */
tkptr->FtpDataConnectIOsb.Status = status;
SysDclAst (ProxyFtpDataConnectAst, tkptr);
return;
}
}
/****************************************************************************/
/*
Called as an AST by ProxyFtpDataConnect() once the PASV data connection is
established or fails.
*/
ProxyFtpDataConnectAst (PROXY_TASK *tkptr)
{
int status;
char *cptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpDataConnectAst() !&F !&S",
&ProxyFtpDataConnectAst, tkptr->FtpDataConnectIOsb.Status);
rqptr = tkptr->RequestPtr;
if (VMSnok (tkptr->FtpDataConnectIOsb.Status))
{
/*****************/
/* connect error */
/*****************/
if (WATCHING (tkptr, WATCH_PROXY))
WatchThis (WATCHITM(rqptr), WATCH_PROXY, "FTP-DATA connect !&S",
tkptr->FtpDataConnectIOsb.Status);
ProxyFtpDataCloseSocket (tkptr);
tkptr->ResponseStatusCode = 502;
rqptr->rqResponse.HttpStatus = 502;
switch (tkptr->FtpDataConnectIOsb.Status)
{
case PROXY_ERROR_CONNECT_REFUSED :
cptr = MsgFor(rqptr,MSG_PROXY_CONNECT_REFUSED);
ErrorGeneral (rqptr, cptr, FI_LI);
break;
case PROXY_ERROR_HOST_UNREACHABLE :
cptr = MsgFor(rqptr,MSG_PROXY_HOST_UNREACHABLE);
ErrorGeneral (rqptr, cptr, FI_LI);
break;
default :
rqptr->rqResponse.ErrorTextPtr = tkptr->RequestHostPort;
ErrorVmsStatus (rqptr, tkptr->FtpDataConnectIOsb.Status, FI_LI);
}
}
SysDclAst (&ProxyFtpLifeCycle, tkptr);
}
/*****************************************************************************/
/*
Write to the data connection of the FTP server. Explicitly declares any AST
routine if an error occurs. The calling function must not do any error recovery
if an AST routine has been supplied but the associated AST routine must! If an
AST was not supplied then the return status can be checked. AST calls
ProxyFtpWriteRawAST() which will then call the supplied AST function.
*/
int ProxyFtpDataWriteRaw
(
PROXY_TASK *tkptr,
PROXY_AST AstFunction,
char *DataPtr,
int DataCount
)
{
int status;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpDataWriteRaw() !&F !&A !&X !UL",
&ProxyFtpDataWriteRaw, AstFunction, DataPtr, DataCount);
/* FTP data should never have blocking IO queued against it */
if (!AstFunction) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
rqptr = tkptr->RequestPtr;
if (tkptr->FtpDataWriteRawAstFunction || !DataCount)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
tkptr->FtpDataWriteRawAstFunction = AstFunction;
tkptr->FtpDataWriteRawDataPtr = DataPtr;
tkptr->FtpDataWriteRawDataCount = DataCount;
if (WATCHING (rqptr, WATCH_NETWORK_OCTETS))
{
WatchThis (WATCHITM(rqptr), WATCH_NETWORK,
"WRITE !UL bytes", DataCount);
WatchDataDump (DataPtr, DataCount);
}
status = sys$qio (EfnNoWait, tkptr->FtpDataChannel,
IO$_WRITEVBLK, &tkptr->FtpDataWriteIOsb,
&ProxyFtpDataWriteRawAst, tkptr,
DataPtr, DataCount, 0, 0, 0, 0);
if (VMSok (status)) return (status);
/* if resource wait enabled the only quota not waited for is ASTLM */
if (status == SS$_EXQUOTA)
ErrorExitVmsStatus (status, NULL, FI_LI);
/* write failed, call AST explicitly, status in the IOsb */
tkptr->FtpDataWriteIOsb.Status = status;
tkptr->FtpDataWriteIOsb.Count = 0;
SysDclAst (ProxyFtpDataWriteRawAst, tkptr);
return (status);
}
/*****************************************************************************/
/*
AST from ProxyFtpDataWriteRaw(). Call the AST function.
*/
ProxyFtpDataWriteRawAst (PROXY_TASK *tkptr)
{
int status;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpDataWriteRawAst() !&F !&S !UL",
&ProxyFtpDataWriteRawAst,
tkptr->FtpDataWriteIOsb.Status, tkptr->FtpDataWriteIOsb.Count);
rqptr = tkptr->RequestPtr;
if (WATCHING (tkptr, WATCH_NETWORK))
{
if (VMSnok(tkptr->FtpDataWriteIOsb.Status))
WatchThis (WATCHITM(tkptr), WATCH_NETWORK,
"WRITE !&S",
tkptr->FtpDataWriteIOsb.Status);
else
WatchThis (WATCHITM(tkptr), WATCH_NETWORK,
"WRITE !&S !UL bytes",
tkptr->FtpDataWriteIOsb.Status,
tkptr->FtpDataWriteIOsb.Count);
}
if (VMSok (tkptr->FtpDataWriteIOsb.Status))
{
tkptr->NetIoPtr->BlocksRawTx64++;
tkptr->NetIoPtr->BlocksTallyTx64++;
tkptr->NetIoPtr->BytesRawTx64 += tkptr->FtpDataWriteIOsb.Count;
tkptr->NetIoPtr->BytesTallyTx64 += tkptr->FtpDataWriteIOsb.Count;
}
if (tkptr->FtpDataWriteRawAstFunction)
SysDclAst (tkptr->FtpDataWriteRawAstFunction, tkptr);
tkptr->FtpDataWriteRawDataCount = 0;
tkptr->FtpDataWriteRawAstFunction = tkptr->FtpDataWriteRawDataPtr = NULL;
}
/*****************************************************************************/
/*
Queue up a read from the data port of the FTP server. If 'AstFunction' is zero
then no I/O completion AST routine is called. If it is non-zero then the
function pointed to by the parameter is called when the network write
completes.
Explicitly declares any AST routine if an error occurs. The calling function
must not do any error recovery if an AST routine has been supplied but the
associated AST routine must! If an AST was not supplied then the return
status can be checked.
*/
int ProxyFtpDataReadRaw
(
PROXY_TASK *tkptr,
PROXY_AST AstFunction,
char *DataPtr,
int DataSize
)
{
int status;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpDataReadRaw() !&F !&A !&X !UL",
&ProxyFtpDataReadRaw, AstFunction, DataPtr, DataSize);
/* FTP data should never have blocking IO queued against it */
if (!AstFunction) ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
rqptr = tkptr->RequestPtr;
if (tkptr->FtpDataReadRawAstFunction)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
tkptr->FtpDataReadRawAstFunction = AstFunction;
tkptr->FtpDataReadRawDataPtr = DataPtr;
tkptr->FtpDataReadRawDataSize = DataSize;
if (WATCHING (rqptr, WATCH_NETWORK_OCTETS))
WatchThis (WATCHITM(rqptr), WATCH_NETWORK,
"READ !UL bytes max", DataSize);
status = sys$qio (EfnNoWait, tkptr->FtpDataChannel,
IO$_READVBLK, &tkptr->FtpDataReadIOsb,
&ProxyFtpDataReadRawAst, tkptr,
DataPtr, DataSize, 0, 0, 0, 0);
if (VMSok (status)) return (status);
/* with resource wait enabled the only quota not waited for is ASTLM */
if (status == SS$_EXQUOTA)
ErrorExitVmsStatus (status, NULL, FI_LI);
/* queuing of read failed, call AST explicitly, status in the IOsb */
tkptr->FtpDataReadIOsb.Status = status;
tkptr->FtpDataReadIOsb.Count = 0;
SysDclAst (ProxyFtpDataReadRawAst, tkptr);
return (status);
}
/*****************************************************************************/
/*
AST from ProxyFtpDataReadRaw(). Call the AST function.
*/
ProxyFtpDataReadRawAst (PROXY_TASK *tkptr)
{
int status;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpDataReadRawAst() !&F !&S !UL",
&ProxyFtpDataReadRawAst,
tkptr->FtpDataReadIOsb.Status, tkptr->FtpDataReadIOsb.Count);
rqptr = tkptr->RequestPtr;
if (WATCHPNT(tkptr))
{
if (WATCH_CATEGORY(WATCH_NETWORK) ||
WATCH_CATEGORY(WATCH_NETWORK_OCTETS))
{
if (VMSok(tkptr->FtpDataReadIOsb.Status))
{
WatchThis (WATCHITM(tkptr), WATCH_NETWORK,
"READ !&S !UL bytes",
tkptr->FtpDataReadIOsb.Status,
tkptr->FtpDataReadIOsb.Count);
if WATCH_CATEGORY(WATCH_NETWORK_OCTETS)
WatchDataDump (tkptr->FtpDataReadRawDataPtr,
tkptr->FtpDataReadIOsb.Count);
}
else
WatchThis (WATCHITM(tkptr), WATCH_NETWORK,
"READ !&S",
tkptr->FtpDataReadIOsb.Status);
}
}
if (VMSok (tkptr->FtpDataReadIOsb.Status))
{
tkptr->NetIoPtr->BlocksRawRx64++;
tkptr->NetIoPtr->BlocksTallyRx64++;
tkptr->NetIoPtr->BytesRawRx64 += tkptr->FtpDataReadIOsb.Count;
tkptr->NetIoPtr->BytesTallyRx64 += tkptr->FtpDataReadIOsb.Count;
/* zero bytes with a normal status is a definite no-no (TGV-Multinet) */
if (!tkptr->FtpDataReadIOsb.Count)
tkptr->FtpDataReadIOsb.Status = SS$_ABORT;
}
if (tkptr->FtpDataReadRawAstFunction)
SysDclAst (tkptr->FtpDataReadRawAstFunction, tkptr);
tkptr->FtpDataReadRawDataSize = 0;
tkptr->FtpDataReadRawAstFunction = tkptr->FtpDataReadRawDataPtr = NULL;
}
/****************************************************************************/
/*
Just shut the FTP data socket down, bang!
*/
int ProxyFtpDataCloseSocket (PROXY_TASK *tkptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpDataCloseSocket() !&F", &ProxyFtpDataCloseSocket);
if (!tkptr->FtpDataChannel) return (SS$_NORMAL);
status = sys$dassgn (tkptr->FtpDataChannel);
tkptr->FtpDataChannel = 0;
if (WATCHING (tkptr, WATCH_PROXY))
{
if (VMSok(status))
WatchThis (WATCHITM(tkptr), WATCH_PROXY, "FTP-DATA close !AZ,!UL",
tkptr->RequestHostName, tkptr->RequestPort);
else
WatchThis (WATCHITM(tkptr), WATCH_PROXY, "FTP-DATA close !AZ,!UL !&S",
tkptr->RequestHostName, tkptr->RequestPort, status);
}
return (status);
}
/****************************************************************************/
/*
Map FTP response status codes over into HTTP response status codes.
*/
int ProxyFtpHttpStatus (PROXY_TASK *tkptr)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (tkptr, WATCH_MOD_PROXY))
WatchThis (WATCHITM(tkptr), WATCH_MOD_PROXY,
"ProxyFtpHttpStatus() !UL", tkptr->FtpResponseCode);
switch (tkptr->FtpResponseCode)
{
case 202 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 501);
case 257 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 201);
case 421 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 503);
case 425 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 502);
case 426 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 502);
case 450 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 404);
case 451 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 502);
case 452 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 502);
case 500 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 502);
case 501 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 502);
case 502 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 501);
case 503 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 502);
case 504 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 501);
case 530 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 401);
case 532 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 403);
case 550 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 404);
case 551 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 502);
case 552 : return (tkptr->RequestPtr->rqResponse.HttpStatus = 403);
}
return (tkptr->RequestPtr->rqResponse.HttpStatus = 500);
}
/****************************************************************************/