[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]
/*****************************************************************************/
/*
netIO.c
The fundamental structure and code for the a/synchronous $QIO with the network.
If the NETIO structure contain a Transport Layer Security (secure-sockets)
pointer it implicitly uses the TLS/SSL encrypted equivalent. If the NEIO
struct contains a pointer to an HTTP/2 stream struct then uses the HTTP/2
pointer within that to perform HTTP/2 I/O (of course the HTTP/2 I/O ultimately
uses a NETIO struct to mediate the actual I/O, most often via TLS/SSL).
Reading and writing data size now have no architectural limit. It's handled
internally. Same for SSL/TLS. With the potential for data size/length greater
than a single QIO the IO status block is deprecated in favour of
|ioptr->Read/WriteCount| and |ioptr->Read/WriteStatus|.
VERSION HISTORY
---------------
15-JUL-2020 MGD bugfix; NetIoWriteStatus() and NetIoReadStatus()
18-APR-2020 MGD NetIoQioMaxSeg() tune QIO to TCP MSS
24-DEC-2019 MGD NetIoWriteStatus() and NetIoReadStatus() count parameter
20-JAN-2018 MGD refactor NetPeek() into NetIoPeek()
NetIoRead() and NetIoWrite() ..IOsb.Status = 0
NetIoRead() and NetIoWrite() blocking NetIo..Ast() each I/O
11-AUG-2015 MGD restructure of network I/O abstractions
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
# undef __VMS_VER
# define __VMS_VER 70000000
# undef __CRTL_VER
# define __CRTL_VER 70000000
#else
# ifdef WASD_VMS_V7
# undef _VMS__V6__SOURCE
# define _VMS__V6__SOURCE
# undef __VMS_VER
# define __VMS_VER 70000000
# undef __CRTL_VER
# define __CRTL_VER 70000000
# endif
#endif
#include <stdio.h>
#include <ctype.h>
#include <iodef.h>
#include "wasd.h"
#define WASD_MODULE "NETIO"
/******************/
/* global storage */
/******************/
/********************/
/* external storage */
/********************/
extern uint EfnWait,
EfnNoWait,
HttpdTickSecond;
extern char ErrorSanityCheck[];
extern struct dsc$descriptor TcpIpDeviceDsc;
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Allocate (global) memory for the network I/O structure and assign a channel to
the internet template device. Return a pointer to the structure if successful
or NULL if not. At a maximum of every second or so reports any channel
assignment failure until the maximum period is exceeded (currently one minute).
*/
NETIO_STRUCT* NetIoBegin ()
{
static ulong ExitTickSecond,
PrevTickSecond;
int status;
ushort channel;
char *cptr;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE (WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetIoBegin()");
status = sys$assign (&TcpIpDeviceDsc, &channel, 0, 0);
if (VMSnok (status))
{
/* manage channel assignment failure */
if (HttpdTickSecond < ExitTickSecond)
{
if (HttpdTickSecond != PrevTickSecond)
{
ErrorNoticed (NULL, status, NULL, FI_LI);
PrevTickSecond = HttpdTickSecond;
if (!ExitTickSecond)
ExitTickSecond = HttpdTickSecond + NET_ASSIGN_FAIL_MAX;
}
/* hmmm, probably BYTLM exhausted */
if (status == SS$_EXQUOTA) return (NULL);
/* shouldn't have exhausted these, but seem to have */
if (status == SS$_NOIOCHAN) return (NULL);
/* some other (serious) error */
}
ErrorExitVmsStatus (status, "sys$assign()", FI_LI);
}
ExitTickSecond = PrevTickSecond = 0;
ioptr = VmGet (sizeof(NETIO_STRUCT));
ioptr->Channel = channel;
ioptr->QioMaxSeg = NETIO_QIO_BYTES_SENTINAL;
return (ioptr);
}
/*****************************************************************************/
/*
Proxy NETIO does not need the client data structure used by request processing
and so conserve a little memory by not allocating that (bit shonky I know).
This is noted in NET.H as well.
*/
NETIO_STRUCT* NetIoProxyBegin ()
{
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE (WATCH_MOD_NET))
WatchThis (WATCHALL, WATCH_MOD_NET, "NetIoProxyBegin()");
ioptr = VmGet (sizeof(NETIO_STRUCT) - sizeof(CLIENT_STRUCT));
ioptr->QioMaxSeg = NETIO_QIO_BYTES_SENTINAL;
return (ioptr);
}
/*****************************************************************************/
/*
Deassign the channel as necessary and free the network I/O structure.
If a TLS/SSL then do the equivalent.
*/
void NetIoEnd (NETIO_STRUCT *ioptr)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET, "NetIoEnd()");
if (ioptr->SesolaPtr)
SesolaNetEnd (ioptr->SesolaPtr);
else
{
sys$dassgn (ioptr->Channel);
VmFree (ioptr, FI_LI);
}
}
/*****************************************************************************/
/*
QIOing with a maximum of the TCP MSS seems so much more efficient (at least for
VSI AXPVMS VMS V8.4-2L1 and VSI AXPVMS TCPIP V5.7). The driver must have to do
a lot less work if the QIO data length is no greater than the TCP MSS.
Defaults to the MSS of ethernet (1460).
System logical name WASD_QIO_MAXSEG will allow this value to be explictly
set. There is no sanity check on this value. Logical name is tested once at
first request (i.e. at server startup).
*/
void NetIoQioMaxSeg (NETIO_STRUCT *ioptr)
{
static int QioMaxSeg = -1;
char *cptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET, "NetIoQioMaxSeg()");
if (QioMaxSeg < 0)
if (cptr = SysTrnLnm (WASD_QIO_MAXSEG))
QioMaxSeg = atoi (cptr);
else
QioMaxSeg = 0;
TcpIpSocketBufferSize (ioptr);
if (QioMaxSeg)
ioptr->QioMaxSeg = QioMaxSeg;
else
if (ioptr->TcpIpTcpMaxSeg)
{
ioptr->QioMaxSeg = ioptr->TcpIpTcpMaxSeg;
if (ioptr->QioMaxSeg > NETIO_QIO_BYTES_MAX)
ioptr->QioMaxSeg = NETIO_QIO_BYTES_MAX;
else
if (ioptr->QioMaxSeg < NETIO_QIO_BYTES_MIN)
ioptr->QioMaxSeg = NETIO_QIO_BYTES_MIN;
}
else
ioptr->QioMaxSeg = NETIO_QIO_BYTES_SENTINAL;
if (ioptr->QioMaxSeg != ioptr->TcpIpTcpMaxSeg)
if (WATCHING (ioptr, WATCH_NETWORK))
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"QIO maxseg:!UL", ioptr->QioMaxSeg);
}
/*****************************************************************************/
/*
Write 'DataLength' bytes located at 'DataPtr' to the client either using either
the "raw" network, or via HTTP/2, or via the Secure Sockets Layer.
If 'AstFunction' zero then use sys$qiow(), waiting for completion. If
an AST completion address is supplied then use sys$qio(). If empty data
buffer is supplied (zero length) then declare an AST to service any AST
routine supplied. If none then just return.
Explicitly declares any AST routine if an error occurs. The calling function
must not do any error recovery if an AST routine has been supplied but the
associated AST routine must! If an AST was not supplied then the return
status can be checked.
*/
int NetIoWrite
(
NETIO_STRUCT *ioptr,
VOID_AST AstFunction,
void *AstParam,
void *DataPtr,
uint DataLength
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET,
"NetIoWrite() !&X !&A !&X !UL",
ioptr, AstFunction, DataPtr, DataLength);
if (DataPtr)
{
/* first call */
if (!ioptr->Http2StreamPtr || AstFunction)
{
/* not HTTP/2 or non-blocking */
if (ioptr->WriteAstFunction)
{
HttpdStackTrace ("NetIoWrite()", FI_LI);
status = SS$_BUGCHECK;
ErrorNoticed (ioptr->RequestPtr, status, "!&A",
FI_LI, ioptr->WriteAstFunction);
return (status);
}
ioptr->WriteCount = 0;
ioptr->WriteStatus = 0;
ioptr->WriteAstFunction = AstFunction;
ioptr->WriteAstParam = AstParam;
ioptr->WritePtr = DataPtr;
ioptr->WriteLength = DataLength;
ioptr->WriteIOsb.Count = 0;
ioptr->WriteIOsb.Status = 0;
}
}
if (ioptr->Http2StreamPtr)
{
/**********/
/* HTTP/2 */
/**********/
status = Http2NetIoWrite (ioptr, AstFunction, AstParam,
DataPtr, DataLength);
return (status);
}
if (ioptr->SesolaPtr)
{
/*****************/
/* secure socket */
/*****************/
status = SesolaNetIoWrite (ioptr, DataPtr, DataLength);
return (status);
}
if (ioptr->VmsStatus)
{
/*********************************/
/* deliver explicitly set status */
/*********************************/
if (ioptr->WriteAstFunction)
SysDclAst (NetIoWriteAst, ioptr);
else
NetIoWriteAst (ioptr);
return (ioptr->VmsStatus);
}
if (WATCHING (ioptr, WATCH_NETWORK_OCTETS))
{
int dlen = ioptr->WriteLength - ioptr->WriteCount;
if (dlen > ioptr->QioMaxSeg) dlen = ioptr->QioMaxSeg;
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"WRITE !UL (!UL/!UL) bytes (!&?non-blocking\rblocking\r)",
dlen, ioptr->WriteCount, ioptr->WriteLength,
ioptr->WriteAstFunction);
WatchDataDump ((uchar*)ioptr->WritePtr + ioptr->WriteCount, dlen);
}
if (!ioptr->WriteLength)
status = ioptr->WriteStatus = SS$_BUGCHECK;
else
if (ioptr->WriteAstFunction)
{
/*******************/
/* non-blocking IO */
/*******************/
/* limit size of QIO */
DataLength = ioptr->WriteLength - ioptr->WriteCount;
if (DataLength > ioptr->QioMaxSeg) DataLength = ioptr->QioMaxSeg;
status = sys$qio (EfnNoWait, ioptr->Channel,
IO$_WRITEVBLK, &ioptr->WriteIOsb,
&NetIoWriteAst, ioptr,
(uchar*)ioptr->WritePtr + ioptr->WriteCount,
DataLength,
0, 0, 0, 0);
if (VMSnok (status)) ioptr->WriteStatus = status;
}
else
{
/***************/
/* blocking IO */
/***************/
while (ioptr->WriteCount < ioptr->WriteLength)
{
/* limit size of QIO */
DataLength = ioptr->WriteLength - ioptr->WriteCount;
if (!DataLength) DataLength = NETIO_QIO_BYTES_SENTINAL;
status = sys$qiow (EfnWait, ioptr->Channel,
IO$_WRITEVBLK, &ioptr->WriteIOsb, 0, 0,
(uchar*)ioptr->WritePtr + ioptr->WriteCount,
DataLength,
0, 0, 0, 0);
if (VMSnok (status))
ioptr->WriteStatus = status;
else
NetIoWriteAst (ioptr);
if (VMSnok (ioptr->WriteStatus)) break;
}
}
/****************/
/* check status */
/****************/
if (VMSok (status)) return (status);
/* if resource wait enabled the only quota not waited for is ASTLM */
if (status == SS$_EXQUOTA)
{
/* no ASTs means not much of anything else can happen so just exit! */
sys$canexh(0);
/* make the message a little more meaningful */
sys$exit (SS$_EXASTLM);
}
/* write failed, call AST explicitly, status in the IOsb */
ioptr->WriteIOsb.Status = status;
ioptr->WriteIOsb.Count = 0;
if (ioptr->WriteAstFunction)
SysDclAst (NetIoWriteAst, ioptr);
else
NetIoWriteAst (ioptr);
return (status);
}
/*****************************************************************************/
/*
AST from NetIoWrite(). Call the AST function.
*/
void NetIoWriteAst (NETIO_STRUCT *ioptr)
{
void *AstParam;
VOID_AST AstFunction;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET,
"NetIoWriteAst() !&F !&X !&X !&S !UL !UL !UL !&A",
&NetIoWriteAst, ioptr, ioptr->VmsStatus,
ioptr->WriteIOsb.Status, ioptr->WriteIOsb.Count,
ioptr->WriteLength, ioptr->WriteCount+ioptr->WriteIOsb.Count,
ioptr->WriteAstFunction);
if (ioptr->VmsStatus)
{
/* explicitly set status */
ioptr->WriteIOsb.Status = ioptr->VmsStatus;
ioptr->WriteIOsb.Count = 0;
}
ioptr->WriteStatus = ioptr->WriteIOsb.Status;
if (ioptr->WriteIOsb.Status == SS$_NORMAL &&
!(ioptr->WriteCount || ioptr->WriteLength))
{
/* special case, do not tally or report via WATCH */
if (AstFunction = ioptr->WriteAstFunction)
{
AstParam = ioptr->WriteAstParam;
ioptr->WriteAstFunction = ioptr->WriteAstParam = NULL;
AstFunction (AstParam);
}
return;
}
if (WATCHPNT(ioptr))
{
/* the SS$_WASECC is returned when GZIPing network data */
if (ioptr->WriteIOsb.Status != SS$_WASECC)
{
if (WATCH_CATEGORY(WATCH_NETWORK))
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"WRITE !&S !UL (!UL/!UL) bytes (!&?non-blocking\rblocking\r)",
ioptr->WriteIOsb.Status,
ioptr->WriteIOsb.Count,
ioptr->WriteCount + ioptr->WriteIOsb.Count,
ioptr->WriteLength, ioptr->WriteAstFunction);
if (WATCH_CATEGORY(WATCH_RESPONSE))
if (VMSnok (ioptr->WriteIOsb.Status))
WatchThis (WATCHITM(ioptr), WATCH_RESPONSE,
"NETWORK !&S (!&?non-blocking\rblocking\r)",
ioptr->WriteIOsb.Status, ioptr->WriteAstFunction);
}
}
if (VMSok (ioptr->WriteIOsb.Status))
{
ioptr->BlocksRawTx64++;
ioptr->BlocksTallyTx64++;
ioptr->BytesRawTx64 += ioptr->WriteIOsb.Count;
ioptr->BytesTallyTx64 += ioptr->WriteIOsb.Count;
ioptr->WriteCount += ioptr->WriteIOsb.Count;
if (ioptr->WriteAstFunction)
{
if (ioptr->WriteCount < ioptr->WriteLength)
{
/* continue to write */
NetIoWrite (ioptr, NULL, NULL, NULL, 0);
return;
}
}
}
else
{
ioptr->WriteErrorCount++;
/* just note the first error status */
if (!ioptr->WriteErrorStatus)
ioptr->WriteErrorStatus = ioptr->WriteIOsb.Status;
if (ioptr->WriteIOsb.Status &&
!(ioptr->WriteIOsb.Status == SS$_ABORT ||
ioptr->WriteIOsb.Status == SS$_CANCEL ||
ioptr->WriteIOsb.Status == SS$_CONNECFAIL ||
ioptr->WriteIOsb.Status == SS$_IVCHAN ||
ioptr->WriteIOsb.Status == SS$_LINKDISCON ||
ioptr->WriteIOsb.Status == SS$_TIMEOUT ||
ioptr->WriteIOsb.Status == SS$_UNREACHABLE ||
ioptr->WriteIOsb.Status == SS$_VCCLOSED))
{
char *sptr = "(none)";
REQUEST_STRUCT *rqptr;
if (rqptr = ioptr->RequestPtr)
if (rqptr->rqHeader.RequestUriPtr)
sptr = rqptr->rqHeader.RequestUriPtr;
ErrorNoticed (NULL, ioptr->WriteIOsb.Status, "!AZ", FI_LI, sptr);
}
}
if (AstFunction = ioptr->WriteAstFunction)
{
AstParam = ioptr->WriteAstParam;
ioptr->WriteAstFunction = ioptr->WriteAstParam = NULL;
AstFunction (AstParam);
}
}
/*****************************************************************************/
/*
Deliver the supplied VMS status code via AST while maintaining the network
write in-progress conditions. As with other I/O the delivery needs to be
decoupled in case it gets called again during that delivery.
*/
int NetIoWriteStatus
(
NETIO_STRUCT *ioptr,
VOID_AST AstFunction,
void *AstParam,
int AstStatus,
int WriteCount
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET,
"NetIoWriteStatus() !&X !&A !&S",
ioptr, AstFunction, AstStatus);
if (ioptr->WriteAstFunction)
{
char buf [256];
FaoToBuffer (buf, sizeof(buf), NULL, "!&A", ioptr->WriteAstFunction);
ErrorExitVmsStatus (SS$_BUGCHECK, buf, FI_LI);
}
ioptr->WriteAstFunction = AstFunction;
ioptr->WriteAstParam = AstParam;
if (!WriteCount) ioptr->WritePtr = NULL;
ioptr->WriteCount = 0;
ioptr->WriteLength = WriteCount;
ioptr->WriteIOsb.Count = WriteCount;
ioptr->WriteIOsb.Status = AstStatus;
if (AstFunction)
SysDclAst (NetIoWriteAst, ioptr);
else
NetIoWriteAst (ioptr);
return (AstStatus);
}
/*****************************************************************************/
/*
Queue up a read from the client over the network. If 'AstFunction'
is zero then no I/O completion AST routine is called. If it is non-zero then
the function pointed to by the parameter is called when the network write
completes.
Explicitly declares any AST routine if an error occurs. The calling function
must not do any error recovery if an AST routine has been supplied but the
associated AST routine must! If an AST was not supplied then the return
status can be checked.
*/
int NetIoRead
(
NETIO_STRUCT *ioptr,
VOID_AST AstFunction,
void *AstParam,
void *DataPtr,
uint DataSize
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET,
"NetIoRead() !&X !&A !&X !UL",
ioptr, AstFunction, DataPtr, DataSize);
if (DataPtr)
{
/* first call */
if (ioptr->ReadAstFunction)
{
char buf [256];
HttpdStackTrace ("NetIoRead()", FI_LI);
FaoToBuffer (buf, sizeof(buf), NULL, "!&A", ioptr->ReadAstFunction);
status = SS$_BUGCHECK;
ErrorNoticed (ioptr->RequestPtr, status, buf, FI_LI);
return (status);
}
ioptr->ReadCount = 0;
ioptr->ReadStatus = 0;
ioptr->ReadAstFunction = AstFunction;
ioptr->ReadAstParam = AstParam;
ioptr->ReadPtr = DataPtr;
ioptr->ReadSize = DataSize;
ioptr->ReadIOsb.Count = 0;
ioptr->ReadIOsb.Status = 0;
}
if (ioptr->Http2StreamPtr)
{
/**********/
/* HTTP/2 */
/**********/
status = Http2NetIoRead (ioptr);
return (status);
}
if (ioptr->SesolaPtr)
{
/*****************/
/* secure socket */
/*****************/
status = SesolaNetIoRead (ioptr, DataPtr, DataSize);
return (status);
}
if (WATCHING (ioptr, WATCH_NETWORK))
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"!AZ !UL/!UL bytes (!&?non-blocking\rblocking\r)",
ioptr->ReadSize & NETIO_DATA_FILL_BUF ? "FILL" : "READ",
ioptr->ReadCount, ioptr->ReadSize & ~NETIO_DATA_FILL_BUF,
ioptr->ReadAstFunction);
if (ioptr->VmsStatus)
{
/*********************************/
/* deliver explicitly set status */
/*********************************/
if (ioptr->ReadAstFunction)
SysDclAst (NetIoReadAst, ioptr);
else
NetIoReadAst (ioptr);
return (ioptr->VmsStatus);
}
if (!ioptr->ReadSize)
status = ioptr->ReadStatus = SS$_BUGCHECK;
else
if (ioptr->ReadAstFunction)
{
/*******************/
/* non-blocking IO */
/*******************/
DataSize = ioptr->ReadSize & ~NETIO_DATA_FILL_BUF;
DataSize -= ioptr->ReadCount;
if (DataSize > ioptr->QioMaxSeg) DataSize = ioptr->QioMaxSeg;
status = sys$qio (EfnNoWait, ioptr->Channel,
IO$_READVBLK, &ioptr->ReadIOsb,
&NetIoReadAst, ioptr,
(uchar*)ioptr->ReadPtr+ioptr->ReadCount, DataSize,
0, 0, 0, 0);
if (VMSnok (status)) ioptr->ReadStatus = status;
}
else
{
/***************/
/* blocking IO */
/***************/
for (;;)
{
DataSize = ioptr->ReadSize & ~NETIO_DATA_FILL_BUF;
DataSize -= ioptr->ReadCount;
if (DataSize > ioptr->QioMaxSeg) DataSize = ioptr->QioMaxSeg;
status = sys$qiow (EfnWait, ioptr->Channel,
IO$_READVBLK, &ioptr->ReadIOsb, 0, 0,
(uchar*)ioptr->ReadPtr+ioptr->ReadCount, DataSize,
0, 0, 0, 0);
if (VMSnok (status))
ioptr->ReadStatus = status;
else
NetIoReadAst (ioptr);
if (VMSnok (ioptr->ReadStatus)) break;
}
}
/****************/
/* check status */
/****************/
/* if I/O successful */
if (VMSok (status)) return (status);
/* with resource wait enabled the only quota not waited for is ASTLM */
if (status == SS$_EXQUOTA)
{
/* no ASTs means not much of anything else can happen so just exit! */
sys$canexh(0);
/* make the message a little more meaningful */
sys$exit (SS$_EXASTLM);
}
/* write failed, call AST explicitly, status in the IOsb */
ioptr->ReadIOsb.Status = status;
ioptr->ReadIOsb.Count = 0;
if (ioptr->ReadAstFunction)
SysDclAst (NetIoReadAst, ioptr);
else
NetIoReadAst (ioptr);
return (status);
}
/*****************************************************************************/
/*
AST from NetIoRead(). Call the AST function.
*/
void NetIoReadAst (NETIO_STRUCT *ioptr)
{
void *AstParam;
VOID_AST AstFunction;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET,
"NetIoReadAst() !&F !&X !&X !&S !UL !UL !&A",
NetIoReadAst, ioptr, ioptr->VmsStatus,
ioptr->ReadIOsb.Status, ioptr->ReadIOsb.Count,
ioptr->ReadCount, ioptr->ReadAstFunction);
if (VMSok (ioptr->ReadIOsb.Status))
{
/* zero bytes with a normal status (once seen with TGV-Multinet) */
// if (!ioptr->ReadIOsb.Count) ioptr->ReadIOsb.Status = SS$_ABORT;
}
if (ioptr->VmsStatus)
{
/* explicitly set status */
ioptr->ReadIOsb.Status = ioptr->VmsStatus;
ioptr->ReadIOsb.Count = 0;
}
ioptr->ReadStatus = ioptr->ReadIOsb.Status;
if (ioptr->ReadIOsb.Status == SS$_NORMAL &&
!(ioptr->ReadCount || ioptr->ReadSize))
{
/* special case, do not tally or report via WATCH */
if (AstFunction = ioptr->ReadAstFunction)
{
AstParam = ioptr->ReadAstParam;
ioptr->ReadAstFunction = ioptr->ReadAstParam = NULL;
AstFunction (AstParam);
}
return;
}
if (WATCHPNT(ioptr))
{
if (WATCH_CATEGORY(WATCH_NETWORK) ||
WATCH_CATEGORY(WATCH_NETWORK_OCTETS))
{
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"!AZ !&S !UL (!UL/!UL) bytes (!&?non-blocking\rblocking\r)",
ioptr->ReadSize & NETIO_DATA_FILL_BUF ? "FILL" : "READ",
ioptr->ReadIOsb.Status,
ioptr->ReadIOsb.Count,
ioptr->ReadCount + ioptr->ReadIOsb.Count,
ioptr->ReadSize & ~NETIO_DATA_FILL_BUF,
ioptr->ReadAstFunction);
if (WATCH_CATEGORY(WATCH_NETWORK_OCTETS))
if (VMSok(ioptr->ReadIOsb.Status))
WatchDataDump (ioptr->ReadPtr + ioptr->ReadCount,
ioptr->ReadIOsb.Count);
}
}
if (VMSok (ioptr->ReadIOsb.Status))
{
ioptr->BlocksRawRx64++;
ioptr->BlocksTallyRx64++;
ioptr->BytesRawRx64 += ioptr->ReadIOsb.Count;
ioptr->BytesTallyRx64 += ioptr->ReadIOsb.Count;
ioptr->ReadCount += ioptr->ReadIOsb.Count;
if (ioptr->ReadAstFunction)
{
if (ioptr->ReadSize & NETIO_DATA_FILL_BUF)
{
if (ioptr->ReadCount < (ioptr->ReadSize & ~NETIO_DATA_FILL_BUF))
{
/* read more to fill buffer */
NetIoRead (ioptr, NULL, NULL, NULL, 0);
return;
}
}
}
}
else
{
ioptr->ReadErrorCount++;
/* just note the first error status */
if (!ioptr->ReadErrorStatus)
ioptr->ReadErrorStatus = ioptr->ReadIOsb.Status;
if (!(ioptr->ReadIOsb.Status == SS$_ABORT ||
ioptr->ReadIOsb.Status == SS$_CANCEL ||
ioptr->ReadIOsb.Status == SS$_CONNECFAIL ||
ioptr->ReadIOsb.Status == SS$_IVCHAN ||
ioptr->ReadIOsb.Status == SS$_LINKDISCON ||
ioptr->ReadIOsb.Status == SS$_TIMEOUT ||
ioptr->ReadIOsb.Status == SS$_UNREACHABLE ||
ioptr->ReadIOsb.Status == SS$_VCCLOSED))
{
char *sptr = "(none)";
REQUEST_STRUCT *rqptr;
if (rqptr = ioptr->RequestPtr)
if (rqptr->rqHeader.RequestUriPtr)
sptr = rqptr->rqHeader.RequestUriPtr;
ErrorNoticed (NULL, ioptr->ReadIOsb.Status, "!AZ", FI_LI, sptr);
}
}
if (AstFunction = ioptr->ReadAstFunction)
{
AstParam = ioptr->ReadAstParam;
ioptr->ReadAstFunction = ioptr->ReadAstParam = NULL;
AstFunction (AstParam);
}
}
/*****************************************************************************/
/*
Deliver the supplied VMS status code via AST while maintaining the network
write in-progress conditions. As with other I/O the delivery needs to be
decoupled in case it gets called again during that delivery. Primarily used to
indicate SS$_CANCEL in HTTP/2 processing.
*/
void NetIoReadStatus
(
NETIO_STRUCT *ioptr,
VOID_AST AstFunction,
void *AstParam,
int AstStatus,
uint ReadCount
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET,
"NetIoReadStatus() !&X !UL !&A !&S",
ioptr, ReadCount, AstFunction, AstStatus);
if (ioptr->ReadAstFunction)
{
char buf [256];
FaoToBuffer (buf, sizeof(buf), NULL, "!&A", ioptr->ReadAstFunction);
ErrorExitVmsStatus (SS$_BUGCHECK, buf, FI_LI);
}
ioptr->ReadAstFunction = AstFunction;
ioptr->ReadAstParam = AstParam;
if (!ReadCount)
{
ioptr->ReadPtr = NULL;
ioptr->ReadSize = 0;
}
ioptr->ReadCount = 0;
ioptr->ReadIOsb.Count = ReadCount;
ioptr->ReadIOsb.Status = AstStatus;
if (AstFunction)
SysDclAst (NetIoReadAst, ioptr);
else
NetIoReadAst (ioptr);
}
/****************************************************************************/
/*
Any $QIO I/O currently outstanding?
*/
BOOL NetIoInProgress (NETIO_STRUCT *ioptr)
{
int channel, status;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET, "NetIoInProgress()");
if (ioptr->Http2StreamPtr)
return (Http2NetIoInProgress (ioptr->Http2StreamPtr));
if (ioptr->SesolaPtr)
return (SesolaNetIoInProgress (ioptr->SesolaPtr));
return (ioptr->WriteAstFunction || ioptr->ReadAstFunction);
}
/****************************************************************************/
/*
Cancel network I/O in-progress.
*/
void NetIoCancel (NETIO_STRUCT *ioptr)
{
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET, "NetIoCancel()");
ioptr->VmsStatus = SS$_CANCEL;
if (ioptr->Http2StreamPtr)
Http2RequestCancel (((HTTP2_STREAM_STRUCT*)ioptr->Http2StreamPtr)->RequestPtr);
else
if (ioptr->SesolaPtr)
SesolaNetIoCancel (ioptr);
else
if (ioptr->WriteAstFunction || ioptr->ReadAstFunction)
sys$cancel (ioptr->Channel);
}
/****************************************************************************/
/*
Just close the socket (channel), bang!
*/
int NetIoCloseSocket (NETIO_STRUCT *ioptr)
{
int channel, status;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_NET))
WatchThis (WATCHITM(ioptr), WATCH_MOD_NET, "NetIoCloseSocket()");
if (ioptr->Http2StreamPtr) return (SS$_NORMAL);
if (!ioptr->Channel) return (SS$_NORMAL);
status = sys$dassgn (channel = ioptr->Channel);
ioptr->Channel = 0;
if (WATCH_CATEGORY(WATCH_CONNECT))
WatchThis (WATCHITM(ioptr), WATCH_CONNECT, "CLOSE channel !UL !&S",
channel, status);
return (status);
}
/*****************************************************************************/
/*
Allows *testing* of NetIoWrite() for small, medium, large and huge buffers.
A request to UTI "/$/NetIoWriteTest/?<integer>" will invoke this function.
Writes responses of ASCII in quantities from 1 byte to whatever. Non-blocking
by default, negative quantity to make blocking.
*/
#if WATCH_MOD
void NetIoWriteTest (REQUEST_STRUCT *rqptr)
{
int ch, nonblock, size;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET, "NetIoWriteTest()");
if (rqptr->NotePadPtr != NetIoWriteTest)
{
rqptr->NotePadPtr = NetIoWriteTest;
if (!(cptr = rqptr->rqHeader.QueryStringPtr)) cptr = "32767";
size = atoi(cptr);
if (size >= 0) nonblock = 1; else nonblock = 0;
size = abs(size);
cptr = VmGetHeap (rqptr, size+32);
zptr = (sptr = cptr) + size;
ch = '!';
while (sptr < zptr)
{
while (ch <= '~' && sptr < zptr) *sptr++ = ch++;
if (sptr < zptr) *sptr++ = '\n';
ch = '!';
}
rqptr->rqResponse.NoGzip = true;
ResponseHeader (rqptr, 200, "text/plain", size, NULL, NULL);
if (nonblock)
{
NetWrite (rqptr, NetIoWriteTest, cptr, size);
return;
}
NetWrite (rqptr, NULL, cptr, size);
}
RequestEnd2 (rqptr);
}
#endif /* WATCH_MOD */
/*****************************************************************************/
/*
Allows *testing* of NetIoRead() for small, medium, large and huge buffers.
Using cURL and a POSTed file to buffer. Non-blocking by default, negative
quantity <integer> to make blocking.
$ curl --insecure "-XPOST" --data-binary @<file_name> -
"http[s]://<host_name>/$/NetIoReadTest/?<integer>"
*/
#if WATCH_MOD
void NetIoReadTest (REQUEST_STRUCT *rqptr)
{
int nonblock = 1;
int64 size;
ushort slen;
char *cptr;
char buf [256];
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_NET))
WatchThis (WATCHITM(rqptr), WATCH_MOD_NET, "NetIoReadTest()");
if (rqptr->NotePadPtr != NetIoWriteTest)
{
rqptr->NotePadPtr = NetIoWriteTest;
if (atoi(rqptr->rqHeader.QueryStringPtr) < 0) nonblock = 0;
size = rqptr->rqHeader.ContentLength64;
cptr = VmGetHeap (rqptr, size+32);
size |= NETIO_DATA_FILL_BUF;
if (nonblock)
{
NetRead (rqptr, &NetIoReadTest, cptr, size);
return;
}
NetRead (rqptr, NULL, cptr, size);
}
rqptr->NetIoPtr->BytesRawRx64 += rqptr->NetIoPtr->ReadCount;
rqptr->NetIoPtr->BytesTallyRx64 += rqptr->NetIoPtr->ReadCount;
FaoToBuffer (buf, sizeof(buf), &slen, "status:!&S count:!UL\n",
rqptr->NetIoPtr->ReadStatus,
rqptr->NetIoPtr->ReadCount);
rqptr->rqResponse.NoGzip = true;
ResponseHeader (rqptr, 200, "text/plain", slen, NULL, NULL);
NetWrite (rqptr, NULL, buf, slen);
RequestEnd2 (rqptr);
}
#endif /* WATCH_MOD */
/*****************************************************************************/