[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]
/*****************************************************************************/
/*
proxyMUNGE.c
Munges (rewrites) URIs/URLs to provide an effective reverse-proxy, including:
o response header "Location:" field
o response header "Set-Cookie:" field path and domain components
o HTML document
* "href=" tag attributes
* "src=" tag attributes
* "background=" tag attributes
* "action=" (form) tag attributes
* "code=" (applet, object) tag attributes
* "codebase=" (applet, object) tag attributes
* "archive=" (object) tag attributes
* "data=" (object) tag attributes
* "usemap=" (object) tag attributes
o HTML tag attributes must be in the form
* attrib="data"
* attrib='data'
* attrib=data
o HTML "style=" attribute
* as per CSS document
o CSS document
* url("..") and url(..) property
Does not munge JavaScript.
Supports reverse-proxy to http:// and https:// (if built against SSL).
Operates as a CGIplus or standard CGI script.
CONFIGURATION
-------------
To avoid odd behaviours some care must be taken to include all the relevant
subtleties of this configuration (the '?', 'script=query-relaxed').
# HTTPD$MAP
[[the.reverse-proxy.service:port]]
redirect /whatever/* /proxymunge/http://the.internal.host/*?
set /proxymunge/http://the.internal.host/* script=params=\
(REVERSE="/whatever",HOST="another.internal.host=/another",\
DOMAIN="internal.host.name=external.host.name")
script+ /proxymunge/* /cgi-bin/proxymunge/* map=once script=query=relaxed
# HTTPD$AUTH
[opaque]
/proxymunge/* r+w
The REVERSE parameter in the configuration below is used to rewrite URLs/URIs
in HTML documents returned to the client so that they may be accessed via the
proxy script. A single REVERSE parameter must be supplied with each activation.
The HOST parameter is used to replace the host[:port] component of a URL
with the specified string (might be another reverse-proxy path). The HOST
parameter may contain multiple 'match=substitute' by comma-separation.
script=params=HOST=("one=two","three=four")
The DOMAIN parameter is used to replace the domain component of a "Set-Cookie:"
response header field. The DOMAIN parameter may contain multiple
'match=substitute' by comma-separation.
script=params=DOMAIN=("one=two","three=four")
This second example just illustrates how to extend the basic configuration to
support reverse-proxies into multiple internal hosts.
# HTTPD$MAP
[[the.reverse-proxy.service:port]]
redirect /one/* /proxymunge/http://one.internal.host/*?
redirect /two/* /proxymunge/http://two.internal.host/*?
#
set /proxymunge/http://one.internal.host/* script=params=\
(REVERSE="/one",HOST="two.internal.host=/two",\
DOMAIN="one.host.name=external.host.name")
#
set /proxymunge/http://two.internal.host/* script=params=\
(REVERSE="/two",HOST="one.internal.host=/one",\
DOMAIN="two.host.name=external.host.name")
#
script+ /proxymunge/* /cgi-bin/proxymunge/* map=once script=query=relaxed
COMMAND-LINE PARAMETERS
-----------------------
/DBUG low level debug statements
/WATCH output WASD server WATCH-able statements
/SSLV23 support SSL version 2 or 3 (default is 3 only)
(no longer supported with OpenSSL 1.0.n and later)
/TLS1 support TLSv1 (deprecated with OpenSSL 1.1.n)
/TLS11 support TLSv1.1 (OpenSSL 1.0.n and later)
/TLS12 support TLSv1.2 (OpenSSL 1.0.n and later)
/TLS13 support TLSv1.3 (OpenSSL 1.1.1 and later)
(if multiple /TLS qualifiers then lowest and highest become range)
LOGICAL NAMES
-------------
PROXYMUNGE$DBUG same as /DBUG
PROXYMUNGE$WATCH same as /WATCH
PROXYMUNGE$PARAM same as CLI
BUILD DETAILS
-------------
Compile then link:
$ @BUILD_PROXYMUNGE BUILD [<root directory of WASD OpenSSL package>]
To just link:
$ @BUILD_PROXYMUNGE LINK [<root directory of WASD OpenSSL package>]
COPYRIGHT
---------
Copyright (C) 2007-2021 Mark G.Daniel
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
VERSION HISTORY (update SOFTWAREVN as well)
---------------
25-FEB-2020 MGD v2.1.0, add /TLS.. qualifiers
23-FEB-2020 MGD v2.0.0, adapt to OpenSSL v1.1.n and later
22-SEP-2007 MGD v1.0.0, initial development
*/
/*****************************************************************************/
#define COPYRIGHT_DATE "2007-2020"
#define SOFTWAREVN "2.1.0"
#define SOFTWARENM "PROXYMUNGE"
#ifdef __ALPHA
# define SOFTWAREID SOFTWARENM " AXP-" SOFTWAREVN
#endif
#ifdef __ia64
# define SOFTWAREID SOFTWARENM " IA64-" SOFTWAREVN
#endif
#ifdef __VAX
# error VAX no longer implemented
#endif
#ifdef __x86_64
# define SOFTWAREID SOFTWARENM " X86-" SOFTWAREVN
#endif
#define SOFTWARECR "Copyright (C) " COPYRIGHT_DATE " Mark G.Daniel"
#ifndef MUNGE_VIA_SSL
/* default is to build without SSL support */
#define MUNGE_VIA_SSL 0
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Internet-related header files */
#include <socket.h>
#include <in.h>
#include <netdb.h>
#include <inet.h>
/* VMS related header files */
#include <descrip.h>
#include <lnmdef.h>
#include <ssdef.h>
#include <starlet.h>
#include <stsdef.h>
/* OpenSSL header files */
#if MUNGE_VIA_SSL
#include <openssl/crypto.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#endif
/* application header files */
#include <cgilib.h>
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define BOOL int
#define TRUE 1
#define FALSE 0
#define FOUTS(from,to) { \
if (to > from) { \
char ch; \
ch = *(to); \
*(to) = '\0'; \
fputs (from,stdout); \
*(to) = ch; \
} \
}
/******************/
/* global storage */
/******************/
char CopyrightDate [] = COPYRIGHT_DATE,
SoftwareCopy [] = SOFTWARECR,
Utility [] = "PROXYMUNGE";
BOOL CliSSLv23,
CliTLSv1,
CliTLSv11,
CliTLSv12,
CliTLSv13,
Debug,
HttpScheme,
HttpsScheme,
IsCgiPlus,
ResponseContentOpaque,
ResponseContentTextHtml,
ResponseContentTextCss,
WatchEnabled;
int CgiGatewayMrs,
CgiPlusUsageCount,
CgiParamDomainLength,
CgiParamInternalLength,
CgiParamReverseLength,
ReadBufferCount,
ReadBufferSize,
ResponseBodyCount,
ResponseBodySize,
ResponseContentLength,
ResponseHeaderCount,
ResponseHeaderSize,
ResponseBodyLength,
ServerSocket,
ServerPortNumber;
struct sockaddr_in ServerSockAddr;
char *CgiContentLengthPtr,
*CgiContentTypePtr,
*CgiEnvironmentPtr,
*CgiPathInfoPtr,
*CgiQueryStringPtr,
*CgiRequestMethodPtr,
*CgiParamDomainPtr,
*CgiParamHostPtr,
*CgiParamReversePtr,
*CgiGatewayMrsPtr,
*MungeDomainPtr,
*MungeHostPtr,
*ReadBufferPtr,
*RequestUriPtr,
*ResponseHeaderPtr,
*ResponseBodyPtr;
char ServerHostName [128],
ServerHostPort [128+16],
ServerPort [16],
SoftwareEnv [128];
#if MUNGE_VIA_SSL
#define OPENSSL_SINCE_111 (OPENSSL_VERSION_NUMBER >= 0x10101000L)
#define OPENSSL_BEFORE_111 (OPENSSL_VERSION_NUMBER < 0x10101000L)
#define OPENSSL_SINCE_110 (OPENSSL_VERSION_NUMBER >= 0x10100000L)
#define OPENSSL_BEFORE_110 (OPENSSL_VERSION_NUMBER < 0x10100000L)
SSL_CTX *SslContext;
SSL *SslServer;
SSL_METHOD *SslMethod;
BIO *BioServer;
#endif
/***********************/
/* function prototypes */
/***********************/
char* GetCgiVar (char*);
char* GetCgiVarNull (char*);
void ErrorExit (int, int);
void GetParameters ();
void MungeCssText (char*, char*);
char* MungeDomain (char*);
char* MungeUrl (char*, char);
void ProcessRequest ();
void ReturnCssResponseBody ();
void ReturnHtmlResponseBody ();
void ReturnHttpResponseHeader ();
char* SpanQuoted (char*, char*);
char* SpanToEndTag (char*, char*, char*);
char* SpanToTagClose (char*, char*);
char* SysTrnLnm (char*, char*);
char* StatTimer (BOOL);
int WatchThis (int, char*, ...);
int WatchDump (char*, int);
BOOL strsame (char*, char*, int);
/*****************************************************************************/
/*
*/
main ()
{
int minTLS, maxTLS;
char *cptr;
unsigned char RandBits[32];
/*********/
/* begin */
/*********/
CgiEnvironmentPtr = CgiLibEnvironmentVersion();
sprintf (SoftwareEnv, "%s, %s, %s",
SOFTWAREID, CgiEnvironmentPtr, BUILD_DATETIME);
Debug = (SysTrnLnm ("PROXYMUNGE$DBUG", NULL) != NULL);
if (Debug)
{
fprintf (stdout,
"Content-Type: text/plain\nScript-Control: X-content-encoding-gzip=0\n\n");
CgiLibEnvironmentSetDebug (1);
}
GetParameters ();
CgiLibEnvironmentInit (0, NULL, FALSE);
IsCgiPlus = CgiLibEnvironmentIsCgiPlus ();
#if MUNGE_VIA_SSL
SSL_library_init ();
OpenSSL_add_all_algorithms();
SSL_load_error_strings ();
/*
http://www.openssl.org/support/faq.html
'Why do I get a "PRNG not seeded" error message?'
*/
sys$gettim (&RandBits);
sys$numtim (&RandBits[8], &RandBits);
memmove (&RandBits[sizeof(RandBits)/2], &RandBits[3], sizeof(RandBits)/2);
#if OPENSSL_SINCE_110
/* 23-FEB-2020 MGD linking against v1.1.1c (at least) required this */
#pragma names save
#pragma names as_is
RAND_seed (&RandBits, sizeof(RandBits));
#pragma names restore
ERR_clear_error();
SslMethod = (SSL_METHOD*)TLS_client_method();
SslContext = SSL_CTX_new (SslMethod);
if (!SslContext)
{
fprintf (stdout, "Status: 500\n\n[line:%d] ", __LINE__);
ERR_print_errors_fp (stdout);
ErrorExit (SS$_BUGCHECK, __LINE__);
}
minTLS = TLS1_1_VERSION;
#if OPENSSL_SINCE_111
maxTLS = TLS1_3_VERSION;
#else
maxTLS = TLS1_2_VERSION;
#endif
if (CliTLSv1)
minTLS = TLS1_VERSION;
else
if (CliTLSv11)
minTLS = TLS1_1_VERSION;
else
if (CliTLSv12)
minTLS = TLS1_2_VERSION;
#if OPENSSL_SINCE_111
else
if (CliTLSv13)
minTLS = TLS1_3_VERSION;
#endif
#if OPENSSL_SINCE_111
if (CliTLSv13)
maxTLS = TLS1_3_VERSION;
else
#endif
if (CliTLSv12)
maxTLS = TLS1_2_VERSION;
else
if (CliTLSv11)
maxTLS = TLS1_1_VERSION;
else
if (CliTLSv1)
maxTLS = TLS1_VERSION;
ERR_clear_error();
if (!SSL_CTX_set_min_proto_version (SslContext, minTLS))
{
fprintf (stdout, "Status: 500\n\n[line:%d] ", __LINE__);
ERR_print_errors_fp (stdout);
ErrorExit (SS$_BUGCHECK, __LINE__);
return;
}
ERR_clear_error();
if (!SSL_CTX_set_max_proto_version(SslContext, maxTLS))
{
fprintf (stdout, "Status: 500\n\n[line:%d] ", __LINE__);
ERR_print_errors_fp (stdout);
ErrorExit (SS$_BUGCHECK, __LINE__);
return;
}
sprintf (SoftwareEnv, "%s, %s, %s, %s",
SOFTWAREID, CgiEnvironmentPtr, OpenSSL_version (OPENSSL_VERSION),
BUILD_DATETIME);
#else /* OPENSSL_SINCE_110 */
RAND_seed (&RandBits, sizeof(RandBits));
if (CliSSLv23)
SslMethod = (SSL_METHOD*)SSLv23_client_method ();
else
SslMethod = (SSL_METHOD*)SSLv3_client_method ();
SslContext = SSL_CTX_new (SslMethod);
if (!SslContext) ErrorExit (SS$_BUGCHECK, __LINE__);
sprintf (SoftwareEnv, "%s, %s, %s, %s",
SOFTWAREID, CgiEnvironmentPtr, SSLeay_version(SSLEAY_VERSION),
BUILD_DATETIME);
#endif /* OPENSSL_SINCE_110 */
#endif /* MUNGE_VIA_SSL */
for (;;)
{
/* block waiting for the next request */
CgiLibVar ("");
if (WatchEnabled = (SysTrnLnm ("PROXYMUNGE$WATCH", NULL) != NULL))
WatchThis (__LINE__, NULL);
ProcessRequest ();
if (WatchEnabled) WatchThis (__LINE__, NULL);
if (!IsCgiPlus) break;
CgiLibCgiPlusEOF ();
}
}
/*****************************************************************************/
/*
*/
void ProcessRequest ()
{
int cnt, retval;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ProcessRequest()\n");
if (WatchEnabled) WatchThis (__LINE__, "!AZ", SoftwareEnv);
if (IsCgiPlus)
{
CgiPlusUsageCount++;
if (WatchEnabled) WatchThis (__LINE__, "CgiPlus: !UL", CgiPlusUsageCount);
}
if (!ReadBufferPtr)
{
CgiGatewayMrsPtr = GetCgiVar ("GATEWAY_MRS");
CgiGatewayMrs = atoi(CgiGatewayMrsPtr);
if (!CgiGatewayMrs) CgiGatewayMrs = 4096;
ReadBufferSize = CgiGatewayMrs;
ReadBufferPtr = calloc (1, ReadBufferSize);
if (!ReadBufferPtr) ErrorExit (vaxc$errno, __LINE__);
ResponseHeaderSize = CgiGatewayMrs;
ResponseHeaderPtr = calloc (1, ResponseHeaderSize);
if (!ResponseHeaderPtr) ErrorExit (vaxc$errno, __LINE__);
}
if (WatchEnabled) WatchThis (__LINE__, "GATEWAY_MRS !SL", CgiGatewayMrs);
/********************/
/* munge parameters */
/********************/
CgiParamReversePtr = GetCgiVar ("REVERSE");
CgiParamReverseLength = strlen(CgiParamReversePtr);
CgiParamHostPtr = GetCgiVar ("HOST");
CgiParamInternalLength = strlen(CgiParamHostPtr);
if (MungeHostPtr) free (MungeHostPtr);
MungeHostPtr = NULL;
if (CgiParamInternalLength)
{
MungeHostPtr = sptr = calloc (1, CgiParamInternalLength+4);
if (!MungeHostPtr) ErrorExit (vaxc$errno, __LINE__);
for (cptr = CgiParamHostPtr; *cptr; *sptr++ = *cptr++);
*(unsigned long*)sptr = 0;
for (sptr = MungeHostPtr; *sptr; sptr++)
if (*sptr == '=' || *sptr == ',') *sptr = '\0';
if (WatchEnabled)
{
for (sptr = MungeHostPtr; *sptr; sptr++)
{
for (cptr = sptr; *cptr; cptr++);
cptr++;
WatchThis (__LINE__, "URL host \'!AZ\' to \'!AZ\'", sptr, cptr);
while (*cptr) cptr++;
sptr = cptr;
}
}
}
CgiParamDomainPtr = GetCgiVar ("DOMAIN");
CgiParamDomainLength = strlen(CgiParamDomainPtr);
if (MungeDomainPtr) free (MungeDomainPtr);
MungeDomainPtr = NULL;
if (CgiParamDomainLength)
{
MungeDomainPtr = sptr = calloc (1, CgiParamDomainLength+4);
if (!MungeDomainPtr) ErrorExit (vaxc$errno, __LINE__);
for (cptr = CgiParamDomainPtr; *cptr; *sptr++ = *cptr++);
*(unsigned long*)sptr = 0;
for (sptr = MungeDomainPtr; *sptr; sptr++)
if (*sptr == '=' || *sptr == ',') *sptr = '\0';
if (WatchEnabled)
{
for (sptr = MungeDomainPtr; *sptr; sptr++)
{
for (cptr = sptr; *cptr; cptr++);
cptr++;
WatchThis (__LINE__, "COOKIE domain \'!AZ\' to \'!AZ\'",
sptr, cptr);
while (*cptr) cptr++;
sptr = cptr;
}
}
}
/**********************/
/* parse host and URI */
/**********************/
CgiPathInfoPtr = GetCgiVar ("PATH_INFO");
CgiQueryStringPtr = GetCgiVar ("QUERY_STRING");
cptr = CgiPathInfoPtr;
if (*cptr) cptr++;
HttpScheme = HttpsScheme = FALSE;
if (!strncmp (cptr, "http://", cnt = 7))
HttpScheme = TRUE;
else
if (!strncmp (cptr, "https://", cnt = 8))
HttpsScheme = TRUE;
#if !MUNGE_VIA_SSL
if (HttpsScheme)
{
if (WatchEnabled) WatchThis (__LINE__, "SSL not supported");
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'SSL not supported\'\n\n");
return;
}
#endif
if (!(HttpScheme || HttpsScheme))
{
if (WatchEnabled) WatchThis (__LINE__, "CONFUSED mapping !AZ", cptr);
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'CONFUSED mapping\'\n\n");
return;
}
zptr = (sptr = ServerHostName) + sizeof(ServerHostName)-1;
cptr += cnt;
while (*cptr && *cptr != ':' && *cptr != '/' && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
while (*cptr && *cptr != ':' && *cptr != '/') cptr++;
if (*cptr == ':')
{
cptr++;
zptr = (sptr = ServerPort) + sizeof(ServerHostName)-1;
while (*cptr && *cptr != '/' && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
ServerPortNumber = atoi(ServerPort);
while (*cptr && *cptr != '/') cptr++;
}
else
{
#if MUNGE_VIA_SSL
if (HttpsScheme)
{
strcpy (ServerPort, "443");
ServerPortNumber = 443;
}
else
#endif
{
strcpy (ServerPort, "80");
ServerPortNumber = 80;
}
}
sprintf (ServerHostPort, "%s:%s", ServerHostName, ServerPort);
RequestUriPtr = cptr;
/*****************/
/* proxy request */
/*****************/
retval = ConnectToServer ();
#if MUNGE_VIA_SSL
if (HttpsScheme && retval >= 0)
{
SslServer = SSL_new (SslContext);
if (!SslServer)
{
if (WatchEnabled)
{
WatchThis (__LINE__, "SSL_new() failure");
ERR_print_errors_fp (stdout);
}
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'SSL_new() failure\'\n\n");
return;
}
retval = SSL_set_fd (SslServer, ServerSocket);
if (retval <= 0)
{
if (WatchEnabled)
{
WatchThis (__LINE__, "SSL_set_fd() failure");
ERR_print_errors_fp (stdout);
}
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'SSL_set_fd() failure\'\n\n");
return;
}
ERR_clear_error();
retval = SSL_connect (SslServer);
if (retval <= 0)
{
if (WatchEnabled)
{
WatchThis (__LINE__, "SSL_connect() failure");
ERR_print_errors_fp (stdout);
}
fprintf (stdout, "Status: 500\n\n[line:%d] ", __LINE__);
ERR_print_errors_fp (stdout);
return;
}
if (WatchEnabled)
WatchThis (__LINE__, "SSL established using !AZ",
SSL_get_cipher (SslServer));
}
#endif
if (retval >= 0) retval = MakeHttpRequest ();
if (retval >= 0) retval = GetHttpResponse ();
if (retval >= 0)
{
if (ResponseContentTextHtml)
ReturnHtmlResponseBody ();
else
if (ResponseContentTextCss)
ReturnCssResponseBody ();
}
#if MUNGE_VIA_SSL
if (HttpsScheme) SSL_shutdown (SslServer);
#endif
shutdown (ServerSocket, 2);
close (ServerSocket);
#if MUNGE_VIA_SSL
if (HttpsScheme) SSL_free (SslServer);
#endif
}
/*****************************************************************************/
/*
TCP/IP connect to the server specified by ServerHostName and ServerPortNumber.
*/
int ConnectToServer ()
{
#define SIZINADDR (sizeof(struct in_addr))
int retval;
struct in_addr InAddr;
struct hostent *HostEntryPtr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ConnectToServer()\n");
if (WatchEnabled) WatchThis (__LINE__, "CONNECT !AZ", ServerHostPort);
memset (&ServerSockAddr, 0, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_port = htons (ServerPortNumber);
InAddr.s_addr = inet_addr (ServerHostName);
if (InAddr.s_addr == (unsigned int)INADDR_NONE)
{
HostEntryPtr = gethostbyname (ServerHostName);
if (HostEntryPtr)
memcpy (&ServerSockAddr.sin_addr, HostEntryPtr->h_addr, SIZINADDR);
else
{
if (WatchEnabled) WatchThis (__LINE__, "host not resolved");
fprintf (stdout,
"Status: 504\n\
Script-Control: X-error-text=\'host not resolved\'\n\n");
return (-1);
}
}
else
memcpy (&ServerSockAddr.sin_addr, &InAddr.s_addr, SIZINADDR);
ServerSocket = socket(AF_INET, SOCK_STREAM, 0);
if (ServerSocket < 0)
{
if (WatchEnabled)
WatchThis (__LINE__, "SOCKET failure %X!8XL", vaxc$errno);
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'%%X%08.08XL %s\'\n\n",
vaxc$errno, strerror(vaxc$errno));
return (-1);
}
retval = connect (ServerSocket,
(const struct sockaddr*)&ServerSockAddr,
sizeof(ServerSockAddr));
if (retval < 0)
{
if (WatchEnabled)
WatchThis (__LINE__, "CONNECT failure %X!8XL", vaxc$errno);
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'%%X%08.08XL %s\'\n\n",
vaxc$errno, strerror(vaxc$errno));
return (retval);
}
}
/****************************************************************************/
/*
Rebuild an HTTP/1.0 request header representing the proxied request and write
it to the TCP/IP connected server.
*/
int MakeHttpRequest ()
{
int retval,
ContentLength = 0,
PostBufferCount = 0;
char *aptr, *cptr, *sptr, *zptr,
*PostBufferPtr = NULL;
char RequestBuffer [2048];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MakeHttpRequest()\n");
CgiRequestMethodPtr = GetCgiVar ("REQUEST_METHOD");
zptr = (sptr = RequestBuffer) + sizeof(RequestBuffer)-1;
for (cptr = CgiRequestMethodPtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (sptr < zptr) *sptr++ = ' ';
for (cptr = RequestUriPtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (*CgiQueryStringPtr)
{
if (sptr < zptr) *sptr++ = '?';
for (cptr = CgiQueryStringPtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
for (cptr = " HTTP/1.0\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "Host: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = ServerHostName; *cptr && sptr < zptr; *sptr++ = *cptr++);
if (ServerPortNumber != 80)
{
if (sptr < zptr) *sptr++ = ':';
for (cptr = ServerPort; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "X-Proxy-Agent: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = SoftwareEnv; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
aptr = GetCgiVarNull ("HTTP_AUTHORIZATION");
if (aptr)
{
for (cptr = "Authorization: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
aptr = GetCgiVarNull ("HTTP_USER_AGENT");
if (aptr)
{
for (cptr = "User-Agent: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
aptr = GetCgiVarNull ("HTTP_ACCEPT");
if (aptr)
{
for (cptr = "Accept: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
aptr = GetCgiVarNull ("HTTP_ACCEPT_CHARSET");
if (aptr)
{
for (cptr = "Accept-Charset: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
aptr = GetCgiVarNull ("HTTP_LANGUAGE");
if (aptr)
{
for (cptr = "Accept-Language: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
aptr = GetCgiVarNull ("HTTP_COOKIE");
if (aptr)
{
for (cptr = "Cookie: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
aptr = GetCgiVarNull ("HTTP_IF_MODIFIED_SINCE");
if (aptr)
{
for (cptr = "If-Modified-Since: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
if (!strcmp (CgiRequestMethodPtr, "GET"))
{
/* nothing additional required with this supported method */
}
else
if (!strcmp (CgiRequestMethodPtr, "HEAD"))
{
/* nothing additional required with this supported method */
}
else
if (!strcmp (CgiRequestMethodPtr, "POST"))
{
CgiContentTypePtr = GetCgiVar("CONTENT_TYPE");
CgiContentLengthPtr = GetCgiVar("CONTENT_LENGTH");
ContentLength = atoi(CgiContentLengthPtr);
CgiLibReadRequestBody (&PostBufferPtr, &PostBufferCount);
if (WatchEnabled) WatchThis (__LINE__, "POST !UL bytes", PostBufferCount);
if (!PostBufferPtr || PostBufferCount != ContentLength)
{
if (PostBufferPtr) free (PostBufferPtr);
if (WatchEnabled) WatchThis (__LINE__, "POST body read failure");
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'POST body read failure\'\n\n");
return (-1);
}
for (cptr = "Content-Type: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = CgiContentTypePtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\nContent-Length: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = CgiContentLengthPtr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
else
{
if (WatchEnabled)
WatchThis (__LINE__, "!AZ not supported", CgiRequestMethodPtr);
fprintf (stdout,
"Status: 501\n\
Script-Control: X-error-text=\'%s not supported\'\n\n", CgiRequestMethodPtr);
return (-1);
}
aptr = GetCgiVarNull ("HTTP_PRAGMA");
if (aptr)
{
for (cptr = "Pragma: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
aptr = GetCgiVarNull ("HTTP_CACHE_CONTROL");
if (aptr)
{
for (cptr = "Cache-Control: "; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = aptr; *cptr && sptr < zptr; *sptr++ = *cptr++);
for (cptr = "\r\n"; *cptr && sptr < zptr; *sptr++ = *cptr++);
}
for (cptr = "Connection: close\r\n\r\n";
*cptr && sptr < zptr;
*sptr++ = *cptr++);
*sptr = '\0';
if (WatchEnabled) WatchThis (__LINE__, "!AZ", RequestBuffer);
if (sptr >= zptr)
{
if (WatchEnabled) WatchThis (__LINE__, "Request buffer overflow");
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'Request buffer overflow\'\n\n");
return (-1);
}
#if MUNGE_VIA_SSL
if (HttpsScheme)
retval = SSL_write (SslServer, RequestBuffer, sptr-RequestBuffer);
else
#endif
retval = write (ServerSocket, RequestBuffer, sptr-RequestBuffer);
if (PostBufferPtr)
{
if (retval >= 0)
{
#if MUNGE_VIA_SSL
if (HttpsScheme)
SSL_write (SslServer, PostBufferPtr, PostBufferCount);
else
#endif
write (ServerSocket, PostBufferPtr, PostBufferCount);
}
free (PostBufferPtr);
}
return (retval);
}
/****************************************************************************/
/*
Read the response from the TCP/IP connected server. Continue reading until the
HTTP response header is received. Once that is available parse the contents
for information relevant to processing the body and send it to the client (via
the script stdout) fields munged as necessary.
If the response content-type is not HTML then it's opaque and continue to read,
sending each buffer back to the client, until the server disconnects.
If the response body is HTML then continue reading, buffering that body until
the server disconnects.
*/
int GetHttpResponse ()
{
int retval;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "GetHttpRequest()\n");
ResponseHeaderCount = 0;
zptr = (sptr = ResponseHeaderPtr) + ResponseHeaderSize - 1;
for (;;)
{
#if MUNGE_VIA_SSL
if (HttpsScheme)
retval = SSL_read (SslServer, ReadBufferPtr, ReadBufferSize);
else
#endif
retval = read (ServerSocket, ReadBufferPtr, ReadBufferSize);
if (WatchEnabled)
{
WatchThis (__LINE__, "READ !SL", retval);
if (retval > 0) WatchDump (ReadBufferPtr, retval);
}
if (retval <= 0) break;
ReadBufferCount = retval;
if (!ResponseHeaderCount)
{
/*******************/
/* response header */
/*******************/
cptr = ReadBufferPtr;
while (retval-- && sptr < zptr)
{
*sptr++ = *cptr;
if (*cptr++ == '\n')
{
if (sptr > ResponseHeaderPtr+2 &&
*(unsigned short*)(sptr-2) == '\n\n')
{
*sptr = '\0';
ResponseHeaderCount = sptr - ResponseHeaderPtr;
break;
}
else
if (sptr > ResponseHeaderPtr+4 &&
*(unsigned long*)(sptr-4) == '\r\n\r\n')
{
*sptr = '\0';
ResponseHeaderCount = sptr - ResponseHeaderPtr;
break;
}
}
}
if (!ResponseHeaderCount) continue;
ReturnHttpResponseHeader ();
/*************/
/* any body? */
/*************/
if (ResponseContentOpaque)
{
/* write anything remaining in the buffer following the header */
if (retval > 0)
if (ReadBufferCount - ResponseHeaderCount > 0)
retval = fwrite (ReadBufferPtr + ResponseHeaderCount,
ReadBufferCount - ResponseHeaderCount,
1, stdout);
}
else
if (ReadBufferCount - ResponseHeaderCount)
{
/* response body remaining after parse of response header */
if (ResponseContentLength)
ResponseBodySize = ResponseContentLength;
else
ResponseBodySize = CgiGatewayMrs;
ResponseBodyPtr = calloc (1, ResponseBodySize+16);
if (!ResponseBodyPtr) ErrorExit (vaxc$errno, __LINE__);
memcpy (ResponseBodyPtr,
ReadBufferPtr + ResponseHeaderCount,
ReadBufferCount - ResponseHeaderCount);
ResponseBodyCount = ReadBufferCount - ResponseHeaderCount;
}
continue;
}
/*****************/
/* response body */
/*****************/
if (ResponseContentOpaque)
{
/*************************/
/* to client immediately */
/*************************/
fwrite (ReadBufferPtr, ReadBufferCount, 1, stdout);
}
else
{
/*******************/
/* buffer the body */
/*******************/
if (!ResponseBodyPtr)
{
if (ResponseContentLength)
ResponseBodySize = ResponseContentLength;
else
ResponseBodySize = CgiGatewayMrs;
ResponseBodyPtr = calloc (1, ResponseBodySize+16);
if (!ResponseBodyPtr) ErrorExit (vaxc$errno, __LINE__);
ResponseBodyCount = 0;
}
if (ResponseBodyCount + ReadBufferCount > ResponseBodySize)
{
ResponseBodySize += CgiGatewayMrs;
ResponseBodyPtr = realloc (ResponseBodyPtr, ResponseBodySize+16);
if (!ResponseBodyPtr) ErrorExit (vaxc$errno, __LINE__);
}
memcpy (ResponseBodyPtr+ResponseBodyCount,
ReadBufferPtr,
ReadBufferCount);
ResponseBodyCount += ReadBufferCount;
if (WatchEnabled)
WatchThis (__LINE__, "BODY !UL/!UL",
ResponseBodySize, ResponseBodyCount);
}
}
return (retval);
}
/****************************************************************************/
/*
Return a munged (if required) HTTP response header to the client.
*/
void ReturnHttpResponseHeader ()
{
char *aptr, *cptr, *sptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ReturnHttpResponseHeader()\n");
ResponseContentOpaque = TRUE;
ResponseContentTextCss = ResponseContentTextHtml = FALSE;
/* first, are we dealing with HTML? */
cptr = ResponseHeaderPtr;
while (*cptr)
{
if (strsame (cptr, "Content-Type:", 13))
{
for (cptr += 13; *cptr && *cptr == ' '; cptr++);
if (!strncmp (cptr, "text/html", 9))
{
ResponseContentTextHtml = TRUE;
ResponseContentOpaque = FALSE;
}
else
if (!strncmp (cptr, "text/css", 8))
{
ResponseContentTextCss = TRUE;
ResponseContentOpaque = FALSE;
}
break;
}
while (*cptr && *cptr != '\n') cptr++;
if (*cptr) cptr++;
}
cptr = sptr = ResponseHeaderPtr;
while (*cptr)
{
if (strsame (cptr, "Content-Length:", 15))
{
if (ResponseContentOpaque)
{
/* opaque content, we'll just be spitting out a bago'bytes */
for (cptr += 15; *cptr && *cptr == ' '; cptr++);
if (isdigit (*cptr)) ResponseContentLength = atoi(cptr);
}
else
{
/* once munged this content-length most likely won't be accurate */
FOUTS (sptr, cptr)
for (cptr += 15; *cptr && *cptr != '\n'; cptr++);
if (*cptr) cptr++;
sptr = cptr;
}
}
else
if (strsame (cptr, "Set-Cookie:", 11))
{
cptr += 11;
while (*cptr && *cptr != '\n')
{
if (tolower(*cptr) == 'p' && strsame (cptr, "path=", 5))
{
cptr += 5;
FOUTS (sptr, cptr)
cptr = sptr = MungeUrl (cptr, 0);
}
else
if (tolower(*cptr) == 'd' && strsame (cptr, "domain=", 7))
{
cptr += 7;
FOUTS (sptr, cptr)
cptr = sptr = MungeDomain (cptr);
}
else
cptr++;
}
}
else
if (strsame (cptr, "Location:", 9))
{
cptr += 9;
while (*cptr && *cptr == ' ') cptr++;
FOUTS (sptr, cptr)
cptr = sptr = MungeUrl (cptr, 0);
}
while (*cptr && *cptr != '\n') cptr++;
if (*cptr) cptr++;
}
FOUTS (sptr, cptr)
}
/****************************************************************************/
/*
Process the HTML content of the response body, munging URLs contained
in ACTION=, BACKGROUND=, HREF= and SRC= as required. Free the dynamically
allocated body buffer when complete.
*/
void ReturnHtmlResponseBody ()
{
char ch;
char *aptr, *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ReturnHttpResponseBody()\n");
if (!ResponseBodyPtr) return;
zptr = (cptr = sptr = ResponseBodyPtr) + ResponseBodyCount;
while (cptr < zptr)
{
if (*cptr != '<')
{
/* not inside a markup tag */
cptr++;
continue;
}
if (strsame (cptr, "<SCRIPT", 7))
{
/**************/
/* SCRIPT TAG */
/**************/
cptr = SpanToTagClose (cptr+7, zptr);
cptr = SpanToEndTag ("</SCRIPT>", cptr, zptr);
continue;
}
if (strsame (cptr, "<STYLE", 6))
{
/*************/
/* STYLE TAG */
/*************/
cptr = SpanToTagClose (cptr+6, zptr);
FOUTS (sptr, (aptr = cptr))
cptr = sptr = SpanToEndTag ("</STYLE>", cptr, zptr);
if (cptr < zptr) MungeCssText (aptr, (sptr=(cptr-8)));
continue;
}
/*************/
/* OTHER TAG */
/*************/
cptr++;
while (cptr < zptr)
{
/* if reached the end of a markup tag (or non-well-formed one) */
if (*cptr == '>' || *cptr == '<') break;
if (*cptr == '\"' || *cptr == '\'')
{
cptr = SpanQuoted (cptr, zptr);
continue;
}
if (tolower(*cptr) == 's' && strsame (cptr, "style=", 6))
{
/*******************/
/* STYLE ATTRIBUTE */
/*******************/
cptr += 6;
if (*cptr == '\"' || *cptr == '\'')
{
ch = *cptr++;
FOUTS (sptr, (aptr = cptr))
while (cptr < zptr && *cptr != ch) cptr++;
MungeCssText (aptr, (sptr=cptr));
if (cptr < zptr) cptr++;
}
else
{
FOUTS (sptr, (aptr = cptr))
while (cptr < zptr && !isspace(*cptr)) cptr++;
MungeCssText (aptr, (sptr=cptr));
}
continue;
}
/*******************/
/* OTHER ATTRIBUTE */
/*******************/
if (tolower(*cptr) == 'h' && strsame (cptr, "href=", 5))
cptr += 5;
else
if (tolower(*cptr) == 's' && strsame (cptr, "src=", 4))
cptr += 4;
else
if (tolower(*cptr) == 'b' && strsame (cptr, "background=", 11))
cptr += 11;
else
if (tolower(*cptr) == 'a' && strsame (cptr, "action=", 7))
cptr += 7;
else
if (tolower(*cptr) == 'c' && strsame (cptr, "code=", 5))
cptr += 5;
else
if (tolower(*cptr) == 'c' && strsame (cptr, "codebase=", 9))
cptr += 9;
else
if (tolower(*cptr) == 'd' && strsame (cptr, "data=", 5))
cptr += 5;
else
if (tolower(*cptr) == 'u' && strsame (cptr, "usemap=", 7))
cptr += 7;
else
if (tolower(*cptr) == 'a' && strsame (cptr, "archive=", 8))
cptr += 8;
else
{
cptr++;
continue;
}
if (*cptr == '\"' || *cptr == '\'')
{
ch = *cptr++;
FOUTS (sptr, cptr)
cptr = sptr = MungeUrl (cptr, ch);
while (cptr < zptr && *cptr != ch) cptr++;
if (cptr < zptr) cptr++;
}
else
{
FOUTS (sptr, cptr)
cptr = sptr = MungeUrl (cptr, 0);
}
}
}
FOUTS (sptr, cptr)
free (ResponseBodyPtr);
ResponseBodyPtr = NULL;
ResponseBodySize = 0;
}
/****************************************************************************/
/*
Span all text between the quotes.
*/
char* SpanQuoted
(
char *StartPtr,
char *EndPtr
)
{
char ch;
char *cptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SpanQuoted()\n");
cptr = StartPtr;
ch = *cptr++;
while (cptr < EndPtr && *cptr != ch) cptr++;
if (cptr < EndPtr) cptr++;
return (cptr);
}
/****************************************************************************/
/*
Span all text between to the end-of-tag '>'.
*/
char* SpanToTagClose
(
char *cptr,
char *zptr
)
{
char ch;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SpanToTagClose()\n");
while (cptr < zptr)
{
if (*cptr == '\"' || *cptr == '\'')
{
cptr = SpanQuoted (cptr, zptr);
continue;
}
/* if end of tag */
if (*cptr == '>') break;
cptr++;
}
if (cptr < zptr) cptr++;
return (cptr);
}
/****************************************************************************/
/*
Span all text between to the specific end tag (e.g. "</SCRIPT>").
*/
char* SpanToEndTag
(
char *EndTag,
char *cptr,
char *zptr
)
{
int len;
char ch;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SpanToEndTag()\n");
len = strlen (EndTag);
while (cptr < zptr)
{
if (*cptr == '\"' || *cptr == '\'')
{
cptr = SpanQuoted (cptr, zptr);
continue;
}
/* if end tag */
if (*cptr == '<' && strsame (cptr, EndTag, len)) break;
cptr++;
}
if (cptr+len < zptr) cptr += len;
return (cptr);
}
/****************************************************************************/
/*
Munge a "text/css" response body.
*/
void ReturnCssResponseBody ()
{
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ReturnCssResponseBody()\n");
if (!ResponseBodyPtr) return;
MungeCssText (ResponseBodyPtr, ResponseBodyPtr+ResponseBodyCount);
free (ResponseBodyPtr);
ResponseBodyPtr = NULL;
ResponseBodySize = 0;
}
/****************************************************************************/
/*
About all that is required for munging Cascading Style Sheets is to identify
the 'url' element and modify that appropriately.
*/
void MungeCssText
(
char *cptr,
char *zptr
)
{
char *sptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MungeCssText()\n");
sptr = cptr;
while (cptr < zptr)
{
if (*cptr != '{')
{
/* not inside a property */
if (*(unsigned short*)cptr == '/*')
{
/* ingore anything inside comment delimiters */
cptr += 2;
while (cptr < zptr && *(unsigned short*)cptr != '*/') cptr++;
if (cptr < zptr) cptr += 2;
}
else
cptr++;
continue;
}
cptr++;
while (cptr < zptr)
{
/* if reached the end of a property (or non-well-formed one) */
if (*cptr == '}' || *cptr == '{') break;
/* ingore anything inside a property between double quotes */
if (*cptr == '\"')
{
cptr = SpanQuoted (cptr, zptr);
continue;
}
/* inside a property */
if (tolower(*cptr) == 'u' &&
(!strncmp (cptr, "url(", 4) || !strncmp (cptr, "url ", 4)))
cptr += 4;
else
{
cptr++;
continue;
}
while (*cptr && isspace(*cptr)) cptr++;
if (*cptr == '\"')
{
cptr++;
FOUTS (sptr, cptr)
cptr = sptr = MungeUrl (cptr, '\"');
while (cptr < zptr && *cptr != '\"') cptr++;
if (cptr < zptr) cptr++;
}
else
{
FOUTS (sptr, cptr)
cptr = sptr = MungeUrl (cptr, 0);
}
}
}
FOUTS (sptr, cptr)
}
/****************************************************************************/
/*
Modify a URL in a HREF=, SRC=, etc. If the URL is not a relative reference
then check if it's an absolute URL. If so check if the host component if the
same as the proxied-to server. If it is then just substitute the reverse-proxy
path. If a rooted URI then just prefix it with the reverse-proxy path.
*/
char* MungeUrl
(
char *UrlPtr,
char QuoteChar
)
{
int cnt, retval;
char *cptr, *sptr, *zptr;
char HostBuffer [256];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MungeUrl()\n");
if (!*CgiParamReversePtr) return (UrlPtr);
cptr = UrlPtr;
if (strsame (cptr, "//", cnt = 2) ||
strsame (cptr, "http://", cnt = 7))
{
cptr += cnt;
zptr = (sptr = HostBuffer) + sizeof(HostBuffer)-1;
while (*cptr && *cptr != '/' && *cptr != QuoteChar &&
!isspace(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
while (*cptr && *cptr != '/' && *cptr != QuoteChar && !isspace(*cptr))
cptr++;
if (sptr = MungeHostPtr)
{
while (*sptr)
{
if (strsame (HostBuffer, sptr, -1))
{
while (*sptr) sptr++;
sptr++;
fputs (sptr, stdout);
return (cptr);
}
while (*sptr) sptr++;
sptr++;
if (*sptr)
{
while (*sptr) sptr++;
sptr++;
}
}
}
if (!strsame (HostBuffer, ServerHostName, -1) &&
!strsame (HostBuffer, ServerHostPort, -1)) return (UrlPtr);
fputs (CgiParamReversePtr, stdout);
return (cptr);
}
if (*cptr == '/')
{
/* rooted URI */
fputs (CgiParamReversePtr, stdout);
return (cptr);
}
return (UrlPtr);
}
/****************************************************************************/
/*
Rewrites the 'domain=' component of a cookie.
*/
char* MungeDomain (char *DomainPtr)
{
int cnt, retval;
char *cptr, *sptr, *zptr;
char DomainBuffer [256];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MungeDomain()\n");
if (!MungeDomainPtr) return (DomainPtr);
cptr = sptr = DomainPtr;
zptr = (sptr = DomainBuffer) + sizeof(DomainBuffer)-1;
while (*cptr && *cptr != ';' && !isspace(*cptr) && sptr < zptr)
*sptr++ = *cptr++;
*sptr = '\0';
while (*cptr && *cptr != ';' && !isspace(*cptr)) cptr++;
sptr = MungeDomainPtr;
while (*sptr)
{
if (strsame (DomainBuffer, sptr, -1))
{
while (*sptr) sptr++;
sptr++;
fputs (sptr, stdout);
return (cptr);
}
while (*sptr) sptr++;
sptr++;
if (*sptr)
{
while (*sptr) sptr++;
sptr++;
}
}
return (DomainPtr);
}
/*****************************************************************************/
/*
*/
char* GetCgiVar (char *VarName)
{
char *cptr;
/*********/
/* begin */
/*********/
cptr = CgiLibVar (VarName);
if (WatchEnabled) WatchThis (__LINE__, "!AZ=!AZ", VarName, cptr);
return (cptr);
}
/*****************************************************************************/
/*
*/
char* GetCgiVarNull (char *VarName)
{
char *cptr;
/*********/
/* begin */
/*********/
cptr = CgiLibVarNull (VarName);
if (WatchEnabled)
WatchThis (__LINE__, "!AZ=!AZ", VarName, cptr ? cptr : "(null)");
return (cptr);
}
/*****************************************************************************/
/*
Exit after reporting the source code module name and line number.
*/
void ErrorExit
(
int StatusValue,
int SourceLineNumber
)
{
/*********/
/* begin */
/*********/
if (WatchEnabled) WatchThis (__LINE__, "%X!8XL - fatal error");
fprintf (stdout,
"Status: 500\n\
Script-Control: X-error-text=\'%X!8XL - fatal error\'\n\n", StatusValue);
exit (StatusValue);
}
/*****************************************************************************/
/*
Hmmm, idea look familiar? :-)
*/
int WatchThis
(
int SourceCodeLine,
char *FaoString,
...
)
{
static int WatchCount;
int argcnt, status;
char *cptr, *sptr, *zptr;
char Buffer [16384],
FaoBuffer [256];
unsigned long *vecptr;
$DESCRIPTOR (BufferDsc, Buffer);
$DESCRIPTOR (FaoBufferDsc, FaoBuffer);
unsigned long FaoVector [32];
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if (Debug) fprintf (stdout, "WatchThis() %d |%s|\n", argcnt, FaoString);
if (!FaoString)
{
if (WatchCount)
{
/* post-processing reset */
WatchThis (__LINE__, "STATS !AZ", StatTimer(TRUE));
WatchThis (__LINE__, "WATCH end");
WatchEnabled = WatchCount = 0;
}
else
{
/* pre-processing initialize */
WatchCount = 1;
CgiLibResponseHeader (200, "text/plain",
"Script-Control: X-content-encoding-gzip=0\n");
WatchThis (__LINE__, "WATCH begin");
StatTimer(FALSE);
}
return (SS$_NORMAL);
}
vecptr = FaoVector;
*vecptr++ = WatchCount++;
*vecptr++ = 0;
*vecptr++ = SourceCodeLine;
va_start (argptr, FaoString);
for (argcnt -= 2; argcnt; argcnt--)
*vecptr++ = (unsigned long)va_arg (argptr, unsigned long);
va_end (argptr);
zptr = (sptr = FaoBuffer) + sizeof(FaoBuffer)-3;
for (cptr = "|!4ZL|!%T|!4ZL|"; *cptr; *sptr++ = *cptr++);
for (cptr = FaoString; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr++ = '|';
*sptr++ = '\n';
*sptr++ = '\0';
FaoBufferDsc.dsc$a_pointer = FaoBuffer;
FaoBufferDsc.dsc$w_length = sptr - FaoBuffer;
status = sys$faol (&FaoBufferDsc, 0, &BufferDsc,
(unsigned long*)&FaoVector);
if (Debug) fprintf (stdout, "sys$fao() %%X%08.08X\n", status);
if (!(status & 1)) exit (status);
fputs (Buffer, stdout);
return (status);
}
/*****************************************************************************/
/*
Ditto? :-)
*/
int WatchDump
(
char *DataPtr,
int DataLength
)
{
int cnt, len;
char *cptr, *lptr, *sptr;
char WatchBuffer [256];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "WatchDump() %d\n", DataLength);
cptr = DataPtr;
len = DataLength;
while (len)
{
sptr = WatchBuffer;
lptr = cptr;
cnt = 0;
while (cnt < 32)
{
if (cnt < len)
sptr += sprintf (sptr, "%02.02X", (unsigned char)*cptr++);
else
{
*sptr++ = ' ';
*sptr++ = ' ';
}
if (!(++cnt % 4)) *sptr++ = ' ';
}
*sptr++ = ' ';
cptr = lptr;
cnt = 0;
while (cnt < 32 && cnt < len)
{
if (isprint(*cptr))
*sptr++ = *cptr;
else
*sptr++ = '.';
cptr++;
cnt++;
}
if (len > 32) len -= 32; else len = 0;
*sptr++ = '\n';
*sptr = '\0';
fputs (WatchBuffer, stdout);
}
return (1);
}
/*****************************************************************************/
/*
*/
char* StatTimer (BOOL ShowStat)
{
static $DESCRIPTOR (FaoDsc,
"REAL:!%T CPU:!UL.!2ZL DIO:!UL BIO:!UL FAULTS:!UL\0");
static char StatString [96];
static $DESCRIPTOR (StatStringDsc, StatString);
static unsigned long LibStatTimerReal = 1,
LibStatTimerCpu = 2,
LibStatTimerBio = 3,
LibStatTimerDio = 4,
LibStatTimerFaults = 5;
int status;
unsigned long CpuBinTime,
CountBio,
CountDio,
CountFaults;
unsigned long RealBinTime [2];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "StatTimer()\n");
if (!ShowStat)
{
lib$init_timer (0);
return (NULL);
}
/* post-processing reset */
lib$stat_timer (&LibStatTimerReal, &RealBinTime, 0);
lib$stat_timer (&LibStatTimerCpu, &CpuBinTime, 0);
lib$stat_timer (&LibStatTimerBio, &CountBio, 0);
lib$stat_timer (&LibStatTimerDio, &CountDio, 0);
lib$stat_timer (&LibStatTimerFaults, &CountFaults, 0);
sys$fao (&FaoDsc, 0, &StatStringDsc,
&RealBinTime, CpuBinTime/100, CpuBinTime%100,
CountDio, CountBio, CountFaults);
return (StatString);
}
/*****************************************************************************/
/*
Translate a logical name using LNM$FILE_DEV. Return a pointer to the value
string, or NULL if the name does not exist. If 'LogValue' is supplied the
logical name is translated into that (assumed to be large enough), otherwise
it's translated into an internal static buffer.
*/
char* SysTrnLnm
(
char *LogName,
char *LogValue
)
{
static unsigned short ShortLength;
static char StaticLogValue [256];
static $DESCRIPTOR (LogNameDsc, "");
static $DESCRIPTOR (LnmFileDevDsc, "LNM$FILE_DEV");
static struct {
short int buf_len;
short int item;
void *buf_addr;
unsigned short *ret_len;
} LnmItems [] =
{
{ 255, LNM$_STRING, 0, &ShortLength },
{ 0,0,0,0 }
};
int status;
char *cptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "SysTrnLnm() |%s|\n", LogName);
LogNameDsc.dsc$a_pointer = LogName;
LogNameDsc.dsc$w_length = strlen(LogName);
if (LogValue)
cptr = LnmItems[0].buf_addr = LogValue;
else
cptr = LnmItems[0].buf_addr = StaticLogValue;
status = sys$trnlnm (0, &LnmFileDevDsc, &LogNameDsc, 0, &LnmItems);
if (Debug) fprintf (stdout, "sys$trnlnm() %%X%08.08X\n", status);
if (!(status & 1))
{
if (Debug) fprintf (stdout, "|(null)|\n");
return (NULL);
}
cptr[ShortLength] = '\0';
if (Debug) fprintf (stdout, "|%s|\n", cptr);
return (cptr);
}
/****************************************************************************/
/*
Does a case-insensitive, character-by-character string compare and returns
TRUE if two strings are the same, or FALSE if not. If a maximum number of
characters are specified only those will be compared, if the entire strings
should be compared then specify the number of characters as 0.
*/
BOOL strsame
(
char *sptr1,
char *sptr2,
int count
)
{
/*********/
/* begin */
/*********/
while (*sptr1 && *sptr2)
{
if (toupper (*sptr1++) != toupper (*sptr2++)) return (FALSE);
if (count)
if (!--count) return (TRUE);
}
if (*sptr1 || *sptr2)
return (FALSE);
else
return (TRUE);
}
/*****************************************************************************/
/*
Get "command-line" parameters, whether from the command-line or from a
configuration symbol or logical containing the equivalent. OSU scripts have
the 'method', 'url' and 'protocol' supplied as P1, P2, P3 (these being detected
and used by CGILIB), and are of no interest to this function.
*/
void GetParameters ()
{
static char CommandLine [1024];
static unsigned long Flags = 0;
int status,
SkipParameters;
unsigned short Length;
char ch;
char *aptr, *cptr, *clptr, *sptr;
$DESCRIPTOR (CommandLineDsc, CommandLine);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "GetParameters()\n");
if ((clptr = getenv ("PROXYMUNGE$PARAM")) == NULL)
{
/* get the entire command line following the verb */
if (VMSnok (status =
lib$get_foreign (&CommandLineDsc, 0, &Length, &Flags)))
exit (status);
(clptr = CommandLine)[Length] = '\0';
}
/* if OSU environment then skip P1, P2, P3 */
if (getenv ("WWWEXEC_RUNDOWN_STRING") != NULL)
SkipParameters = 3;
else
SkipParameters = 0;
aptr = NULL;
ch = *clptr;
for (;;)
{
if (aptr != NULL && *aptr == '/') *aptr = '\0';
if (!ch) break;
*clptr = ch;
if (Debug) fprintf (stdout, "clptr |%s|\n", clptr);
while (*clptr && isspace(*clptr)) *clptr++ = '\0';
aptr = clptr;
if (*clptr == '/') clptr++;
while (*clptr && !isspace (*clptr) && *clptr != '/')
{
if (*clptr != '\"')
{
clptr++;
continue;
}
cptr = clptr;
clptr++;
while (*clptr)
{
if (*clptr == '\"')
if (*(clptr+1) == '\"')
clptr++;
else
break;
*cptr++ = *clptr++;
}
*cptr = '\0';
if (*clptr) clptr++;
}
ch = *clptr;
if (*clptr) *clptr = '\0';
if (Debug) fprintf (stdout, "aptr |%s|\n", aptr);
if (!*aptr) continue;
if (SkipParameters)
{
SkipParameters--;
continue;
}
if (strsame (aptr, "/DBUG", -1))
{
Debug = TRUE;
continue;
}
if (strsame (aptr, "/SOFTWAREID", 4) ||
strsame (aptr, "/VERSION", 4))
{
fprintf (stdout, "%%%s-I-SOFTWAREID, %s\n%s\n",
Utility, SoftwareEnv, SoftwareCopy);
exit (SS$_NORMAL);
}
#if OPENSSL_SINCE_110
if (strsame (aptr, "/TLS1", -1))
{
CliTLSv1 = TRUE;
continue;
}
if (strsame (aptr, "/TLS11", -1))
{
CliTLSv11 = TRUE;
continue;
}
if (strsame (aptr, "/TLS12", -1))
{
CliTLSv12 = TRUE;
continue;
}
#if OPENSSL_SINCE_111
if (strsame (aptr, "/TLS13", -1))
{
CliTLSv13 = TRUE;
continue;
}
#endif
#endif
#if OPENSSL_BEFORE_110
if (strsame (aptr, "/SSLV23", -1))
{
CliSSLv23 = TRUE;
continue;
}
#endif
if (strsame (aptr, "/WATCH", 4))
{
WatchEnabled = TRUE;
continue;
}
if (*aptr == '/')
{
fprintf (stdout, "%%%s-E-IVQUAL, unrecognized qualifier\n \\%s\\\n",
Utility, aptr+1);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
fprintf (stdout, "%%%s-E-MAXPARM, too many parameters\n \\%s\\\n",
Utility, aptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
}
/*****************************************************************************/