[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]
/*****************************************************************************/
/*
wsb.c
WebSocket test-bench and gremlin inducing client.
This command-line program is designed to test and exercise the WASD WebSocket
environment during development. It also reports on data transfered per second
and so can be used to metric the raw throughput of a given WASD WebSocket
environment and platform. This utility uses the client-specific functionality
of the WSLIBCL.C library as well as the standard WebSockets support of WSLIB.C
The complementary WebSocket server (script, application) is WS_BENCH.C.
This utility is not intended to be a paradigm of WebSocket programming virtue.
It is a pragmatic test-bench and while it might be preferable to have some
independent, reference test-bench, back here in mid-2011 as the RFC begins to
gel (again) there is precious little available. At least WASD will have
consistent implementation quirks :-)
The three primary functions implementing test behaviour are; ClientToServer()
performing the client-end writes, ServerToClient() supplying the processing of
reads from the server responses, and PushToServer() proving random-interval
writes to the server.
The WSB (and wsLIB) can only handle messages sizes up to 4GB (not the
full 63 bit size permitted by WebSocket protocol). It is also better to send
multiple smaller messages rather than one humungous one because the WSB
allocates message memory before filling it appropriately (and allocating 4GB
*might* take a relative while).
ECHO TEST
---------
The client utility simply generates frames of the specified length and content
and type and sends them to the server. The server echoes these frames back to
the client (first UTF-8 to ASCII decoding then ASCII to UTF-8 encoding text)
where it is compared to what has been sent. Errors are reported.
PUSH TEST
---------
Both the client and send send unsolicited frames to each other at random
intervals (from 50mS to 1600mS) containing the specified length and content
type. The receiving entity then echos these back ina frame for comparison
checking by the sender.
PING/PONG TEST
--------------
The /PING and /PONG qualifiers cause server and client agents to ping each
other at random intervals during other test sequences.
USAGE EXAMPLES
--------------
$ WSB == "$WASD_EXE:WSB"
$ WSB /DO=ECHO /NUMBER=1000 /CONCURRENT=50 /QBF /REPEAT=100
Sends one thousand requests, fifty at a time, sending "The quick brown fox ..."
one hundred times to the server (UTF-8 encoded, though is really only 7 bit
ASCII) each of which is decoded and then reencoded and sent it back where the
client compares that echo.
$ WSB /DO=ECHO /NUMBER=1000 /CONCURRENT=10 /BINARY /REPEAT=500 /BREAK
Sends one thousand requests, ten at a time, sending randomly generated binary
content to the server five hundred times, which echos it back and the client
reporting any discrepancy. Connections are broken randomly during each
transaction to test resiliancy of WASD and server script/library.
$ WSB /DO=PUSH /NUMBER=100 /CONCURRENT=10 /REPEAT=500 /SIZE=64K /TEXT /PING
Sends one hundred requests, ten at a time, each sending fifty mssages of
sixty-four kilobytes, both the client and server each asynchronously sending
randomly generated UTF-8 text content, at random intervals, which the other
echos back and the server reporting any discrepancy. It generates asynchronous
traffic in both directions. In addition ping frames are sent from client to
server at random intervals and any non-pong response notified.
PLATFORM THROUGHPUT METRIC
--------------------------
Measure of raw message and byte throughput for a series of messages of various
sizes can provide useful information on the underlying maximum messaging
characteristics of a given WASD/VMS platform. Data traverses the full
WSB -> TCP/IP -> WASD -> script/application -> WASD -> TCP/IP -> WSB
communication and IPC pathways. Of course this may also be performed between
autonomous VMS platforms in which case it also includes the physical network.
$ WSB /DO=ECHO /THROUGHPUT /REPEAT=1000 /SIZE=0
$ WSB /DO=ECHO /THROUGHPUT /REPEAT=1000 /SIZE=16
$ WSB /DO=ECHO /THROUGHPUT /REPEAT=1000 /SIZE=64
$ WSB /DO=ECHO /THROUGHPUT /REPEAT=1000 /SIZE=256
$ WSB /DO=ECHO /THROUGHPUT /REPEAT=1000 /SIZE=1024
$ WSB /DO=ECHO /THROUGHPUT /REPEAT=1000 /SIZE=65K
The /THROUGHPUT qualifier sends WebSocket binary messages but DOES NOT fill
those messages with any specific data (it remains as zeroes). This saves the
overhead of buffer filling and allows more of the system's resources to be
devoted to the transferring data. Of course the same test can be undertaken
using /BINARY, /QBF and /TEXT data (with expected and observed reduced
throughput metrics).
QUALIFIERS
----------
/BINARY send random data as binary frames
/BREAK[=<integer>] randomly break connection at one in <integer> (default 5%)
/BRIEF brief statistics
/CONCURRENT= number of concurrent runs (default 1)
/COUNT= total number of individual requests (synonym for /NUMBER)
/DYNAMIC dynamically allocated buffers
/DO=ECHO echo various contents
/DO=PING send a standalone PING to the server
/DO=PONG send a standalone, unsolicited PONG to the server
/DO=PUSH asynchronous push content in both directions
/HEARTBEAT=<integer> add periodic ping to the mix at the specified seconds
/MRS=<integer> allows the maximum record size of the socket to be specified
/NUMBER= total number of individual requests (default 1)
/PING add PING frames randomly to the test
/PONG add unsolicited PONG and server PING/PONGs into the mix
/PROXY=<string> make a proxied WebSocket request
/RANDOM=<integer> random events occur at one in <integer> (default 5%)
/REPEAT= <integer> number of messages within the request (default 1)
/SIZE=<integer> message size in bytes (can use 'G', 'M', or 'k')
/QBF send 'quick brown fox' as text frames (7 bit ASCII)
/[NO]STAGGER initial connections staggered one after the other (default)
/TEXT send strings of the characters 0..255 as text frames (UTF-8)
/THROUGHPUT send whatever's in the buffer as binary data
COPYRIGHT
---------
Copyright (C) 2011-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!)
---------------
05-FEB-2012 MGD v1.1.0, guess what a proxied request might look like
25-JUN-2011 MGD v1.0.0, initial development (happy birthday Sis)
*/
/*****************************************************************************/
#define SOFTWAREVN "1.1.0"
#define SOFTWARENM "WSB"
#ifdef __ALPHA
# define SOFTWAREID SOFTWARENM " AXP-" SOFTWAREVN
#endif
#ifdef __ia64
# define SOFTWAREID SOFTWARENM " IA64-" SOFTWAREVN
#endif
#ifdef __VAX
# define SOFTWAREID SOFTWARENM " VAX-" SOFTWAREVN
#endif
#ifdef __x86_64
# define SOFTWAREID SOFTWARENM " X86-" SOFTWAREVN
#endif
#define COPYRIGHT_DATES "2011-2020"
#define COPYRIGHT_FULL \
"Copyright (C) 2011,2012 Mark G.Daniel\n\
This program, comes with ABSOLUTELY NO WARRANTY.\n\
This is free software, and you are welcome to redistribute it under the\n\
conditions of the GNU GENERAL PUBLIC LICENSE, version 3, or later version.\n\
http://www.gnu.org/licenses/gpl.txt\n"
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unixio.h>
/* VMS related header files */
#include <descrip.h>
#include <iosbdef.h>
#include <libclidef.h>
#include <libdef.h>
#include <libdtdef.h>
#include <lib$routines.h>
#include <ssdef.h>
#include <stsdef.h>
#include <starlet.h>
#include <syidef.h>
#include "wslib.h"
#define BOOL int
#define TRUE 1
#define FALSE 0
/* this definition is not available in older VMS versions */
#ifndef EFN$C_ENF
# define EFN$C_ENF 128 /* Event No Flag (no stored state) */
#endif
#ifndef SS$_FISH
# define SS$_FISH 2928 /* for earlier VAXen */
#endif
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define DEFAULT_BUFFER_SIZE 80
#define DEFAULT_BREAK 20 /* one in twenty (~5%) */
#define DEFAULT_RANDOM 20 /* one in twenty (~5%) */
#define DEFAULT_READ_BUFFER_SIZE 16384
#define DEFAULT_SERVER_PORT 80
#define DEFAULT_ECHO_CHUNK 1024
#define MAX_CONNECTION_ERROR_COUNT 30
#define HEARTBEAT_AT 100
/* lib$cvtf_from_internal_time() complains about about a zero elapsed time! */
#define LIB$_DELTIMREQ 1410052
/* mainly to allow easy use of the __unaligned directive */
#define ULONGPTR __unaligned unsigned long*
#define USHORTPTR __unaligned unsigned short*
#define INT64PTR __unaligned __int64*
#define EXIT_LINE(status) { printf ("[WSB:%d]", __LINE__); exit(status); }
#define QUAD_TO_FLOAT(lptr) \
((float)(((unsigned long*)lptr)[0]) + \
(float)(((unsigned long*)lptr)[1]) * 4294967295.0)
struct ConnectionStruct
{
int ContentCount,
ContentLength,
ConnectNumber,
CountDown,
FrameHeaderLength,
PayloadLength,
PayloadCount,
PingBufferCount,
PushCount,
PushTimerId,
ReadBufferCount,
ReadBufferSize,
WebCloseHandshake,
WebSocketVersion,
WriteBufferCount,
WriteBufferSize;
unsigned short Channel;
unsigned char FrameHeader [2+2+6];
char HttpHeader [256],
PingBuffer [256],
WebSocketUrl,
WebSocketHost;
char *ReadBufferPtr,
*WriteBufferPtr;
struct _iosb SocketIOsb,
ReadIOsb,
WriteIOsb;
struct WsLibStruct *WsLibPtr;
};
char Utility [] = "WSB";
unsigned long CvtTimeFloatSeconds = LIB$K_DELTA_SECONDS_F;
BOOL Debug,
CliBinaryFrame,
CliBreak,
CliBrief,
CliDynamic,
CliQbfFrame,
CliTextFrame,
CliPing,
CliPong,
CliStagger = TRUE,
CliThroughPut,
DoEcho,
DoPing,
DoPong,
DoPush,
DoShowHelp,
DoShowVersion;
int BreakRequestCount,
BreakResponseCount,
BreakRequestLast,
BreakResponseLast,
CliBufferSize = DEFAULT_BUFFER_SIZE,
CliConcurrency = 1,
CliCount = 1,
CliHeartBeat = 0,
CliSocketMrs = 0,
CliNumber = 1,
CliRandom = DEFAULT_RANDOM,
ClientPingCount,
ClientPongCount,
ConcurrentCount,
ConnectionCount,
ConnectionErrorCount,
EfnEnf = EFN$C_ENF,
FailedRequestCount,
HeartBeatAt = HEARTBEAT_AT,
HttpProtocol = 11,
HttpReadErrorCount,
PongOkCount,
ReadBufferSize,
RequestCount,
ResponseErrorCount,
ServerPort,
ServerPingCount,
ServerPongCount,
ServerPongFailCount,
TotalBytesSent,
WebSocketErrorCount,
WebSocketProtocolVersion = 8;
unsigned long ReadTotal [2],
ReadMsgTotal [2],
WriteTotal [2],
WriteMsgTotal [2];
char *CliProxyServer,
*RequestUriPtr;
char CloseAdieu [128],
CommandLine [256],
ServerHost [256],
ServerSoftware [256],
RequestUri [256];
extern int WsLibClBreakCount,
WsLibClBreakEvery;
/* function prototypes */
void BinaryFill (char*, int);
char* BytesPerSecond (float);
char* BytesOf (float);
void ClientToServer (struct WsLibStruct*);
void CloseConnection (struct WsLibStruct*);
void ConnectionAst (struct WsLibStruct*);
void ConnectToServer ();
float DurationSeconds (unsigned long*);
void GetParameters (int, char**);
void MessageCallback (struct WsLibStruct*);
void ParseURL ();
void PongCallback (struct WsLibStruct*);
void PushEvent (struct ConnectionStruct*);
void PushServer (struct ConnectionStruct*);
void QbfFill (char*, int);
BOOL RandomEvent ();
void ServerReadAst (struct WsLibStruct*);
void ServerToClient (struct WsLibStruct*);
void ServerWriteAst (struct WsLibStruct*);
void ShowHelp ();
int strsame (char*, char*, int);
void UpdateTotals (struct WsLibStruct*);
void Utf8Fill (char*, int);
/*****************************************************************************/
/*
*/
int main
(
int argc,
char *argv[]
)
{
static char SyiVersion [8];
static struct
{
short buf_len;
short item;
char *buf_addr;
short *short_ret_len;
}
SyiItem [] =
{
{ sizeof(SyiVersion), SYI$_VERSION, (char*)&SyiVersion, 0 },
{ 0,0,0,0 }
};
int cnt, status,
VmsVersion;
float BytesFloat = 0.0,
ReadFloat,
ReadMsgFloat,
SecsFloat,
WriteFloat,
WriteMsgFloat;
char *cptr, *sptr, *uptr, *zptr;
/*********/
/* begin */
/*********/
if (getenv("WSB$DBUG")) Debug = TRUE;
GetParameters (argc, argv);
if (Debug) setenv ("WATCH_SCRIPT", "*", 1);
if (DoShowVersion)
{
fprintf (stdout, "%%%s-I-VERSION, %s\n%s",
Utility, SOFTWAREID, COPYRIGHT_FULL);
exit (SS$_NORMAL);
}
if (DoShowHelp) ShowHelp ();
sprintf (CloseAdieu, "%s bids adieu!", SOFTWAREID);
if (VMSnok (status = sys$getsyi (0, 0, 0, &SyiItem, 0, 0, 0)))
exit (status);
VmsVersion = ((SyiVersion[1]-48) * 10) + (SyiVersion[3]-48);
if (Debug) fprintf (stdout, "VmsVersion: %d\n", VmsVersion);
if (VmsVersion < 70) EfnEnf = 0;
/* at each count there is an opportunity so ... */
if (CliBreak)
{
CliBreak *= CliCount;
WsLibClBreakEvery = CliBreak;
}
ParseURL ();
uptr = RequestUri;
if (cptr = CliProxyServer)
{
/* make it a proxied request */
uptr += sprintf (RequestUri, "http://%s:%d", ServerHost, ServerPort);
/* change the connected-to host and port */
sptr = ServerHost;
while (*cptr && *cptr != ':' && *cptr != '/') *sptr++ = *cptr++;
*sptr = '\0';
if (*cptr++ == ':')
if (isdigit(*cptr)) ServerPort = atoi(cptr);
}
if (DoEcho)
{
sprintf (uptr, "/cgiplus-bin/ws_bench?do=echo&size=%d%s%s",
CliDynamic ? 0 : CliBufferSize,
CliPing ? "&ping=20" : "",
CliPong ? "&pong=20" : "");
RequestUriPtr = RequestUri;
}
else
if (DoPush)
{
sprintf (uptr, "/cgiplus-bin/ws_bench?do=push&size=%d%s%s",
CliDynamic ? 0 : CliBufferSize,
CliPing ? "&ping=20" : "",
CliPong ? "&pong=20" : "");
RequestUriPtr = RequestUri;
}
else
if (DoPing || DoPong)
{
sprintf (uptr, "/cgiplus-bin/ws_bench?do=%s&size=%d",
DoPing ? "ping" : "pong",
CliDynamic ? 0 : CliBufferSize);
RequestUriPtr = RequestUri;
}
else
exit (SS$_NORMAL);
/******/
/* go */
/******/
DurationSeconds (NULL);
if (CliStagger)
{
/* connections to the server will be one after the other */
ConnectToServer ();
}
else
{
/* this throws the concurrent total at the server at once! */
sys$setast (0);
for (cnt = 0; cnt < CliConcurrency; cnt++)
{
status = sys$dclast (&ConnectToServer, 0, 0);
if (VMSnok (status)) EXIT_LINE (status);
}
sys$setast (1);
}
sys$hiber ();
SecsFloat = DurationSeconds (NULL);
/*********/
/* stats */
/*********/
fprintf (stdout, "%%%s-I-STATS, %d total connections\n",
Utility, ConnectionCount);
if (CliBreak)
fprintf (stdout, "%d broken connections\n",
WsLibClBreakCount);
if (DoPing || CliPing)
fprintf (stdout,
"%d client pings, %d server pongs, %d server pings\n",
ClientPingCount, ServerPongCount, ServerPingCount);
if (CliBrief) exit (SS$_NORMAL);
ReadFloat = QUAD_TO_FLOAT(&ReadTotal);
ReadMsgFloat = QUAD_TO_FLOAT(&ReadMsgTotal);
WriteFloat = QUAD_TO_FLOAT(&WriteTotal);
WriteMsgFloat = QUAD_TO_FLOAT(&WriteMsgTotal);
fprintf (stdout, "Duration: %.3f seconds\n", SecsFloat);
fprintf (stdout, "Tx: %.0f msgs at %.0f/S, %s at %s\n",
WriteMsgFloat, WriteMsgFloat/SecsFloat,
BytesOf(WriteFloat), BytesPerSecond(WriteFloat/SecsFloat));
fprintf (stdout, "Rx: %.0f msgs at %.0f/S, %s at %s\n",
ReadMsgFloat, ReadMsgFloat/SecsFloat,
BytesOf(ReadFloat), BytesPerSecond(ReadFloat/SecsFloat));
fprintf (stdout, "Total: %.0f msgs at %.0f/S, %s at %s\n",
WriteMsgFloat+ReadMsgFloat, (WriteMsgFloat+ReadMsgFloat)/SecsFloat,
BytesOf(WriteFloat+ReadFloat),
BytesPerSecond((WriteFloat+ReadFloat)/SecsFloat));
exit (SS$_NORMAL);
}
/*****************************************************************************/
/*
Loop through the specified number of connections (or attempts thereof).
Maintain, as best it can be, the specified number of simultaneous connections.
If a connection attempt fails just quit there for that particular loop, leave
a bit of time (as reads occur) to allow the server to recover.
*/
void ConnectToServer ()
{
int status;
struct ConnectionStruct *cxptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ConnectToServer()\n");
if (ConnectionCount >= CliNumber)
{
/* reached the total number of requests */
if (!ConcurrentCount) sys$wake (0, 0);
return;
}
ConnectionCount++;
ConcurrentCount++;
if (HeartBeatAt && !(ConnectionCount % HeartBeatAt))
fprintf (stdout, "Completed %d requests\n", ConnectionCount);
/* init connection structure */
cxptr = calloc (1, sizeof(struct ConnectionStruct));
if (!cxptr) EXIT_LINE (vaxc$errno);
cxptr->ConnectNumber = ConnectionCount;
cxptr->CountDown = CliCount;
cxptr->WriteBufferSize = CliBufferSize;
/* allocate some buffer size even for a zero-sized payload */
cxptr->WriteBufferPtr = calloc (1, cxptr->WriteBufferSize+256);
if (!cxptr->WriteBufferPtr) EXIT_LINE (vaxc$errno);
cxptr->ReadBufferSize = cxptr->WriteBufferSize;
cxptr->ReadBufferPtr = calloc (1, cxptr->ReadBufferSize);
if (!cxptr->ReadBufferPtr) EXIT_LINE (vaxc$errno);
cxptr->WsLibPtr = WsLibCreate (cxptr, &CloseConnection);
if (CliSocketMrs) WsLibClSetSocketMrs (cxptr->WsLibPtr, CliSocketMrs);
WsLibSetRoleClient (cxptr->WsLibPtr);
WsLibSetMsgCallback (cxptr->WsLibPtr, &MessageCallback);
/* maxiumum of five seconds without received data */
WsLibSetReadSecs (cxptr->WsLibPtr, 5);
WsLibSetPongCallback (cxptr->WsLibPtr, &PongCallback);
if (CliHeartBeat) WsLibSetPingSecs (cxptr->WsLibPtr, CliHeartBeat);
status = WsLibClConnect (cxptr->WsLibPtr,
ServerHost, ServerPort, RequestUri,
&ConnectionAst);
if (Debug) fprintf (stdout, "WsLibClConnect() %%X%08.08X\n", status);
}
/****************************************************************************/
/*
Connection to server has been established (or not).
*/
void ConnectionAst (struct WsLibStruct *wsptr)
{
int status;
struct ConnectionStruct *cxptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ConnectionAst()\n");
cxptr = WsLibGetUserData (wsptr);
if (VMSnok (wsptr->SocketIOsb.iosb$w_status))
{
/* connect failed */
EXIT_LINE (wsptr->SocketIOsb.iosb$w_status);
}
if (CliStagger)
{
if (ConcurrentCount < CliConcurrency)
{
/* initiate the next serial connection */
status = sys$dclast (&ConnectToServer, 0, 0);
if (VMSnok (status)) EXIT_LINE (status);
}
}
/* begin to interact with the server (WebSocket) application */
ClientToServer (wsptr);
}
/****************************************************************************/
/*
Request is concluded.
*/
void CloseConnection (struct WsLibStruct *wsptr)
{
int status;
struct ConnectionStruct *cxptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "CloseConnection()\n");
cxptr = WsLibGetUserData (wsptr);
if (cxptr->PushTimerId) sys$cantim (cxptr->PushTimerId, 0);
UpdateTotals (wsptr);
WsLibDestroy (wsptr);
if (cxptr->WriteBufferPtr) free (cxptr->WriteBufferPtr);
if (cxptr->ReadBufferPtr) free (cxptr->ReadBufferPtr);
free (cxptr);
if (ConcurrentCount) ConcurrentCount--;
/* replace the just-closed connection (unless limits reached) */
ConnectToServer ();
}
/****************************************************************************/
/*
Write a frame from the client to the server (WS_BENCH.C) which does the
complementary processing and writes the result(s) back, this being processed
in ServerToClient() below.
*/
void ClientToServer (struct WsLibStruct *wsptr)
{
int status;
struct ConnectionStruct *cxptr;
struct WsLibFrmStruct *frmptr;
struct WsLibMsgStruct *msgptr;
/*********/
/* begin */
/*********/
cxptr = WsLibGetUserData (wsptr);
if (Debug) fprintf (stdout, "ClientToServer() %d\n", cxptr->CountDown);
if (WsLibIsClosed (wsptr)) return;
if (VMSnok (status = WsLibClSocketStatus (wsptr)))
{
cxptr->CountDown = 0;
fprintf (stdout, "%%%s-W-CONNECT, [%d] #%d failed (%%X%08.08X)\n",
Utility, __LINE__, cxptr->ConnectNumber, status);
}
if (WsLibClBreakNow (wsptr)) return;
if (!cxptr->CountDown)
{
WsLibClose (wsptr, WSLIB_CLOSE_NORMAL, CloseAdieu);
return;
}
cxptr->WriteBufferCount = CliBufferSize;
if ((DoPing || DoPong) ||
((CliPing || CliPong) && RandomEvent()))
{
if (cxptr->WriteBufferSize > sizeof(cxptr->PingBuffer))
cxptr->PingBufferCount = sizeof(cxptr->PingBuffer);
else
cxptr->PingBufferCount = cxptr->WriteBufferSize;
if (CliBinaryFrame)
BinaryFill (cxptr->PingBuffer, cxptr->PingBufferCount);
else
if (CliTextFrame)
Utf8Fill (cxptr->PingBuffer, cxptr->PingBufferCount);
else
if (CliQbfFrame)
QbfFill (cxptr->PingBuffer, cxptr->PingBufferCount);
/* else /throughput is in the buffer! */
if (DoPing || CliPing)
WsLibPing (wsptr,
cxptr->PingBuffer,
cxptr->PingBufferCount);
/* expect to see this at server end but without any response to client */
if (DoPong || CliPong)
WsLibPong (wsptr,
cxptr->PingBuffer,
cxptr->PingBufferCount);
if (DoPing || CliPing)
ClientPingCount++;
else
ClientPongCount++;
}
else
if (DoEcho)
{
if (CliBinaryFrame)
{
WsLibSetBinary (wsptr);
BinaryFill (cxptr->WriteBufferPtr, cxptr->WriteBufferCount);
}
else
if (CliTextFrame)
{
/* at server UTF-8 will be converted to ASCII and then back again */
WsLibSetUtf8 (wsptr);
Utf8Fill (cxptr->WriteBufferPtr, cxptr->WriteBufferCount);
}
else
if (CliQbfFrame)
{
/* brown foxes are only 7 bit ASCII */
WsLibSetUtf8 (wsptr);
QbfFill (cxptr->WriteBufferPtr, cxptr->WriteBufferCount);
}
/* else /throughput is in the buffer! */
WsLibWrite (wsptr,
cxptr->WriteBufferPtr,
cxptr->WriteBufferCount,
ServerWriteAst);
}
else
if (DoPush)
{
/* if the first call then initiate server push */
if (!cxptr->PushTimerId) PushServer (cxptr);
}
/* read next frame */
WsLibRead (wsptr,
cxptr->ReadBufferPtr,
cxptr->ReadBufferSize,
ServerReadAst);
WsLibClBreakNow (wsptr);
}
/****************************************************************************/
/*
The server (WS_BENCH.C) has processed what was sent by ClientToServer() and
sent it back to the client for checking. When processed sent next to server.
*/
void ServerToClient (struct WsLibStruct *wsptr)
{
int ClientCount,
ServerCount;
struct ConnectionStruct *cxptr;
/*********/
/* begin */
/*********/
cxptr = WsLibGetUserData (wsptr);
if (Debug) fprintf (stdout, "ServerToClient() %d\n", cxptr->CountDown);
if (WsLibIsClosed (wsptr)) return;
if (!cxptr->CountDown--)
{
WsLibClose (wsptr, WSLIB_CLOSE_NORMAL, CloseAdieu);
return;
}
if (WsLibClBreakNow (wsptr)) return;
cxptr->ReadBufferCount = WsLibReadCount (wsptr);
if (DoEcho)
{
if ((CliBinaryFrame && !WsLibReadIsBinary(wsptr)) ||
(CliTextFrame && !WsLibReadIsText(wsptr)) ||
(CliQbfFrame && !WsLibReadIsText(wsptr)) ||
(CliThroughPut && !WsLibReadIsBinary(wsptr)) ||
cxptr->WriteBufferCount != WsLibReadCount(wsptr) ||
memcmp (cxptr->ReadBufferPtr,
cxptr->WriteBufferPtr,
cxptr->WriteBufferCount))
{
fprintf (stdout,
"%%%s-W-ECHO, [%d] #%d data mismatch\n",
Utility, __LINE__, cxptr->ConnectNumber);
goto ServerToClientShutdown;
}
}
else
if (DoPush)
{
if ((CliBinaryFrame && !WsLibReadIsBinary(wsptr)) ||
(CliTextFrame && !WsLibReadIsText(wsptr)) ||
(CliQbfFrame && !WsLibReadIsText(wsptr)) ||
(CliThroughPut && !WsLibReadIsBinary(wsptr)) ||
cxptr->ReadBufferCount != cxptr->WriteBufferCount)
{
fprintf (stdout, "%%%s-W-PUSH, [%d] #%d data mismatch (%s)\n",
Utility, __LINE__, cxptr->ConnectNumber,
cxptr->WriteBufferPtr);
goto ServerToClientShutdown;
}
if (memcmp (cxptr->ReadBufferPtr+24,
cxptr->WriteBufferPtr+24,
cxptr->WriteBufferCount-24))
{
/* but ignore slightly stale data */
sscanf (cxptr->ReadBufferPtr, "C:%d S:%d", &ClientCount, &ServerCount);
if (ClientCount+1 != cxptr->PushCount)
{
fprintf (stdout, "%%%s-W-PUSH, [%d] #%d data mismatch |%s|%s|\n",
Utility, __LINE__, cxptr->ConnectNumber,
cxptr->WriteBufferPtr, cxptr->ReadBufferPtr);
goto ServerToClientShutdown;
}
}
}
WsLibClBreakNow (wsptr);
ClientToServer (wsptr);
return;
ServerToClientShutdown:
FailedRequestCount++;
WsLibClose (wsptr, WSLIB_CLOSE_NORMAL, CloseAdieu);
return;
}
/*****************************************************************************/
/*
Push content to the server at pseudo-random intervals between approximately
100mS and 3200mS. Client can change content at any time.
*/
void PushServer (struct ConnectionStruct *cxptr)
{
static int RandomNumber,
RandomFiller;
int len, status;
unsigned long DeltaTime [2];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "PushServer() %d\n", cxptr);
if (WsLibIsClosed (cxptr->WsLibPtr)) return;
cxptr->PushTimerId = (int)cxptr;
if (DoPush)
{
/* change the pushed content (first 24 bytes are reserved) */
memset (cxptr->WriteBufferPtr, '_', 24);
/* update number from client */
len = sprintf (cxptr->WriteBufferPtr, "C:%d", ++cxptr->PushCount);
cxptr->WriteBufferPtr[len] = '_';
/* fill the remainder with "data" */
if (CliQbfFrame)
{
QbfFill (cxptr->WriteBufferPtr+24, cxptr->WriteBufferCount-24);
WsLibSetAscii (cxptr->WsLibPtr);
}
else
if (CliTextFrame)
{
Utf8Fill (cxptr->WriteBufferPtr+24, cxptr->WriteBufferCount-24);
WsLibSetUtf8 (cxptr->WsLibPtr);
}
else
{
BinaryFill (cxptr->WriteBufferPtr+24, cxptr->WriteBufferCount-24);
WsLibSetBinary (cxptr->WsLibPtr);
}
WsLibWrite (cxptr->WsLibPtr,
cxptr->WriteBufferPtr,
cxptr->WriteBufferCount,
NULL);
}
/* 100mS to 3200ms */
if (!RandomNumber) sys$gettim (&RandomNumber);
RandomNumber = RandomNumber * 69069 + 1;
DeltaTime[0] = -1000000 * ((RandomNumber & 31) + 1);
DeltaTime[1] = -1;
status = sys$setimr (0, &DeltaTime, PushServer, cxptr, 0);
if (VMSnok(status)) EXIT_LINE (status);
}
/****************************************************************************/
/*
*/
void ServerReadAst (struct WsLibStruct *wsptr)
{
int status;
struct ConnectionStruct *cxptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ServerReadAst()\n");
if (VMSnok (status = WsLibReadStatus(wsptr)))
{
/* WEBSOCKET_INPUT read error (can be EOF) */
if (Debug) fprintf (stdout, "%%X%08.08X\n", status);
WsLibClose (wsptr, WSLIB_CLOSE_BANG, NULL);
return;
}
cxptr = WsLibGetUserData (wsptr);
ServerToClient (wsptr);
}
/****************************************************************************/
/*
*/
void ServerWriteAst (struct WsLibStruct *wsptr)
{
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "ServerWriteAst()\n");
}
/****************************************************************************/
/*
Using PRNG data to trigger "random" events at the specified proportion.
*/
int RandomEvent ()
{
static int RandomNumber,
RandomFiller;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "RandomEvent()\n");
if (!RandomNumber) sys$gettim (&RandomNumber);
RandomNumber = RandomNumber * 69069 + 1;
if (RandomNumber % CliRandom) return (FALSE);
return (TRUE);
}
/*****************************************************************************/
/*
Parse the CLI specified URL into it's host-name (and resolved address), port
and path.
*/
void ParseURL ()
{
int status;
char *cptr, *sptr;
/*********/
/* begin */
/*********/
cptr = RequestUriPtr;
if (strsame (cptr, "ws://", 5))
{
cptr += 5;
sptr = ServerHost;
while (*cptr && *cptr != ':' && *cptr != '/') *sptr++ = *cptr++;
*sptr = '\0';
if (*cptr == ':')
{
cptr++;
if (isdigit(*cptr)) ServerPort = atoi(cptr);
while (*cptr && isdigit(*cptr)) cptr++;
}
RequestUriPtr = cptr;
}
if (!ServerHost[0])
{
/* assume the local host is the server */
gethostname (ServerHost, sizeof(ServerHost));
if (Debug) fprintf (stdout, "ServerHost |%s|\n", ServerHost);
}
if (!ServerPort) ServerPort = 80;
}
/****************************************************************************/
/*
Fill the specified buffer with PRNG octets.
*/
void BinaryFill
(
char *BufferPtr,
int BufferSize
)
{
static unsigned long RandomNumber,
GetTimFiller;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "BinaryFill()\n");
if (!RandomNumber) sys$gettim (&RandomNumber);
zptr = (sptr = BufferPtr) + BufferSize;
while (sptr < zptr)
{
RandomNumber = RandomNumber * 69069 + 1;
cptr = (char*)&RandomNumber;
*sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr;
}
}
/****************************************************************************/
/*
Fill the buffer with UTF-8 strings of the 8 bit characters 0..255.
*/
void Utf8Fill
(
char *BufferPtr,
int BufferSize
)
{
unsigned char ch = 0;
unsigned char *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "Utf8Fill()\n");
zptr = (sptr = (unsigned char*)BufferPtr) + BufferSize;
while (sptr < zptr)
{
if (ch & 0x80)
{
if (sptr+1 >= zptr) break;
*sptr++ = ((ch & 0xc0) >> 6) | 0xc0;
*sptr++ = (ch & 0x3f) | 0x80;
}
else
*sptr++ = ch;
if (++ch > 255) ch = 0;
}
while (sptr < zptr) *sptr++ = '\0';
}
/****************************************************************************/
/*
Fill the specified buffer with brown foxes.
*/
void QbfFill
(
char *BufferPtr,
int BufferSize
)
{
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "QbfFill()\n");
cptr = "";
zptr = (sptr = BufferPtr) + BufferSize;
while (sptr < zptr)
{
if (!*cptr) cptr = "The quick brown fox jumps over the lazy dog.\n";
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
}
}
/****************************************************************************/
/*
Called each time wsLIB receives a pong from the server application.
*/
void PongCallback (struct WsLibStruct *wsptr)
{
struct ConnectionStruct *cxptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "PongCallback()\n");
cxptr = WsLibGetUserData (wsptr);
ServerPongCount++;
if (DoPing || DoPong)
{
if (cxptr->CountDown-- <= 1)
{
WsLibClose (wsptr, WSLIB_CLOSE_NORMAL, CloseAdieu);
return;
}
}
}
/****************************************************************************/
/*
Display non-informational messages output by the wsLIB library.
*/
void MessageCallback (struct WsLibStruct *wsptr)
{
int status = SS$_FISH;
char *cptr;
struct ConnectionStruct *cxptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "MessageCallback()\n");
cxptr = WsLibGetUserData (wsptr);
cptr = WsLibMsgString (wsptr);
if (*(USHORTPTR)cptr == '%X') status = strtol(cptr+2,NULL,16);
/* if informational */
if (status & 1) return;
if (status == SS$_VCCLOSED) return;
fprintf (stdout,
"%%%s-W-WSLIB, [#%d] msg callback (WSLIB line %d)\n \\%s\\\n",
Utility, cxptr->ConnectNumber,
WsLibMsgLineNumber(wsptr), cptr);
}
/****************************************************************************/
/*
Return a floating-point representation of the elapsed time. First call starts
the duration. Second call ends it, resets the duration, and returns the
floating point seconds. If no pointer to a duration quadword is supplied it
uses internal static storage. Alpha and IA64 expect CC/FLOAT=IEEE.
*/
float DurationSeconds (unsigned long *StartTimePtr)
{
static int LibDeltaSecs = LIB$K_DELTA_SECONDS_F;
static unsigned long StartTime [2];
int status;
unsigned long DeltaBinTime [2],
EndBinTime [2];
float SecsFloat;
/*********/
/* begin */
/*********/
if (!StartTimePtr) StartTimePtr = StartTime;
if (!(StartTimePtr[0] || StartTimePtr[1]))
{
sys$gettim (StartTimePtr);
return (0.0);
}
sys$gettim (EndBinTime);
status = lib$sub_times (&EndBinTime, StartTimePtr, &DeltaBinTime);
if (VMSnok (status)) exit (status);
StartTimePtr[0] = StartTimePtr[1] = 0;
#ifdef __ia64
status = lib$cvts_from_internal_time (&LibDeltaSecs, &SecsFloat,
&DeltaBinTime);
#else
status = lib$cvtf_from_internal_time (&LibDeltaSecs, &SecsFloat,
&DeltaBinTime);
# ifdef __ALPHA
/* lib$cvts_from_internal_time() does not exist with V7.3-2 or earlier */
# include <cvtdef.h>
# include <cvt$routines.h>
if (VMSok(status))
status = cvt$convert_float (&SecsFloat, CVT$K_VAX_F,
&SecsFloat, CVT$K_IEEE_S, 0);
# endif
#endif
if (VMSnok (status)) exit (status);
return (SecsFloat);
}
/****************************************************************************/
/*
Return a string with a suitable abbreviated bytes.
*/
char* BytesOf (float bytes)
{
static char BytesString [32];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "BytesOf() %f\n", bytes);
if (bytes >= 1000000000.0)
sprintf (BytesString, "%.1f Gbytes", bytes/1000000000.0);
else
if (bytes >= 1000000.0)
sprintf (BytesString, "%.1f Mbytes", bytes/1000000.0);
else
if (bytes >= 1000.0)
sprintf (BytesString, "%.1f kbytes", bytes/1000.0);
else
sprintf (BytesString, "%.0f bytes", bytes);
return (BytesString);
}
/****************************************************************************/
/*
Return a string with a suitable abbreviated bytes/second.
*/
char* BytesPerSecond (float bps)
{
static char BytesPerString [32];
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "BytesPerSecond() %f\n", bps);
if (bps >= 1000000000.0)
sprintf (BytesPerString, "%.1f GB/S", bps/1000000000.0);
else
if (bps >= 1000000.0)
sprintf (BytesPerString, "%.1f MB/S", bps/1000000.0);
else
if (bps >= 1000.0)
sprintf (BytesPerString, "%.1f kB/S", bps/1000.0);
else
sprintf (BytesPerString, "%.0f B/S", bps);
return (BytesPerString);
}
/****************************************************************************/
/*
Do just as the function name says!
*/
void UpdateTotals (struct WsLibStruct *wsptr)
{
int status;
unsigned long *ulptr;
struct ConnectionStruct *cxptr;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "UpdateTotals()\n");
cxptr = WsLibGetUserData (wsptr);
ulptr = WsLibReadTotal (wsptr);
#ifdef __VAX
lib$addx (ulptr, &ReadTotal, &ReadTotal, 0);
#else
*(__int64*)&ReadTotal = *(__int64*)&ReadTotal + *ulptr;
#endif
ulptr = WsLibReadMsgTotal (wsptr);
#ifdef __VAX
lib$addx (ulptr, &ReadMsgTotal, &ReadMsgTotal, 0);
#else
*(__int64*)&ReadMsgTotal = *(__int64*)&ReadMsgTotal + *ulptr;
#endif
ulptr = WsLibWriteTotal (wsptr);
#ifdef __VAX
lib$addx (ulptr, &WriteTotal, &WriteTotal, 0);
#else
*(__int64*)&WriteTotal = *(__int64*)&WriteTotal + *ulptr;
#endif
ulptr = WsLibWriteMsgTotal (wsptr);
#ifdef __VAX
lib$addx (ulptr, &WriteMsgTotal, &WriteMsgTotal, 0);
#else
*(__int64*)&WriteMsgTotal = *(__int64*)&WriteMsgTotal + *ulptr;
#endif
}
/*****************************************************************************/
/*
Get "command-line" parameters, whether from the command-line or from a
configuration symbol or logical containing the equivalent. This function has
been customized for this utility to allow it to be called multiple times during
the one use.
*/
void GetParameters
(
int argc,
char *argv[]
)
{
static char CommandLine [256];
static unsigned long Flags = 0;
int acnt, status;
unsigned short Length;
char ch;
char *aptr, *cptr, *clptr, *sptr;
$DESCRIPTOR (CommandLineDsc, CommandLine);
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "GetParameters() %d\n", argc);
/**************/
/* initialize */
/**************/
ReadBufferSize = DEFAULT_READ_BUFFER_SIZE;
ServerPort = DEFAULT_SERVER_PORT;
RequestUriPtr = "";
if (argc <= 1) return;
/* 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 (Debug) fprintf (stdout, "clptr |%s|\n", clptr);
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;
/**************/
/* parameters */
/**************/
if (strsame (aptr, "/BINARY", 4))
{
CliBinaryFrame = TRUE;
CliQbfFrame = CliTextFrame = CliThroughPut = FALSE;
continue;
}
if (strsame (aptr, "/BREAK=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliBreak = atoi(cptr);
if (!CliBreak) CliBreak = DEFAULT_BREAK;
if (CliBreak < 1) CliBreak = 1;
if (CliBreak > 100) CliBreak = 100;
continue;
}
if (strsame (aptr, "/BRIEF", -1))
{
CliBrief = TRUE;
continue;
}
if (strsame (aptr, "/CONCURRENCY=", 5))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliConcurrency = atoi(cptr);
continue;
}
if (strsame (aptr, "/COUNT=", 4) ||
strsame (aptr, "/NUMBER=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliNumber = atoi(cptr);
continue;
}
if (strsame (aptr, "/DBUG", -1))
{
Debug = TRUE;
continue;
}
if (strsame (aptr, "/DO=ECHO", 8))
{
DoEcho = TRUE;
continue;
}
if (strsame (aptr, "/DO=PING", 8))
{
DoPing = TRUE;
continue;
}
if (strsame (aptr, "/DO=PONG", 8))
{
DoPong = TRUE;
continue;
}
if (strsame (aptr, "/DO=PUSH", 8))
{
DoPush = TRUE;
continue;
}
if (strsame (aptr, "/DYNAMIC", 4))
{
CliDynamic = TRUE;
continue;
}
if (strsame (aptr, "/HEARTBEAT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliHeartBeat = atoi(cptr);
if (!CliHeartBeat) CliHeartBeat = 10;
continue;
}
if (strsame (aptr, "/HELP", 4))
{
DoShowHelp = TRUE;
continue;
}
if (strsame (aptr, "/MRS=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliSocketMrs = atoi(cptr);
continue;
}
if (strsame (aptr, "/PING", 4))
{
CliPing = TRUE;
continue;
}
if (strsame (aptr, "/PONG", 4))
{
CliPong = TRUE;
continue;
}
if (strsame (aptr, "/PROXY=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliProxyServer = cptr;
continue;
}
if (strsame (aptr, "/QBF", -1))
{
CliQbfFrame = TRUE;
CliBinaryFrame = CliTextFrame = CliThroughPut = FALSE;
continue;
}
if (strsame (aptr, "/RANDOM=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliRandom = atoi(cptr);
if (!CliRandom) CliRandom = DEFAULT_RANDOM;
if (CliRandom < 1) CliRandom = 1;
if (CliRandom > 100) CliRandom = 100;
continue;
}
if (strsame (aptr, "/REPEAT=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliCount = atoi(cptr);
continue;
}
if (strsame (aptr, "/SIZE=", 4))
{
for (cptr = aptr; *cptr && *cptr != '='; cptr++);
if (*cptr) cptr++;
CliBufferSize = atoi(cptr);
while (*cptr && isdigit(*cptr)) cptr++;
if (toupper(*cptr) == 'G')
CliBufferSize *= 1000000000;
else
if (toupper(*cptr) == 'M')
CliBufferSize *= 1000000;
else
if (tolower(*cptr) == 'k')
CliBufferSize *= 1000;
continue;
}
if (strsame (aptr, "/STAGGER", 4))
{
CliStagger = TRUE;
continue;
}
if (strsame (aptr, "/NOSTAGGER", 4))
{
CliStagger = FALSE;
continue;
}
if (strsame (aptr, "/TEXT", 4))
{
CliTextFrame = TRUE;
CliBinaryFrame = CliQbfFrame = CliThroughPut = FALSE;
continue;
}
if (strsame (aptr, "/VERSION", 4))
{
DoShowVersion = TRUE;
continue;
}
if (strsame (aptr, "/THROUGHPUT", 4))
{
CliThroughPut = TRUE;
CliBinaryFrame = CliQbfFrame = CliTextFrame = FALSE;
continue;
}
if (*aptr == '/')
{
fprintf (stdout, "%%%s-E-IVQUAL, unrecognized qualifier\n \\%s\\\n",
Utility, aptr+1);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
if (!RequestUriPtr[0])
{
RequestUriPtr = aptr;
continue;
}
fprintf (stdout, "%%%s-E-MAXPARM, too many parameters\n \\%s\\\n",
Utility, aptr);
exit (STS$K_ERROR | STS$M_INHIB_MSG);
}
}
/*****************************************************************************/
/*
*/
void ShowHelp ()
{
/*********/
/* begin */
/*********/
fprintf (stdout,
"%%%s-I-HELP, usage for the WASD WebSocket test-bench :^) utility (%s)\n\
\n\
WSB - CLI test and exercise the WASD WebSocket implementation.\n\
WS_BENCH - the complementary WebSocket server script/application.\n\
\n\
$ WB [qualifiers ...]\n\
\n\
/BINARY /BREAK[=<integer>] /COUNT=<integer> /CONCURRENT=<integer>\n\
/DO=[ECHO|PING|PONG|PUSH] /NUMBER=<integer> /PING /PONG /PROXY=<server> /QBF\n\
/RANDOM=<integer> /REPEAT=<integer> /SIZE=<integer> /[NO]STAGGER /TEXT\n\
\n\
Usage examples:\n\
\n\
$ WSB /NUM=1000 /DO=PUSH\n\
$ WSB /CONC=50 /NUM=1000 /DO=ECHO /PING /BREAK\n\
\n",
Utility, SOFTWAREID);
exit (SS$_NORMAL);
}
/****************************************************************************/
/*
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
)
{
while (*sptr1 && *sptr2)
{
if (toupper (*sptr1++) != toupper (*sptr2++)) return (FALSE);
if (count)
if (!--count) return (TRUE);
}
if (*sptr1 || *sptr2)
return (FALSE);
else
return (TRUE);
}
/****************************************************************************/