[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]
/*****************************************************************************/
/*
body.c
Request body transfer from client, any content processing, etc.
The functions BodyProcessUrlEncoded() and BodyProcessMultipartFormData()
process request body data once it has been read from the client. When data
should be passed on to the calling/using function is calls the AST with the
following storage set. Note that the 'rqBody.Data..' buffer can contain either
raw or processed data, but is always what the current function requires to
continue processing the request body.
'rqptr->rqBody.DataStatus'
containing the VMS status relevant to the processing
'rqptr->rqBody.DataPtr'
pointing to the start of virtual block(s) of data
'rqptr->rqBody.DataCount'
containing the number of bytes in the buffer (whole blocks or left-over)
'rqptr->rqBody.DataVBN'
the virtual block number (1 to whatever, if applicable)
This sort of processing using ASTs is particularly painful. Lots of buffering
is required to allow for octets that must be processed together (e.g. %xx
URL-encoded) to be delivered split between two reads.
To allow file-system functions to perform block I/O the AST is only ever
delivered with a buffer containing a whole number of 512 bytes blocks unless it
is the final call when it may contain from 1 to 511 bytes.
Transfer-Encoding: chunked
--------------------------
Chunked transfer encoding is a HTTP/1.1 fact of life. As the binary content of
these bodies is always smaller after decoding they are unchunked in the same
buffer space that is used to read the chunked stream from the network. Testing
chunked upload can be performed with the WASD Bench utility (v1.2 and later).
With a suitable POST target in the file-system merely upload files of various
sizes and contents into that file-system area and compare the upload with the
original using the DIFFERENCE utility.
$ WB /POST=<filename> /TRANSFER=CHUNKED "http://host/test/<filename>"
$ DIFFERENCE <filename> TEST:[000000]<filename>
$ WB /POST=<filename> /TRANSFER=CHUNKED=300 "http://host/test/<filename>"
$ WB /POST=<filename> /TRANSFER=CHUNKED=0 "http://host/test/<filename>"
Content-Encoding: gzip
----------------------
GZIP compression for request bodies is available in conjunction with the GZIP.C
module and ZLIB library (sharable image). As the decompressed content is
almost invariably larger than the original raw data some form of double
buffering is required. This keeps the network data intact while having the
ZLIB inflation function produce usually multiple, successive output buffers
that are given to the body processing function(s) independently. Using a
similar approach as with chunked upload testing GZIP compressed upload can be
performed with the WASD Bench utility (v1.2 and later). It is first necessary
to create a GZIPed object using the GZIP utility. This behaves as if it a
client-generated GZIP request body.
$ COPY <filename1> <filename2>
$ GZIP <filename2>
$ WB /POST=<filename2>-gz /ENCODING="gzip" "http://host/test/<filename2>"
$ DIFFERENCE <filename1> TEST:[000000]<filename2>
Content-Type: application/x-www-form-urlencoded
-----------------------------------------------
When the processing function BodyProcessUrlEncoded() is used ...
If the document 'Content-Type:' is "application/x-www-form-urlencoded" (i.e.
generated from an HTML form) all field names and delimiting symbols are
eliminated and the field(s) content (only) converted into plain text. Hence a
text document can be POSTed using an HTML form with only the content ending up
in the file.
A field name (beginning with) "hexencoded" is expected to contain hexadecimal
encoded bytes (i.e. two hexadecimal digits per byte), as well as some
url-encoded characters (e.g. newlines, 0x0a). The contents of this field are
decoded before inclusion in the file. This was done to allow non-text files to
be copied around.
Content-Type: multipart/form-data
---------------------------------
When the processing function BodyProcessMultipartFormData() is used ...
This module can process a request body according to RFC-1867, "Form-based File
Upload in HTML". As yet it is not a full implementation. It will not process
"multipart/mixed" subsections. The 'Content-Type:' is "multipart/form-data".
The implementation herein is very basic, a facility only to allow uploads of
files into the server administered file system. The action= tag of the form
must specify the directory (URL format) in which the uploaded file will be
created.
Multipart/form-data Fields
--------------------------
All file names supplied within a multipart/form-data request are relative to
the path information supplied in the header request. Hence it must supply
a directory specification. It is an error condition if this directory is not
specified, and all file specifications are generated by appending file names
to this directory.
In addition to file uploads, specific field names within a multipart/form-data
request are detected and used as additional information or to initiate actions.
These field names are case insensistive, as is any content within them.
When uploading files, the field "UploadFileName" contents, when received
before the file contents themselves (i.e. "text" field occurs in the form
before the "file" field) provides an alternative name to the original file.
Any other value present in the action field is reported as an error.
All required file names must be specified "file.type" prior to the action
being initiated (i.e. name fields must be present in the form before the
action field). The following (hopefully self-documenting) field names can be
used to pass file names for action:
o "FileName"
o "UploadFileName"
o "Protection"
o "PreviewOnly"
o "PreviewNote"
o "Success"
o "Hidden$LF"
Any other field names present in the request are reported as errors.
VERSION HISTORY
---------------
22-NOV-2020 MGD content length now 64 bit
21-MAR-2017 MGD bugfix; use rqHeader.RequestBody.. for body with header
05-SEP-2015 MGD accomodate HTTP/2
17-JUN-2010 MGD significant rework to function()alise common code
improve performance with multiblock of 127 (per JPP)
30-APR-2010 MGD BODY.C make MultipartContentType(Ptr) a dynamic structure
as Microsoft endeavour to include application data
along with MIME content-type, see ...
http://msdn.microsoft.com/en-us/library/aa338205.aspx
and an example (no kidding!) ...
"application/vnd.ms.powerpoint.template.macroEnabled.12application/x-font"
27-OCT-2009 MGD bugfix; BodyReadUnEncode() unchunk all but scripts
07-JUN-2007 MGD BodyProcessReadAll() set buffer size to content length
17-JAN-2007 MGD bugfix; BodyReadBegin() 413 set status before declaring AST
14-NOV-2004 MGD bugfix; BodyRead() maximum exceeded must set read
error status before calling AST (jpp@esme.fr)
17-OCT-2004 MGD inflate gzip content-encoding,
by default script body transfers are now un-encoded
20-JUL-2004 MGD HTTP/1.1 compliance,
provide "100 Continue" response before reading body,
decode "Transfer-encoding: chunked" request bodies
15-AUG-2003 MGD where CDATA constraints make using entity impossible
use a field name of hidden$lf and ^ substituted for it
21-JUN-2003 MGD bugfix; data to be read needs to be the smaller of
remaining body or buffer size (jpp@esme.fr)
24-MAR-2003 MGD bugfix; processing of DCL module script processing restart
05-DEC-2002 MGD allow for white-space in multipart file names
25-AUG-2002 MGD introduce fab$b_rfm and fab$b_rat as fields to allow
PUT.C to specifically set these attributes as required,
bugfix; restart MIME boundary matching algorithm using
the current character (to allow for <CR><LF><CR><LF>)
01-AUG-2002 MGD bugfix; when discarding via BodyReadBegin() use BodyRead()
to queue a network read only if data is outstanding
30-JUN-2002 MGD allow BodyReadBegin() to reset ASTs for RequestBodyDiscard()
07-JUN-2002 MGD bugfix; sanity check where there shouldn't be one
02-FEB-2002 MGD couldn't avoid doing something about it any longer
*/
/*****************************************************************************/
#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
#include <stdio.h>
#include <ctype.h>
#include "wasd.h"
#define WASD_MODULE "BODY"
/******************/
/* global storage */
/******************/
int BodyMultiBlockCount = PUT_MULTIBLOCK_COUNT_DEFAULT;
/********************/
/* external storage */
/********************/
extern BOOL GzipAccept;
extern int NetReadBufferSize;
extern int ToLowerCase[],
ToUpperCase[];
extern char ErrorSanityCheck[];
extern CONFIG_STRUCT Config;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Initialize and initiate the first request body read from the client. If
request body data arrived with the request header a pseudo-read occurs, with
explicit AST delivery. Otherwise just read from the network.
*/
void BodyReadBegin
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction,
REQUEST_AST ProcessFunction
)
{
int status,
DataSize,
MaxKbytes;
int64 ContentLength64;
char *cptr;
char String [256];
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyReadBegin() chunked:!&B gzip:!&B length:!@SQ expected:!@SQ \
ast:!&A process:!&A",
rqptr->rqHeader.TransferEncodingChunked,
rqptr->rqHeader.ContentEncodingGzip,
&rqptr->rqHeader.ContentLength64,
rqptr->rqHeader.XExpectedEntityLength64,
AstFunction, ProcessFunction);
if (rqptr->rqBody.AstFunction)
{
if (AstFunction == (REQUEST_AST)&DclHttpInput &&
rqptr->rqBody.AstFunction == (REQUEST_AST)&DclHttpInput)
{
/************************************************/
/* special case - restarting DCL script process */
/************************************************/
/* provide the same data that was previously supplied */
SysDclAst (&DclHttpInput, rqptr);
return;
}
/* this shouldn't happen */
ErrorNoticed (rqptr, SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus = SS$_BUGCHECK;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (!(ContentLength64 = rqptr->rqHeader.ContentLength64))
/* a WebDAVFS/3.0.0 and/or OS X (Apple) quirk */
ContentLength64 = rqptr->rqHeader.XExpectedEntityLength64;
if (ContentLength64)
{
/* before the "100 Continue" - request body allowed to be this big? */
if (!(MaxKbytes = rqptr->rqPathSet.PutMaxKbytes))
MaxKbytes = Config.cfMisc.PutMaxKbytes;
if (!rqptr->ProxyTaskPtr &&
ContentLength64 >> 10 > MaxKbytes)
{
cptr = MsgFor(rqptr,MSG_REQUEST_BODY_MAX);
status = FaoToBuffer (String, sizeof(String), NULL, cptr,
rqptr->rqHeader.MethodName,
ContentLength64 >> 10, MaxKbytes);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
rqptr->PersistentRequest = rqptr->PersistentResponse = false;
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus = SS$_ABORT;
rqptr->rqResponse.HttpStatus = 413;
ErrorGeneral (rqptr, String, FI_LI);
/* RequestBodyDiscard() uses this for progress determination */
SysDclAst (rqptr->rqBody.AstFunction = AstFunction, rqptr);
return;
}
}
rqptr->rqBody.AstFunction = AstFunction;
rqptr->rqBody.ProcessFunction = ProcessFunction;
rqptr->rqBody.DataCount = rqptr->rqBody.ContentCount64 = 0;
rqptr->rqBody.ContentLength64 = ContentLength64;
rqptr->rqBody.DataVBN = 1;
if (!ContentLength64 &&
!rqptr->rqHeader.TransferEncodingChunked)
{
/* no body to be supplied */
rqptr->rqBody.DataPtr = "";
rqptr->rqBody.DataSize = 0;
rqptr->rqBody.ProcessedAs = BODY_PROCESSED_AS_NONE;
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus = SS$_ENDOFFILE;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (rqptr->Http2Stream.Http2Ptr)
{
/* HTTP/2 allocate now that it is needed */
rqptr->rqNet.ReadBufferSize =
rqptr->Http2Stream.Http2Ptr->ServerMaxFrameSize;
rqptr->rqNet.ReadBufferPtr =
VmGetHeap (rqptr, rqptr->rqNet.ReadBufferSize);
}
else
{
/* HTTP/1.n allow for any content received along with the header */
rqptr->NetIoPtr->ReadCount = rqptr->BytesRx64 -
rqptr->rqHeader.RequestHeaderLength;
}
rqptr->rqBody.DataPtr = rqptr->rqNet.ReadBufferPtr;
rqptr->rqBody.DataSize = rqptr->rqNet.ReadBufferSize;
if (rqptr->rqHeader.HttpVersion == HTTP_VERSION_1_1)
{
rqptr->rqBody.UnEncodeStream = BodyReadUnEncode (rqptr);
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"Unencode stream: !&B", rqptr->rqBody.UnEncodeStream);
/* is a "100 Continue" interim response required at this point? */
if ((rqptr->rqHeader.Expect100Continue ||
rqptr->rqHeader.Method == HTTP_METHOD_PUT ||
rqptr->rqHeader.Method == HTTP_METHOD_POST) &&
!rqptr->rqResponse.HeaderSent &&
!rqptr->DclTaskPtr &&
!rqptr->DECnetTaskPtr &&
!rqptr->ProxyTaskPtr)
ResponseHeader100Continue (rqptr);
}
/* once we start reading into the buffer the request header is kaput */
rqptr->rqHeader.RequestHeaderPtrInvalid = true;
/* may be reset by using ..UrlEncoded() or ..MultipartFormData() */
if (ConfigSameContentType (rqptr->rqHeader.ContentTypePtr, "text/", 5))
rqptr->rqBody.ProcessedAs = BODY_PROCESSED_AS_TEXT;
else
rqptr->rqBody.ProcessedAs = BODY_PROCESSED_AS_OTHER;
/* ensure this does not exceed any specified content length */
if (rqptr->rqBody.ContentLength64 &&
rqptr->NetIoPtr->ReadCount > rqptr->rqBody.ContentLength64)
rqptr->NetIoPtr->ReadCount = rqptr->rqBody.ContentLength64;
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"Length:!@SQ BytesRx:!@SQ HeaderLength:!UL (!UL) IOsb.Count:!UL",
&rqptr->rqBody.ContentLength64, &rqptr->BytesRx64,
rqptr->rqHeader.RequestHeaderLength,
rqptr->BytesRx64 - rqptr->rqHeader.RequestHeaderLength,
rqptr->NetIoPtr->ReadCount);
if (rqptr->rqHeader.RequestBodyCount)
{
/* data arrived with the request header, provide that */
rqptr->rqBody.DataPtr = rqptr->rqHeader.RequestBodyPtr;
rqptr->NetIoPtr->ReadCount = rqptr->rqHeader.RequestBodyCount;
rqptr->NetIoPtr->ReadStatus = SS$_NORMAL;
SysDclAst (&BodyReadAst, rqptr);
rqptr->rqHeader.RequestBodyPtr = NULL;
rqptr->rqHeader.RequestBodyCount = 0;
return;
}
if (rqptr->rqHeader.TransferEncodingChunked)
{
/* don't know at this stage, so just read as much as possible */
DataSize = rqptr->rqNet.ReadBufferSize;
}
else
{
/* data to be read is the smaller of remaining body or buffer size */
DataSize = rqptr->rqBody.ContentLength64 - rqptr->rqBody.ContentCount64;
if (DataSize > rqptr->rqBody.DataSize) DataSize = rqptr->rqBody.DataSize;
}
NetRead (rqptr, &BodyReadAst, rqptr->rqBody.DataPtr, DataSize);
}
/*****************************************************************************/
/*
Should the request body be unencoded or be delivered as raw stream?
Return true or false.
*/
BOOL BodyReadUnEncode (REQUEST_STRUCT *rqptr)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "BodyReadUnEncode()");
if (rqptr->rqHeader.HttpVersion == HTTP_VERSION_1_1)
{
if (rqptr->ProxyTaskPtr)
return (false);
else
if (rqptr->rqHeader.TransferEncodingChunked)
{
if (rqptr->ScriptName[0] &&
!rqptr->rqPathSet.ScriptBodyDecode) return (false);
/* all other chunked */
return (true);
}
else
if (rqptr->rqHeader.ContentEncodingGzip)
{
if (GzipAccept && rqptr->rqPathSet.ScriptBodyDecode)
return (true);
else
return (false);
}
else
return (false);
}
return (false);
}
/*****************************************************************************/
/*
If there is still more to be read of the request body (as indicated by a
difference between what has been read and the content-length indicated in the
request header) the queue another read. If the entire request body has been
read generate an end-of-file status.
*/
void BodyRead (REQUEST_STRUCT *rqptr)
{
int status,
DataSize,
MaxKbytes;
char *cptr;
char String [256];
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyRead() !&B !UL !@SQ/!@SQ",
rqptr->rqBody.UnEncodeStream, rqptr->rqBody.ChunkState,
&rqptr->rqBody.ContentCount64, &rqptr->rqBody.ContentLength64);
if (rqptr->RequestState == REQUEST_STATE_ABORT)
{
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus = SS$_ABORT;
rqptr->rqBody.DataCount = rqptr->NetIoPtr->ReadCount = 0;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
/* ongoing check - request body allowed to be this big? */
if (!(MaxKbytes = rqptr->rqPathSet.PutMaxKbytes))
MaxKbytes = Config.cfMisc.PutMaxKbytes;
if (!rqptr->DclTaskPtr &&
!rqptr->ProxyTaskPtr &&
(rqptr->rqBody.ContentCount64 >> 10) > MaxKbytes)
{
cptr = MsgFor(rqptr,MSG_REQUEST_BODY_MAX);
status = FaoToBuffer (String, sizeof(String), NULL, cptr,
rqptr->rqHeader.MethodName,
rqptr->rqBody.ContentCount64 >> 10, MaxKbytes);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
rqptr->rqResponse.HttpStatus = 413;
ErrorGeneral (rqptr, String, FI_LI);
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus = SS$_ABORT;
rqptr->rqBody.DataCount = rqptr->NetIoPtr->ReadCount = 0;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (rqptr->rqBody.UnEncodeStream &&
rqptr->rqHeader.ContentEncodingGzip &&
(rqptr->NetIoPtr->ReadCount ||
rqptr->GzipCompress.InflateAvailIn))
{
/* there is still data that can be fed into the inflate function */
BodyReadProcess (rqptr);
return;
}
if (rqptr->rqHeader.TransferEncodingChunked)
{
/********************/
/* transfer chunked */
/********************/
if (rqptr->rqBody.UnEncodeStream)
{
/* being unencoded (therefore we can detect the end of it) */
if (rqptr->rqBody.ChunkState != CHUNK_STATE_END)
{
/* not the end of the chunked body just yet! */
rqptr->rqBody.DataPtr = rqptr->rqNet.ReadBufferPtr;
rqptr->rqBody.DataSize = rqptr->rqNet.ReadBufferSize;
NetRead (rqptr, &BodyReadAst, rqptr->rqBody.DataPtr,
rqptr->rqBody.DataSize);
return;
}
/* fall through as end-of-body */
}
else
{
/* not being un-encoded (keep reading 'till the bitter end) */
rqptr->rqBody.DataPtr = rqptr->rqNet.ReadBufferPtr;
rqptr->rqBody.DataSize = rqptr->rqNet.ReadBufferSize;
NetRead (rqptr, &BodyReadAst, rqptr->rqBody.DataPtr,
rqptr->rqBody.DataSize);
return;
}
}
if (!rqptr->rqHeader.TransferEncodingChunked &&
rqptr->rqBody.ContentCount64 < rqptr->rqBody.ContentLength64)
{
/*************/
/* read more */
/*************/
rqptr->rqBody.DataPtr = rqptr->rqNet.ReadBufferPtr;
rqptr->rqBody.DataSize = rqptr->rqNet.ReadBufferSize;
/* data to be read is the smaller of remaining body or buffer size */
DataSize = rqptr->rqBody.ContentLength64 - rqptr->rqBody.ContentCount64;
if (DataSize > rqptr->rqBody.DataSize) DataSize = rqptr->rqBody.DataSize;
NetRead (rqptr, &BodyReadAst, rqptr->rqBody.DataPtr, DataSize);
return;
}
/***************/
/* end of body */
/***************/
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus = SS$_ENDOFFILE;
rqptr->rqBody.DataCount = rqptr->NetIoPtr->ReadCount = 0;
if (rqptr->rqHeader.ContentLength64)
{
if (rqptr->rqHeader.ContentLength64 != rqptr->rqBody.ContentCount64)
{
if (WATCHING (rqptr, WATCH_REQUEST_BODY))
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY,
"Content-Length: !@SQ !!= !@SQ",
rqptr->rqHeader.ContentLength64, rqptr->rqBody.ContentCount64);
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus = SS$_ABORT;
}
}
else
if (rqptr->rqHeader.XExpectedEntityLength64)
{
/* an OSX (Apple) WebDAV quirk */
if (rqptr->rqHeader.XExpectedEntityLength64 !=
rqptr->rqBody.ContentCount64)
{
if (WATCHING (rqptr, WATCH_REQUEST_BODY))
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY,
"X-Expected-Entity-Length: !@SQ !!= !@SQ",
rqptr->rqHeader.XExpectedEntityLength64,
rqptr->rqBody.ContentCount64);
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus = SS$_ABORT;
}
}
if (rqptr->rqBody.ProcessFunction)
SysDclAst (rqptr->rqBody.ProcessFunction, rqptr);
else
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
}
/*****************************************************************************/
/*
Network read has completed. This function will never be called for ENDOFFILE,
only success or legitimate error status. This function accepts data specified
by the IO status block (NetIoPtr->ReadStatus and NetIoPtr->ReadCount).
*/
void BodyReadAst (REQUEST_STRUCT *rqptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyReadAst() !&F !&S !UL !@SQ !@SQ", &BodyReadAst,
rqptr->NetIoPtr->ReadStatus, rqptr->NetIoPtr->ReadCount,
&rqptr->rqBody.ContentLength64, &rqptr->rqBody.ContentCount64);
if (VMSnok (rqptr->NetIoPtr->ReadStatus))
{
/* error */
rqptr->rqBody.DataCount = 0;
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus;
if (!rqptr->rqResponse.HttpStatus)
{
rqptr->rqResponse.HttpStatus = 400;
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_REQUEST_BODY_READ);
ErrorVmsStatus (rqptr, rqptr->NetIoPtr->ReadStatus, FI_LI);
}
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (rqptr->rqBody.UnEncodeStream &&
rqptr->rqHeader.TransferEncodingChunked)
{
/********************/
/* transfer chunked */
/********************/
BodyTransferChunked (rqptr);
if (VMSok (rqptr->NetIoPtr->ReadStatus))
{
if (!rqptr->NetIoPtr->ReadCount)
{
/* need to read more of the body from the client */
BodyRead (rqptr);
return;
}
/* otherwise drop thru to further process */
}
else
{
/* an error was reported */
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
}
else
{
/* keep track of how much raw data has been read of the body */
rqptr->rqBody.ContentCount64 += rqptr->NetIoPtr->ReadCount;
}
BodyReadProcess (rqptr);
}
/*****************************************************************************/
/*
This function called after a real network read has completed or after a GZIP
encoded body chunk has been directly identified in BodyRead() (bypassing
BodyReadAst()). This function accepts data specified by the IO status block
(NetIoPtr->ReadStatus and NetIoPtr->ReadCount) and provides data identified
by the body data structure (rqBody.DataStatus and rqptr->rqBody.DataCount).
*/
void BodyReadProcess (REQUEST_STRUCT *rqptr)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyReadProcess() !&F !&S !UL !@SQ !@SQ", &BodyReadProcess,
rqptr->NetIoPtr->ReadStatus, rqptr->NetIoPtr->ReadCount,
rqptr->rqBody.ContentLength64, rqptr->rqBody.ContentCount64);
if (rqptr->rqBody.UnEncodeStream &&
rqptr->rqHeader.ContentEncodingGzip)
{
/******************/
/* content GZIPed */
/******************/
BodyContentGzip (rqptr);
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyContentGzip() !&S !UL",
rqptr->rqBody.DataStatus, rqptr->rqBody.DataCount);
if (VMSok (rqptr->rqBody.DataStatus))
{
if (!rqptr->rqBody.DataCount)
{
/* need to provide more of the body from the client */
BodyRead (rqptr);
return;
}
/* otherwise drop thru to further process */
}
else
{
/* an error was reported */
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
}
else
{
rqptr->rqBody.DataStatus = rqptr->NetIoPtr->ReadStatus;
rqptr->rqBody.DataCount = rqptr->NetIoPtr->ReadCount;
}
if (WATCHING (rqptr, WATCH_REQUEST_BODY))
{
if (rqptr->rqHeader.ContentEncodingGzip)
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY,
"BODY gzip !UL/!@SQ bytes",
rqptr->rqBody.DataCount, &rqptr->rqBody.ContentCount64);
else
if (rqptr->rqBody.ContentLength64)
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY,
"BODY !UL/!@SQ/!@SQ bytes",
rqptr->rqBody.DataCount, &rqptr->rqBody.ContentCount64,
&rqptr->rqBody.ContentLength64);
else
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY,
"BODY !UL/!@SQ bytes",
rqptr->rqBody.DataCount, &rqptr->rqBody.ContentCount64);
WatchDataDump (rqptr->rqBody.DataPtr, rqptr->rqBody.DataCount);
}
if (rqptr->rqBody.ProcessFunction)
(*rqptr->rqBody.ProcessFunction)(rqptr);
else
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
}
/*****************************************************************************/
/*
Processes an RFC2068 (HTTP/1.1) chunked body.
*/
void BodyTransferChunked (REQUEST_STRUCT *rqptr)
{
int cnt, tbcnt, status,
ChunkCount,
ChunkSize,
ChunkState;
char *bptr, *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyTransferChunked() !&B !UL !&X !UL !&S !UL !UL",
rqptr->rqBody.UnEncodeStream,
rqptr->rqBody.ChunkState, rqptr->rqBody.DataPtr,
rqptr->NetIoPtr->ReadCount, rqptr->NetIoPtr->ReadStatus,
rqptr->rqBody.ChunkCount, rqptr->rqBody.ChunkSize);
if (rqptr->rqBody.ChunkState == CHUNK_STATE_BEGIN)
{
/**************/
/* initialize */
/**************/
/* initialize the chunk specific storage */
rqptr->rqBody.ChunkCount = rqptr->rqBody.ChunkSize = 0;
rqptr->rqBody.ChunkSizeString[0] = '\0';
rqptr->rqBody.ChunkState = CHUNK_STATE_SIZE;
}
/****************/
/* process data */
/****************/
bptr = cptr = rqptr->rqBody.DataPtr;
cnt = rqptr->NetIoPtr->ReadCount;
ChunkCount = rqptr->rqBody.ChunkCount;
ChunkSize = rqptr->rqBody.ChunkSize;
ChunkState = rqptr->rqBody.ChunkState;
while (ChunkState != CHUNK_STATE_END && cnt)
{
if (ChunkState == CHUNK_STATE_SIZE && cnt)
{
/**********************/
/* getting chunk size */
/**********************/
zptr = rqptr->rqBody.ChunkSizeString +
sizeof(rqptr->rqBody.ChunkSizeString)-1;
/* step to the start of any partly read hex number */
for (sptr = rqptr->rqBody.ChunkSizeString; *sptr; sptr++);
if (!rqptr->rqBody.ChunkSizeString[0] && !isxdigit(*cptr))
{
BodyTransferChunkedError (rqptr, FI_LI);
return;
}
while (cnt && isxdigit(*cptr) && sptr < zptr)
{
/* getting hex number string */
*sptr++ = *cptr++;
cnt--;
}
*sptr = '\0';
if (cnt)
{
/* some constraints on the potential hex size string */
if ((*cptr != ';' && !ISLWS(*cptr) && NOTEOL(*cptr)))
{
BodyTransferChunkedError (rqptr, FI_LI);
return;
}
if (!rqptr->rqBody.ChunkSizeString[0])
{
BodyTransferChunkedError (rqptr, FI_LI);
return;
}
if (strlen(rqptr->rqBody.ChunkSizeString) > 8)
{
BodyTransferChunkedError (rqptr, FI_LI);
return;
}
/* line format looks acceptable */
ChunkSize = strtol (rqptr->rqBody.ChunkSizeString, NULL, 16);
ChunkState = CHUNK_STATE_EOL;
rqptr->rqBody.ContentCount64 += ChunkSize;
if (WATCHING (rqptr, WATCH_REQUEST_BODY))
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY,
"CHUNK (0x!AZ) !UL bytes",
rqptr->rqBody.ChunkSizeString, ChunkSize);
}
}
if (ChunkState == CHUNK_STATE_EOL && cnt)
{
/***********************/
/* finding end-of-line */
/***********************/
while (cnt && !ISEOL(*cptr))
{
cptr++;
cnt--;
}
if (cnt && ISEOL(*cptr))
{
/* reached end-of-line, step to the beginning of the data */
if (*cptr == '\r') { cptr++; cnt--; }
if (cnt && *cptr == '\n')
{
cptr++;
cnt--;
ChunkState = CHUNK_STATE_DATA;
}
else
{
BodyTransferChunkedError (rqptr, FI_LI);
return;
}
}
if (!ChunkSize)
{
/*****************/
/* end of chunks */
/*****************/
ChunkState = CHUNK_STATE_TRAILER;
if (cnt && ISEOL(*cptr))
{
/* trailing terminating empty line follows immediately */
if (*cptr == '\r') { cptr++; cnt--; }
if (cnt && *cptr == '\n') { cptr++; cnt--; }
ChunkState = CHUNK_STATE_END;
if (WATCHING (rqptr, WATCH_REQUEST_BODY))
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY,
"CHUNK trailer 0 bytes");
break;
}
}
}
if (ChunkState == CHUNK_STATE_DATA && cnt)
{
/*******************/
/* un-encode chunk */
/*******************/
if (bptr == cptr)
{
/* start of buffer, no need to move contents */
if (cnt <= ChunkSize - ChunkCount)
{
/* full buffer if less or equal to that outstanding */
cptr += cnt;
bptr += cnt;
ChunkCount += cnt;
cnt = 0;
}
else
{
/* less than full buffer will complete that outstanding */
cptr += ChunkSize - ChunkCount;
bptr += ChunkSize - ChunkCount;
cnt -= ChunkSize - ChunkCount;
ChunkCount = ChunkSize;
}
}
else
{
/* move the chunk data forward in the buffer */
while (cnt && ChunkCount < ChunkSize)
{
*bptr++ = *cptr++;
ChunkCount++;
cnt--;
}
}
if (WATCHING (rqptr, WATCH_REQUEST_BODY))
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY,
"CHUNK !UL/!UL bytes", ChunkCount, ChunkSize);
if (ChunkCount >= ChunkSize)
{
/* copied all of this chunk */
ChunkCount = ChunkSize = 0;
rqptr->rqBody.ChunkSizeString[0] = '\0';
ChunkState = CHUNK_STATE_EOD;
}
}
if (ChunkState == CHUNK_STATE_EOD && cnt)
{
/***********************/
/* finding end-of-data */
/***********************/
/* basically just the trailing <CR><LF> */
if (*cptr == '\r') { cptr++; cnt--; }
if (cnt && *cptr == '\n')
{
cptr++;
cnt--;
ChunkState = CHUNK_STATE_SIZE;
}
else
{
BodyTransferChunkedError (rqptr, FI_LI);
return;
}
}
if (ChunkState == CHUNK_STATE_TRAILER && cnt)
{
/********************/
/* trailing trailer */
/********************/
ChunkState = BodyTransferChunkedTrailer (rqptr, cptr, cnt);
if (!ChunkState)
{
rqptr->NetIoPtr->ReadStatus = SS$_ENDOFFILE;
rqptr->NetIoPtr->ReadCount = 0;
return;
}
}
/* adjust to account for any encoding overhead from the buffer */
rqptr->NetIoPtr->ReadCount = bptr - rqptr->rqBody.DataPtr;
}
rqptr->rqBody.ChunkCount = ChunkCount;
rqptr->rqBody.ChunkSize = ChunkSize;
rqptr->rqBody.ChunkState = ChunkState;
rqptr->NetIoPtr->ReadStatus = SS$_NORMAL;
}
/*****************************************************************************/
/*
Processes an RFC2068 (HTTP/1.1) chunked body trailer.
Returns the chunk processing state or zero to indicate a fatal error.
*/
int BodyTransferChunkedTrailer
(
REQUEST_STRUCT *rqptr,
char *DataPtr,
int DataCount
)
{
int cnt, retval, tbcnt,
ChunkState;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
{
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyTransferChunkedTrailer() !UL !UL",
rqptr->rqBody.ChunkedTrailerBufferCount, DataCount);
WatchDataDump (DataPtr, DataCount);
}
if (!rqptr->rqBody.ChunkedTrailerBufferPtr)
{
/* create the trailer buffer */
rqptr->rqBody.ChunkedTrailerBufferCount =
rqptr->rqBody.ChunkedTrailerNewLineCount = 0;
/* allow for a little 'elbow room' in the buffer */
rqptr->rqBody.ChunkedTrailerBufferSize = NetReadBufferSize - 4;
rqptr->rqBody.ChunkedTrailerBufferPtr =
VmGetHeap (rqptr, NetReadBufferSize);
}
cptr = DataPtr;
cnt = DataCount;
tbcnt = rqptr->rqBody.ChunkedTrailerBufferCount;
sptr = rqptr->rqBody.ChunkedTrailerBufferPtr;
zptr = sptr + rqptr->rqBody.ChunkedTrailerBufferSize;
sptr += tbcnt;
while (cnt && sptr < zptr)
{
if (*cptr == '\n')
rqptr->rqBody.ChunkedTrailerNewLineCount++;
else
if (*cptr != '\r')
rqptr->rqBody.ChunkedTrailerNewLineCount = 0;
*sptr++ = *cptr++;
tbcnt++;
cnt--;
if (rqptr->rqBody.ChunkedTrailerNewLineCount == 2)
break;
}
if (sptr >= zptr)
{
BodyTransferChunkedError (rqptr, FI_LI);
return (0);
}
*sptr = '\0';
rqptr->rqBody.ChunkedTrailerBufferCount = tbcnt;
if (rqptr->rqBody.ChunkedTrailerNewLineCount == 2)
ChunkState = CHUNK_STATE_END;
else
ChunkState = CHUNK_STATE_TRAILER;
if (ChunkState == CHUNK_STATE_END)
{
if (WATCHING (rqptr, WATCH_REQUEST_BODY))
{
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY, "CHUNK trailer !UL bytes",
rqptr->rqBody.ChunkedTrailerBufferCount);
WatchDataDump (rqptr->rqBody.ChunkedTrailerBufferPtr,
rqptr->rqBody.ChunkedTrailerBufferCount);
}
if (rqptr->rqBody.ChunkedTrailerBufferCount)
{
retval = RequestFields (rqptr, rqptr->rqBody.ChunkedTrailerBufferPtr,
rqptr->rqBody.ChunkedTrailerBufferCount);
if (retval < 0)
{
BodyTransferChunkedError (rqptr, FI_LI);
return (0);
}
}
}
return (ChunkState);
}
/*****************************************************************************/
/*
Generate an error and set the read status block to indicate.
*/
BodyTransferChunkedError
(
REQUEST_STRUCT *rqptr,
char *SourceModuleName,
int SourceLineNumber
)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "BodyTransferChunkedError()");
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_REQUEST_BODY_READ),
SourceModuleName, SourceLineNumber);
/* set the read status block to indicate an error */
rqptr->NetIoPtr->ReadStatus = SS$_ABORT;
rqptr->NetIoPtr->ReadCount = 0;
}
/*****************************************************************************/
/*
ZLIB inflate GZIP compressed data. Of course a single network read buffer full
can provide multiple data buffer fulls. This requires that this function be
called multiple times until the output buffer, sourced from the network read
buffer, is emptied. Essentially this is done by using the data specified by
the IO status block (NetIoPtr->ReadStatus and NetIoPtr->ReadCount) and what
is left in the ZLIB input buffer (gzptr->InflateAvailIn dereived from ZLIB's
avail_in).
*/
BodyContentGzip (REQUEST_STRUCT *rqptr)
{
int DataCount;
char *DataPtr;
GZIP_COMPRESS *gzptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "BodyContentGzip() !&X !UL",
rqptr->rqBody.DataPtr, rqptr->NetIoPtr->ReadCount);
DataPtr = rqptr->rqBody.DataPtr;
DataCount = rqptr->NetIoPtr->ReadCount;
gzptr = &rqptr->GzipCompress;
/* if the input stream is empty the read buffer will be fully consumed */
if (!gzptr->InflateAvailIn) rqptr->NetIoPtr->ReadCount = 0;
if (!gzptr->InflateStartStream)
{
/* initialization */
if (GzipInflateBegin (rqptr, gzptr, rqptr->rqNet.ReadBufferSize))
{
rqptr->rqBody.DataStatus = SS$_NORMAL;
if (!DataCount) return;
/* otherwise drop thru to begin processing the gzipped content */
}
else
{
rqptr->rqBody.DataStatus = SS$_ABORT;
rqptr->rqBody.DataCount = 0;
return;
}
}
if (GzipInflate (rqptr, gzptr, &DataPtr, &DataCount))
{
rqptr->rqBody.DataStatus = SS$_NORMAL;
rqptr->rqBody.DataCount = DataCount;
rqptr->rqBody.DataPtr = DataPtr;
}
else
{
rqptr->rqBody.DataStatus = SS$_ABORT;
rqptr->rqBody.DataCount = 0;
}
}
/*****************************************************************************/
/*
This is a special case. It reads the entire request body into a buffer.
Needless-to-say the body length must be less than the allocated buffer space.
It is intended only for the HTADMIN.C and UPD.C modules which like to get small
request query strings as POSTs. This approach is a bit of a kludge in some
ways but simplifies the parsing of these POSTed query strings significantly.
*/
void BodyProcessReadAll (REQUEST_STRUCT *rqptr)
{
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyProcessReadAll() !&F !&X !UL !&S",
&BodyProcessReadAll,
rqptr->rqBody.DataPtr, rqptr->rqBody.DataCount,
rqptr->rqBody.DataStatus);
if (!(prptr = rqptr->rqBody.ProcessPtr))
{
/**************/
/* initialize */
/**************/
prptr = rqptr->rqBody.ProcessPtr =
VmGetHeap (rqptr, sizeof(BODY_PROCESS));
rqptr->rqBody.ProcessedAs = BODY_PROCESSED_AS_OTHER;
/* just body buffer size */
prptr->BlockBufferSize = rqptr->rqBody.ContentLength64;
prptr->BlockBufferPtr = VmGetHeap (rqptr, prptr->BlockBufferSize);
prptr->BlockBufferCount = 0;
}
if (VMSnok (rqptr->rqBody.DataStatus))
{
/*****************************/
/* network error/end-of-file */
/*****************************/
if (rqptr->rqBody.DataStatus == SS$_ENDOFFILE)
{
rqptr->rqBody.DataPtr = prptr->BlockBufferPtr;
rqptr->rqBody.DataCount = prptr->BlockBufferCount;
/* as this will be considered null-terminated we'd better */
rqptr->rqBody.DataPtr[rqptr->rqBody.DataCount] = '\0';
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_REQUEST_BODY_READ);
ErrorVmsStatus (rqptr, rqptr->rqBody.DataStatus, FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (prptr->BlockBufferCount + rqptr->rqBody.DataCount >
prptr->BlockBufferSize)
{
/* woops, not big enough! */
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_REQUEST_BODY_READ);
ErrorVmsStatus (rqptr, SS$_BUFFEROVF, FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
/* add what has just been received */
memcpy (prptr->BlockBufferPtr + prptr->BlockBufferCount,
rqptr->rqBody.DataPtr,
rqptr->rqBody.DataCount);
prptr->BlockBufferCount += rqptr->rqBody.DataCount;
BodyRead (rqptr);
}
/*****************************************************************************/
/*
Supply the body data in whole 512 byte virtual blocks so it can be written to
disk using block I/O (used by PUT.C module).
*/
void BodyProcessByVirtualBlock (REQUEST_STRUCT *rqptr)
{
int cnt, status;
char *bptr;
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyProcessByVirtualBlock() !&F !&X !UL !&S",
&BodyProcessByVirtualBlock,
rqptr->rqBody.DataPtr, rqptr->rqBody.DataCount,
rqptr->rqBody.DataStatus);
if (!(prptr = rqptr->rqBody.ProcessPtr))
{
/**************/
/* initialize */
/**************/
prptr = rqptr->rqBody.ProcessPtr =
VmGetHeap (rqptr, sizeof(BODY_PROCESS));
rqptr->rqBody.ProcessedAs = BODY_PROCESSED_AS_VIRTUALBLOCK;
BodyBufferAllocate (rqptr);
}
bptr = prptr->BlockBufferPtr + prptr->BlockBufferCount;
if (prptr->BlockLeftOverCount)
{
/**********************************/
/* remains of previous processing */
/**********************************/
memcpy (bptr, prptr->BlockLeftOverPtr, prptr->BlockLeftOverCount);
bptr += prptr->BlockLeftOverCount;
prptr->BlockLeftOverCount = 0;
prptr->BlockBufferCount = bptr - prptr->BlockBufferPtr;
}
if (VMSnok (rqptr->rqBody.DataStatus))
{
/*****************************/
/* network error/end-of-file */
/*****************************/
if (rqptr->rqBody.DataStatus == SS$_ENDOFFILE)
{
BodyBufferEndOfFile (rqptr);
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_REQUEST_BODY_READ);
ErrorVmsStatus (rqptr, rqptr->rqBody.DataStatus, FI_LI);
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
/*********************************/
/* populate virtual block buffer */
/*********************************/
/* add what has just been received */
memcpy (bptr, rqptr->rqBody.DataPtr, rqptr->rqBody.DataCount);
prptr->BlockBufferCount += rqptr->rqBody.DataCount;
BodyBufferWrite (rqptr);
}
/*****************************************************************************/
/*
Decode URL-encoded byte stream. Eliminates form field names, field equal
symbols and field-separating ampersands. Converts '+' characters in field
content into spaces and hexadecimal, URL-encoded characters into the respective
character.
A field named "hexencoded" is expected to contain hexadecimal-encoded bytes,
and has these two-digit numbers converted back into bytes before inclusion in
the file.
The presence of a non-null field named "previewonly" causes a temporary,
delete-on-close file name to be generated (for previewing the POSTed file :^).
A field "previewnote" contains text placed at the very beginning of a previewed
file. This can either be left in place or eliminated by pointer manipulation
depending on the value of "previewonly". Also see UPD.C module.
Calls 'rqptr->rqBody.AstFunction' with storage set as described above in the
prologue to this module. When all data has been processed and passed on it
returns SS$_ENDOFFILE. Provides data in 512 byte virtual blocks as described
in the prologue.
*/
void BodyProcessUrlEncoded (REQUEST_STRUCT *rqptr)
{
int cnt, status;
unsigned char ch;
char *bptr, *cptr, *sptr, *zptr;
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyProcessUrlEncoded() !&F !&X !UL !&S",
&BodyProcessUrlEncoded,
rqptr->rqBody.DataPtr, rqptr->rqBody.DataCount,
rqptr->rqBody.DataStatus);
if (!(prptr = rqptr->rqBody.ProcessPtr))
{
/**************/
/* initialize */
/**************/
prptr = rqptr->rqBody.ProcessPtr =
VmGetHeap (rqptr, sizeof(BODY_PROCESS));
rqptr->rqBody.ProcessedAs = BODY_PROCESSED_AS_URLENCODED;
prptr->UrlEncodedFieldNameSize = sizeof(prptr->UrlEncodedFieldName);
prptr->UrlEncodedFieldValueSize = sizeof(prptr->UrlEncodedFieldValue);
prptr->UrlEncodedFieldNameCount = prptr->UrlEncodedFieldValueCount = 0;
prptr->UrlEncodedFieldName[0] = prptr->UrlEncodedFieldValue[0] = '\0';
/* this is to kick off the field name processing, it's ignored */
prptr->UrlEncodedFieldName[prptr->UrlEncodedFieldNameCount++] = '!';
BodyBufferAllocate (rqptr);
}
bptr = prptr->BlockBufferPtr + prptr->BlockBufferCount;
if (prptr->BlockLeftOverCount)
{
/**********************************/
/* remains of previous processing */
/**********************************/
memcpy (bptr, prptr->BlockLeftOverPtr, prptr->BlockLeftOverCount);
bptr += prptr->BlockLeftOverCount;
prptr->BlockLeftOverCount = 0;
prptr->BlockBufferCount = bptr - prptr->BlockBufferPtr;
}
if (VMSnok (rqptr->rqBody.DataStatus))
{
/*****************************/
/* network error/end-of-file */
/*****************************/
if (rqptr->rqBody.DataStatus == SS$_ENDOFFILE)
{
BodyBufferEndOfFile (rqptr);
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_REQUEST_BODY_READ);
ErrorVmsStatus (rqptr, rqptr->rqBody.DataStatus, FI_LI);
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
/******************/
/* decode content */
/******************/
cptr = rqptr->rqBody.DataPtr;
cnt = rqptr->rqBody.DataCount;
while (cnt)
{
if (prptr->UrlDecodeIdx &&
prptr->UrlDecodeIdx < 3)
{
prptr->UrlDecode[prptr->UrlDecodeIdx++] = *cptr++;
cnt--;
if (prptr->UrlDecodeIdx < 3) continue;
}
else
if (*cptr == '%')
{
prptr->UrlDecode[prptr->UrlDecodeIdx++] = *cptr++;
cnt--;
continue;
}
else
if (*cptr == '=')
{
prptr->UrlEncodedFieldNameCount = 0;
/* this is to kick off the field value processing, it's ignored */
prptr->UrlEncodedFieldValue[prptr->UrlEncodedFieldValueCount++] = '!';
cnt--;
cptr++;
continue;
}
else
if (*cptr == '&')
{
prptr->UrlEncodedFieldValueCount = 0;
prptr->UrlEncodedFieldHexEncoded = prptr->UrlEncodedHiddenLF = false;
/* this is to kick off the field name processing, it's ignored */
prptr->UrlEncodedFieldName[prptr->UrlEncodedFieldNameCount++] = '!';
cnt--;
cptr++;
continue;
}
else
{
cnt--;
ch = *cptr++;
}
if (prptr->UrlDecodeIdx)
{
ch = 0;
if (prptr->UrlDecode[1] >= '0' &&
prptr->UrlDecode[1] <= '9')
ch = (prptr->UrlDecode[1] - (int)'0') << 4;
else
if (TOUP(prptr->UrlDecode[1]) >= 'A' &&
TOUP(prptr->UrlDecode[1]) <= 'F')
ch = (TOUP(prptr->UrlDecode[1]) - (int)'A' + 10) << 4;
else
{
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_REQUEST_URL_ENC), FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (prptr->UrlDecode[2] >= '0' &&
prptr->UrlDecode[2] <= '9')
ch += (prptr->UrlDecode[2] - (int)'0');
else
if (TOUP(prptr->UrlDecode[2]) >= 'A' &&
TOUP(prptr->UrlDecode[2]) <= 'F')
ch += (TOUP(prptr->UrlDecode[2]) - (int)'A' + 10);
else
{
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"URL-ENC-ERROR: !3AZ !&Z", prptr->UrlDecode, cptr);
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_REQUEST_URL_ENC), FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
prptr->UrlDecode[prptr->UrlDecodeIdx=0] = '\0';
}
else
if (ch == '+')
ch = ' ';
/* absorb carriage returns for a stream-LF file */
if (ch == '\r') continue;
/*******************/
/* process content */
/*******************/
if (prptr->UrlEncodedFieldNameReserved &&
prptr->UrlEncodedFieldNameCount)
{
/* starting a new field name after processing a reserved name/value */
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "!&Z !&Z",
prptr->UrlEncodedFieldName,
prptr->UrlEncodedFieldValue);
if (strsame (prptr->UrlEncodedFieldName+1, "success", -1))
ResponseLocation (rqptr, prptr->UrlEncodedFieldValue+1,
prptr->UrlEncodedFieldValueCount);
else
if (strsame (prptr->UrlEncodedFieldName+1, "protection", -1))
{
/* file protection */
strzcpy (prptr->ProtectionHexString,
prptr->UrlEncodedFieldValue+1,
sizeof(prptr->ProtectionHexString));
}
else
if (strsame (prptr->UrlEncodedFieldName+1, "previewonly", -1))
{
/* if value is non-empty then preview, otherwise ignore */
if (prptr->UrlEncodedFieldValue[1]) prptr->PreviewOnly = true;
}
else
if (strsame (prptr->UrlEncodedFieldName+1, "previewnote", -1))
{
/* preview note (can be a maximum of 254 bytes) */
if (prptr->PreviewOnly)
{
for (sptr = prptr->UrlEncodedFieldValue+1; *sptr; *sptr++)
if (*sptr == '^') /* ^ */
*bptr++ = '\n';
else
*bptr++ = *sptr;
}
}
else
if (strsame (prptr->UrlEncodedFieldName+1, "fab$b_rat", -1))
{
prptr->UrlEncodedFabRat = atoi(prptr->UrlEncodedFieldValue+1);
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "FAB$B_RAT 0x!2XL",
prptr->UrlEncodedFabRat);
}
else
if (strsame (prptr->UrlEncodedFieldName+1, "fab$b_rfm", -1))
{
prptr->UrlEncodedFabRfm = atoi(prptr->UrlEncodedFieldValue+1);
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "FAB$B_RFM 0x!2XL",
prptr->UrlEncodedFabRfm);
}
/* no longer processing the reserved name/value */
prptr->UrlEncodedFieldNameReserved = false;
}
if (prptr->UrlEncodedFieldNameCount)
{
/* currently buffering a field name */
zptr = prptr->UrlEncodedFieldName + prptr->UrlEncodedFieldNameSize;
sptr = prptr->UrlEncodedFieldName + prptr->UrlEncodedFieldNameCount;
if (sptr < zptr) *sptr++ = ch;
if (sptr >= zptr)
{
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneralOverflow (rqptr, FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
*sptr = '\0';
prptr->UrlEncodedFieldNameCount = sptr - prptr->UrlEncodedFieldName;
continue;
}
if (prptr->UrlEncodedFieldValueCount == 1)
{
/* just finished buffering a field name, starting on a value */
prptr->UrlEncodedFieldHexEncoded = false;
if (strsame (prptr->UrlEncodedFieldName+1, "success", -1))
prptr->UrlEncodedFieldNameReserved = true;
else
if (strsame (prptr->UrlEncodedFieldName+1, "protection", -1))
prptr->UrlEncodedFieldNameReserved = true;
else
if (strsame (prptr->UrlEncodedFieldName+1, "previewonly", -1))
prptr->UrlEncodedFieldNameReserved = true;
else
if (strsame (prptr->UrlEncodedFieldName+1, "previewnote", -1))
prptr->UrlEncodedFieldNameReserved = true;
else
if (strsame (prptr->UrlEncodedFieldName+1, "hexencoded", 10))
prptr->UrlEncodedFieldHexEncoded = true;
else
if (strsame (prptr->UrlEncodedFieldName+1, "fab$b_rat", -1))
prptr->UrlEncodedFieldNameReserved = true;
else
if (strsame (prptr->UrlEncodedFieldName+1, "fab$b_rfm", -1))
prptr->UrlEncodedFieldNameReserved = true;
else
prptr->UrlEncodedFieldNameReserved = false;
/*
With constraints on CDATA entities for field values this
contains a '^' (^) substituted for any required line-feed.
*/
if (strsame (prptr->UrlEncodedFieldName+1, "hidden$lf", -1))
prptr->UrlEncodedHiddenLF = true;
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "!&Z !&B",
prptr->UrlEncodedFieldName,
prptr->UrlEncodedFieldNameReserved);
if (!prptr->UrlEncodedFieldNameReserved)
prptr->UrlEncodedFieldNameCount =
prptr->UrlEncodedFieldValueCount = 0;
}
if (prptr->UrlEncodedFieldNameReserved)
{
/* currently buffering a reserved field value */
zptr = prptr->UrlEncodedFieldValue + prptr->UrlEncodedFieldValueSize;
sptr = prptr->UrlEncodedFieldValue + prptr->UrlEncodedFieldValueCount;
if (sptr < zptr) *sptr++ = ch;
if (sptr >= zptr)
{
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneralOverflow (rqptr, FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
*sptr = '\0';
prptr->UrlEncodedFieldValueCount = sptr - prptr->UrlEncodedFieldValue;
continue;
}
if (prptr->UrlEncodedHiddenLF && ch == '^') /* ^ */
ch = '\n';
else
if (prptr->UrlEncodedFieldHexEncoded)
{
prptr->HexDecode[prptr->HexDecodeIdx++] = ch;
if (prptr->HexDecodeIdx == 1) continue;
prptr->HexDecodeIdx = 0;
ch = 0;
if (prptr->HexDecode[0] >= '0' &&
prptr->HexDecode[0] <= '9')
ch = (prptr->HexDecode[0] - (int)'0') << 4;
else
if (TOUP(prptr->HexDecode[0]) >= 'A' &&
TOUP(prptr->HexDecode[0]) <= 'F')
ch = (TOUP(prptr->HexDecode[0]) - (int)'A' + 10) << 4;
else
{
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_REQUEST_URL_ENC), FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (prptr->HexDecode[1] >= '0' &&
prptr->HexDecode[1] <= '9')
ch += (prptr->HexDecode[1] - (int)'0');
else
if (TOUP(prptr->HexDecode[1]) >= 'A' &&
TOUP(prptr->HexDecode[1]) <= 'F')
ch += (TOUP(prptr->HexDecode[1]) - (int)'A' + 10);
else
{
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_REQUEST_URL_ENC), FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
}
/* write the character into the virtual block buffer */
*bptr++ = ch;
}
/****************/
/* post process */
/****************/
/* save the current buffer count */
prptr->BlockBufferCount = bptr - prptr->BlockBufferPtr;
BodyBufferWrite (rqptr);
}
/*****************************************************************************/
/*
Decode a "multipart/form-data" content-type request body. This will (or at
least should) comprise one of more MIME parts with data of various types.
Returns SS$_BADPARAM if it can't understand the stream format, SS$_RESULTOVF if
buffer space is exhausted at any time. Otherwise a normal status.
Calls 'rqptr->rqBody.AstFunction' with storage set as described above in the
prologue to this module. When all data has been processed and passed on it
returns SS$_ENDOFFILE. Provides data in 512 byte virtual blocks as described
in the prologue.
*/
void BodyProcessMultipartFormData (REQUEST_STRUCT *rqptr)
{
int cnt, idx, status;
char *bptr, *cptr, *sptr, *zptr;
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyProcessMultipartFormData() !&F !&X !UL !&S",
&BodyProcessMultipartFormData,
rqptr->rqBody.DataPtr, rqptr->rqBody.DataCount,
rqptr->rqBody.DataStatus);
if (!(prptr = rqptr->rqBody.ProcessPtr))
{
/**************/
/* initialize */
/**************/
if (!ConfigSameContentType (rqptr->rqHeader.ContentTypePtr,
"multipart/form-data", -1))
{
rqptr->rqResponse.HttpStatus = 400;
ErrorGeneral (rqptr, MsgFor(rqptr,MSG_PUT_MULTIPART_FORMDATA), FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
prptr = rqptr->rqBody.ProcessPtr =
VmGetHeap (rqptr, sizeof(BODY_PROCESS));
rqptr->rqBody.ProcessedAs = BODY_PROCESSED_AS_MULTIPART_FORMDATA;
BodyBufferAllocate (rqptr);
if (!BodyGetMimeBoundary (rqptr))
{
/* error message generated by the above function */
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
/* prepend these for boundary matching convenience only */
prptr->BoundaryBuffer[prptr->BoundaryIdx++] = '\r';
prptr->BoundaryBuffer[prptr->BoundaryIdx++] = '\n';
}
bptr = prptr->BlockBufferPtr + prptr->BlockBufferCount;
if (prptr->BlockLeftOverCount)
{
/**********************************/
/* remains of previous processing */
/**********************************/
memcpy (bptr, prptr->BlockLeftOverPtr, prptr->BlockLeftOverCount);
bptr += prptr->BlockLeftOverCount;
prptr->BlockLeftOverCount = 0;
prptr->BlockBufferCount = bptr - prptr->BlockBufferPtr;
}
if (VMSnok (rqptr->rqBody.DataStatus))
{
/*****************************/
/* network error/end-of-file */
/*****************************/
if (rqptr->rqBody.DataStatus == SS$_ENDOFFILE)
{
BodyBufferEndOfFile (rqptr);
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_REQUEST_BODY_READ);
ErrorVmsStatus (rqptr, rqptr->rqBody.DataStatus, FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
/******************/
/* decode content */
/******************/
cptr = rqptr->rqBody.DataPtr;
cnt = rqptr->rqBody.DataCount;
while (cnt)
{
if (prptr->MimeHeaderIdx)
{
/***************************/
/* buffering a MIME header */
/***************************/
if (prptr->MimeHeaderIdx >= sizeof(prptr->MimeHeaderBuffer))
{
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_PUT_MULTIPART);
ErrorVmsStatus (rqptr, SS$_BUFFEROVF, FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (*cptr == '\n')
{
/* check for the blank line terminating the MIME header */
if (prptr->MimeHeaderIdx >= 1 &&
prptr->MimeHeaderBuffer[prptr->MimeHeaderIdx-1] == '\n')
{
/* end of MIME header */
cptr++;
cnt--;
prptr->MimeHeaderIdx--;
prptr->MimeHeaderBuffer[prptr->MimeHeaderIdx] = '\0';
prptr->MimeHeaderCount = prptr->MimeHeaderIdx;
prptr->MimeHeaderIdx = 0;
continue;
}
if (prptr->MimeHeaderIdx >= 3 &&
prptr->MimeHeaderBuffer[prptr->MimeHeaderIdx-1] == '\r' &&
prptr->MimeHeaderBuffer[prptr->MimeHeaderIdx-2] == '\n' &&
prptr->MimeHeaderBuffer[prptr->MimeHeaderIdx-3] == '\r')
{
/* end of MIME header */
cptr++;
cnt--;
prptr->MimeHeaderIdx -= 3;
prptr->MimeHeaderBuffer[prptr->MimeHeaderIdx] = '\0';
prptr->MimeHeaderCount = prptr->MimeHeaderIdx;
prptr->MimeHeaderIdx = 0;
continue;
}
}
prptr->MimeHeaderBuffer[prptr->MimeHeaderIdx++] = *cptr++;
cnt--;
continue;
}
if (prptr->MimeHeaderBuffer[0])
{
/****************************/
/* process MIME part header */
/****************************/
if (WATCHING (rqptr, WATCH_REQUEST_BODY))
{
int Length;
sptr = prptr->MimeHeaderBuffer;
Length = prptr->MimeHeaderCount;
if (SAME2(sptr,'\r\n'))
{
sptr += 2;
Length -= 2;
}
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_BODY, "MULTIPART");
WatchData (sptr, Length);
}
status = BodyProcessMultipartMimeHeader (rqptr);
if (VMSnok (status))
{
/* error message generated by the above function */
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
/* finished with this part header */
prptr->MimeHeaderCount = 0;
prptr->MimeHeaderBuffer[0] = '\0';
/* continue on to buffer the data */
}
if (!prptr->BoundaryIdx)
{
/*********************************/
/* looking for start of boundary */
/*********************************/
if (*cptr == '\r')
{
prptr->BoundaryBuffer[prptr->BoundaryIdx++] = *cptr++;
cnt--;
continue;
}
/* just drop out the bottom as another octet */
}
else
{
/*******************************/
/* still matching for boundary */
/*******************************/
if (!prptr->MultipartBoundary[prptr->BoundaryIdx])
{
/*******************/
/* boundary match! */
/*******************/
/* reached end of the content-type boundary */
prptr->BoundaryIdx = 0;
prptr->MimeHeaderBuffer[prptr->MimeHeaderIdx++] = *cptr++;
cnt--;
/* new boundary, post-process any required form data field */
if (prptr->MultipartFormDataPtr)
{
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
{
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "FORM-DATA");
WatchDataFormatted ("!&Z\n", prptr->MultipartFormDataPtr);
}
if (prptr->MultipartFormDataPtr == prptr->MultipartSuccessUrl)
ResponseLocation (rqptr, prptr->MultipartFormDataPtr,
prptr->MultipartFormDataCount);
}
/* set these to NULL and empty to stop data copying */
prptr->MultipartContentTypePtr =
prptr->MultipartFormDataPtr =
prptr->MultipartFormDataCurrentPtr = NULL;
continue;
}
if (*cptr == prptr->MultipartBoundary[prptr->BoundaryIdx])
{
/* still matching */
prptr->BoundaryBuffer[prptr->BoundaryIdx++] = *cptr++;
prptr->BoundaryBuffer[prptr->BoundaryIdx] = '\0';
cnt--;
continue;
}
/********************/
/* match has failed */
/********************/
if (prptr->MultipartFormDataCurrentPtr)
{
/* restore match buffer to form data buffer */
for (idx = 0; idx < prptr->BoundaryIdx; idx++)
{
if (prptr->MultipartFormDataCount >
prptr->MultipartFormDataSize)
{
rqptr->rqResponse.ErrorTextPtr =
MsgFor(rqptr,MSG_PUT_MULTIPART);
ErrorVmsStatus (rqptr, SS$_BUFFEROVF, FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (isprint(prptr->BoundaryBuffer[idx]) &&
NOTEOL(prptr->BoundaryBuffer[idx]))
*prptr->MultipartFormDataCurrentPtr++ =
prptr->BoundaryBuffer[idx];
prptr->MultipartFormDataCount++;
}
*prptr->MultipartFormDataCurrentPtr = '\0';
}
else
{
/* restore match buffer to content buffer */
if (prptr->MultipartContentTypePtr)
for (idx = 0; idx < prptr->BoundaryIdx; idx++)
*bptr++ = prptr->BoundaryBuffer[idx];
}
prptr->BoundaryIdx = 0;
prptr->BoundaryBuffer[0] = '\0';
/*
If a <CR> then restart the matching algorithm using the current
character. This will allow for correct behaviour with the likes
of <CR><LF><CR><LF>---..boundary sequences (yup, got caught!)
If not a <CR> then drop through to treat as just another octet.
*/
if (*cptr == '\r') continue;
}
/**********************/
/* just another octet */
/**********************/
if (prptr->MultipartFormDataCurrentPtr)
{
if (prptr->MultipartFormDataCount > prptr->MultipartFormDataSize)
{
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_PUT_MULTIPART);
ErrorVmsStatus (rqptr, SS$_BUFFEROVF, FI_LI);
rqptr->rqBody.DataStatus = SS$_ABORT;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
return;
}
if (isprint(*cptr) && NOTEOL(*cptr))
*prptr->MultipartFormDataCurrentPtr++ = *cptr;
}
else
/* if a content-type has been resolved then we're buffering data */
if (prptr->MultipartContentTypePtr)
*bptr++ = *cptr;
cptr++;
cnt--;
}
/****************/
/* post process */
/****************/
/* save the current buffer count */
prptr->BlockBufferCount = bptr - prptr->BlockBufferPtr;
BodyBufferWrite (rqptr);
}
/*****************************************************************************/
/*
A "multipart/form-data" MIME part header has been read into a buffer. This can
comprose serveral lines of header-type information termiated by a NUL
character. Scan through this text isolating field of interest. In particular
'uploadfilename', 'protection' and 'name'. These are used by the PUT.C and
PROXYFTP.C modules.
*/
int BodyProcessMultipartMimeHeader (REQUEST_STRUCT *rqptr)
{
char *cptr, *sptr, *zptr,
*NamePtr;
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyProcessMultipartMimeHeader()");
prptr = rqptr->rqBody.ProcessPtr;
cptr = prptr->MimeHeaderBuffer;
if (!SAME2(cptr,'\r\n'))
{
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_PUT_MULTIPART);
ErrorVmsStatus (rqptr, SS$_BUGCHECK, FI_LI);
return (SS$_BUGCHECK);
}
cptr += 2;
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchDataFormatted ("!&Z\n", cptr);
while (*cptr)
{
while (*cptr && ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
if (strsame (cptr, "Content-Disposition:", 20))
{
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "Content-Disposition:");
/* set these to NULL and empty to stop data copying */
prptr->MultipartContentTypePtr =
prptr->MultipartFormDataPtr =
prptr->MultipartFormDataCurrentPtr = NULL;
prptr->MultipartFormDataSize = prptr->MultipartFormDataCount = 0;
cptr += 20;
while (*cptr && NOTEOL(*cptr))
{
if (strsame (cptr, "name=", 5))
{
cptr += 5;
if (*cptr == '\"')
{
cptr++;
NamePtr = cptr;
while (*cptr && *cptr != '\"' && NOTEOL(*cptr)) cptr++;
if (*cptr != '\"')
{
rqptr->rqResponse.ErrorTextPtr =
MsgFor(rqptr,MSG_PUT_MULTIPART);
ErrorVmsStatus (rqptr, SS$_BUGCHECK, FI_LI);
return (SS$_BUGCHECK);
}
}
else
{
NamePtr = cptr;
while (*cptr && !ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
if (!ISLWS(*cptr))
{
rqptr->rqResponse.ErrorTextPtr =
MsgFor(rqptr,MSG_PUT_MULTIPART);
ErrorVmsStatus (rqptr, SS$_BUGCHECK, FI_LI);
return (SS$_BUGCHECK);
}
}
*cptr++ = '\0';
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "!&Z", NamePtr);
if (strsame (NamePtr, "name", -1))
{
/* handled by the storing the associated 'filename=".."' */
}
else
if (strsame (NamePtr, "protection", -1))
{
prptr->MultipartFormDataPtr = prptr->ProtectionHexString;
prptr->MultipartFormDataSize =
sizeof(prptr->ProtectionHexString);
}
else
if (strsame (NamePtr, "success", -1))
{
prptr->MultipartFormDataPtr = prptr->MultipartSuccessUrl;
prptr->MultipartFormDataSize =
sizeof(prptr->MultipartSuccessUrl);
}
else
if (strsame (NamePtr, "type", -1))
{
prptr->MultipartFormDataPtr = prptr->FtpFileType;
prptr->MultipartFormDataSize = sizeof(prptr->FtpFileType);
}
else
if (strsame (NamePtr, "uploadfilename", -1))
{
prptr->MultipartFormDataPtr = prptr->MultipartUploadFileName;
prptr->MultipartFormDataSize =
sizeof(prptr->MultipartUploadFileName);
}
/* anything else is just ignored */
prptr->MultipartFormDataCurrentPtr = prptr->MultipartFormDataPtr;
prptr->MultipartFormDataCount = 0;
}
else
if (strsame (cptr, "filename=", 9))
{
zptr = (sptr = prptr->MultipartFileName) +
sizeof(prptr->MultipartFileName);
cptr += 9;
if (*cptr == '\"')
{
cptr++;
while (*cptr && *cptr != '\"' && NOTEOL(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
if (*cptr != '\"')
{
rqptr->rqResponse.ErrorTextPtr =
MsgFor(rqptr,MSG_PUT_MULTIPART);
ErrorVmsStatus (rqptr, SS$_BUGCHECK, FI_LI);
return (SS$_BUGCHECK);
}
}
else
{
while (*cptr && !ISLWS(*cptr) && NOTEOL(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
if (!ISLWS(*cptr))
{
rqptr->rqResponse.ErrorTextPtr =
MsgFor(rqptr,MSG_PUT_MULTIPART);
ErrorVmsStatus (rqptr, SS$_BUGCHECK, FI_LI);
return (SS$_BUGCHECK);
}
}
*sptr = '\0';
prptr->MultipartFormDataFileNameCount++;
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "!&Z (!UL)",
prptr->MultipartFileName,
prptr->MultipartFormDataFileNameCount);
/* only one file per upload please! */
if (prptr->MultipartFormDataFileNameCount > 1)
{
rqptr->rqResponse.ErrorTextPtr =
MsgFor(rqptr,MSG_PUT_MULTIPART);
rqptr->rqResponse.ErrorOtherTextPtr =
"Only one file name per upload please!";
ErrorVmsStatus (rqptr, SS$_BADPARAM, FI_LI);
return (SS$_BADPARAM);
}
}
while (*cptr && !ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
while (*cptr && ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
}
}
else
if (strsame (cptr, "Content-Type:", 13))
{
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "Content-Type:");
cptr += 13;
while (*cptr && ISLWS(*cptr) && NOTEOL(*cptr)) cptr++;
/* find length of content-type */
for (sptr = cptr; *sptr && !ISLWS(*sptr) && NOTEOL(*sptr); sptr++);
prptr->MultipartContentTypePtr = sptr = VmGetHeap (rqptr, sptr-cptr+1);
while (*cptr && !ISLWS(*cptr) && NOTEOL(*cptr)) *sptr++ = *cptr++;
*sptr = '\0';
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"!&Z", prptr->MultipartContentTypePtr);
}
else
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
{
for (sptr = cptr; *sptr && NOTEOL(*sptr); sptr++);
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"{!UL}!-!#AZ", sptr-cptr, cptr);
}
/* scan to start of next "line" */
while (*cptr && NOTEOL(*cptr)) cptr++;
while (*cptr && ISEOL(*cptr)) cptr++;
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Scan through the request's "Content-Type:" header field looking for a MIME
"boundary=" string.
*/
int BodyGetMimeBoundary (REQUEST_STRUCT *rqptr)
{
char *cptr, *sptr, *zptr;
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyGetMimeBoundary() !&Z", rqptr->rqHeader.ContentTypePtr);
prptr = rqptr->rqBody.ProcessPtr;
prptr->MultipartBoundary[0] = '\0';
prptr->MultipartBoundaryLength = 0;
cptr = rqptr->rqHeader.ContentTypePtr;
while (*cptr)
{
while (*cptr && *cptr != ';') cptr++;
if (!*cptr) break;
cptr++;
while (*cptr && ISLWS(*cptr)) cptr++;
if (strsame (cptr, "boundary=", 9))
{
cptr += 9;
zptr = (sptr = prptr->MultipartBoundary) +
sizeof(prptr->MultipartBoundary);
/* prepend these only for matching convenience */
*sptr++ = '\r';
*sptr++ = '\n';
*sptr++ = '-';
*sptr++ = '-';
while (*cptr && *cptr != ';' && sptr < zptr) *sptr++ = *cptr++;
if (sptr >= zptr) sptr = prptr->MultipartBoundary;
*sptr = '\0';
prptr->MultipartBoundaryLength = sptr - prptr->MultipartBoundary;
}
}
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"!&Z", prptr->MultipartBoundary + 4);
if (!prptr->MultipartBoundaryLength)
{
rqptr->rqResponse.ErrorTextPtr = MsgFor(rqptr,MSG_PUT_MULTIPART);
rqptr->rqResponse.ErrorOtherTextPtr = "MIME boundary not found!";
ErrorVmsStatus (rqptr, SS$_BUGCHECK, FI_LI);
}
return (prptr->MultipartBoundaryLength);
}
/*****************************************************************************/
/*
Allocate a multi-block buffer.
*/
void BodyBufferAllocate (REQUEST_STRUCT *rqptr)
{
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "BodyBufferAllocate()");
prptr = rqptr->rqBody.ProcessPtr;
prptr->MultiBlockCount = BodyMultiBlockCount;
/* should never, ever happen but we need at least this much space */
if (prptr->MultiBlockCount * 512 < rqptr->rqBody.DataSize)
prptr->MultiBlockCount = (rqptr->rqBody.DataSize / 512) + 1;
/* allow sufficient extra buffer to a full network read */
prptr->BlockBufferSize = (prptr->MultiBlockCount * 512) +
rqptr->rqBody.DataSize;
prptr->BlockBufferPtr = VmGetHeap (rqptr, prptr->BlockBufferSize);
prptr->BlockBufferCount = prptr->BlockLeftOverCount = 0;
prptr->BlockBufferVBN = 1;
if (WATCHING (rqptr, WATCH_RESPONSE))
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE,
"MULTIBLOCK !UL", prptr->MultiBlockCount);
}
/*****************************************************************************/
/*
The file buffer is larger than the network data buffer and so with larger files
fills incrementally over multiple reads. Check if the file buffer is at
capacity by calculating the number of virtual blocks contained in it. If less
than the multiblock number read more. When enough virtual blocks have
accumulated for an efficient write, calculate what remains and note that.
Write the number of virtual blocks which then ASTs to read more. Each time the
read AST delivers that routine copies into the file buffer the data that
remained before copying the just-read data.
*/
void BodyBufferWrite (REQUEST_STRUCT *rqptr)
{
int BytesLeftOver,
VirtualBlocks;
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY,
"BodyBufferWrite() !UL !UL",
rqptr->rqBody.ProcessPtr->BlockBufferCount,
rqptr->rqBody.ProcessPtr->BlockBufferCount / 512);
prptr = rqptr->rqBody.ProcessPtr;
VirtualBlocks = prptr->BlockBufferCount / 512;
if (VirtualBlocks >= prptr->MultiBlockCount)
{
VirtualBlocks = prptr->MultiBlockCount;
BytesLeftOver = prptr->BlockBufferCount - VirtualBlocks * 512;
prptr->BlockBufferCount = VirtualBlocks * 512;
if (prptr->BlockLeftOverCount = BytesLeftOver)
prptr->BlockLeftOverPtr = prptr->BlockBufferPtr +
prptr->BlockBufferCount;
}
else
VirtualBlocks = 0;
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "!UL !UL !UL !UL",
prptr->BlockBufferCount, prptr->BlockBufferVBN,
VirtualBlocks, BytesLeftOver);
if (VirtualBlocks)
{
rqptr->rqBody.DataVBN = prptr->BlockBufferVBN;
rqptr->rqBody.DataPtr = prptr->BlockBufferPtr;
rqptr->rqBody.DataCount = prptr->BlockBufferCount;
rqptr->rqBody.DataStatus = SS$_NORMAL;
prptr->ProcessedByteCount += prptr->BlockBufferCount;
prptr->BlockBufferVBN += VirtualBlocks;
/* now the buffer count can be reset */
prptr->BlockBufferCount = 0;
SysDclAst (rqptr->rqBody.AstFunction, rqptr);
}
else
BodyRead (rqptr);
}
/*****************************************************************************/
/*
Handle still-buffered data when end-of-file is encountered.
*/
void BodyBufferEndOfFile (REQUEST_STRUCT *rqptr)
{
BODY_PROCESS *prptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_BODY))
WatchThis (WATCHITM(rqptr), WATCH_MOD_BODY, "BodyBufferEndOfFile()");
prptr = rqptr->rqBody.ProcessPtr;
if (prptr->BlockBufferCount)
{
rqptr->rqBody.DataVBN = prptr->BlockBufferVBN;
rqptr->rqBody.DataPtr = prptr->BlockBufferPtr;
rqptr->rqBody.DataCount = prptr->BlockBufferCount;
rqptr->rqBody.DataStatus = SS$_NORMAL;
prptr->ProcessedByteCount += prptr->BlockBufferCount;
prptr->BlockBufferCount = 0;
}
else
rqptr->rqBody.DataStatus = SS$_ENDOFFILE;
}
/*****************************************************************************/