[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]
/*****************************************************************************/
/*
SesolaNetIo.c
Handles the a/synchronous $QIO with the network for SSL/TLS encrypted traffic.
Is the SSL/TLS equivalent of NETIO.C
Reading and writing data size now have no architectural limit. While the
OpenSSL BIO infrastructure could always perform it, WASD now reads and writes
exceeding 65535 bytes per call. It's handled internally. 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
---------------
02-SEP-2021 MGD bugfix; SesolaNetIoRead() /bytes = value/
18-APR-2020 MGD NetIoQioMaxSeg() tune QIO to TCP MSS
27-FEB-2020 MGD Sesola_netio_.._ex() seems to be the OpenSSL 1.1.n approach
18-JUN-2019 MGD Sesola_netio_read_ast() 0 status TCP/IP Services?
Sesola_netio_write_ast() 0 status TCP/IP Services?
04-FEB-2019 MGD Sesola_netio_read() and Sesola_netio_write() if connection
broken (channel zero) return zero (SSL shutdown)
17-MAR-2017 MGD bugfix; SesolaNetIoRead() SSL_read() in-progress
05-JUN-2016 MGD SesolaNetIoRead() renegotiate application data buffer
11-AUG-2015 MGD restructure of network I/O abstractions
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* VMS related header files */
#include <iodef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application header files */
#define SESOLA_REQUIRED
#include "Sesola.h"
#define WASD_MODULE "SESOLANETIO"
/***************************************/
#ifdef SESOLA /* secure sockets layer */
/***************************************/
/******************/
/* global storage */
/******************/
/********************/
/* external storage */
/********************/
extern int EfnWait,
EfnNoWait;
extern char ErrorSanityCheck[];
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Write application data to the client via the network. This function uses
SSL_write() to write non-encrypted application data to the network in encrypted
form. This function provides BLOCKING (non-AST) and NON-BLOCKING I/O
conforming to the functionality provided by NetWrite(). The network write I/O
status block status and count fields are valid for the high-level calling
routine.
*/
int SesolaNetIoWrite
(
NETIO_STRUCT *ioptr,
void *DataPtr,
int DataLength
)
{
int bytes, value;
SESOLA_STRUCT *sesolaptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"SesolaNetIoWrite() !&X !&X !UL",
ioptr, DataPtr, DataLength);
sesolaptr = ioptr->SesolaPtr;
if (DataPtr)
{
/* primary call not AST recall */
if (ioptr->VmsStatus)
{
/* deliver explicitly set status */
ioptr->WriteCount = 0;
ioptr->WriteStatus = ioptr->VmsStatus;
if (ioptr->WriteAstFunction) SysDclAst (SesolaNetIoWriteAst, ioptr);
return (ioptr->WriteStatus);
}
sesolaptr->WritePtr = DataPtr;
sesolaptr->WriteLength = DataLength;
sesolaptr->WriteCount = ioptr->WriteCount = 0;
sesolaptr->WriteIOsb.Count = 0;
sesolaptr->WriteIOsb.Status = 0;
if (WATCHING (ioptr, WATCH_NETWORK_OCTETS))
{
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"WRITE !UL bytes PLAIN (!&?non-blocking\rblocking\r)",
DataLength, SESOLA_NETIO_WRITE_IN_PROGRESS(sesolaptr));
WatchDataDump (DataPtr, DataLength);
}
}
else
{
/* AST recall */
DataPtr = sesolaptr->WritePtr;
DataLength = sesolaptr->WriteLength;
}
if (!sesolaptr->WriteLength) ioptr->VmsStatus = SS$_BUGCHECK;
ERR_clear_error ();
bytes = 0;
#if SESOLA_SINCE_110
value = SSL_write_ex (sesolaptr->SslPtr, DataPtr, DataLength, &bytes);
#else
value = SSL_write (sesolaptr->SslPtr, DataPtr, DataLength);
#endif
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"SSL_write() !SL !SL !SL !&B",
value, SSL_get_error(sesolaptr->SslPtr,value), bytes,
sesolaptr->WriteInProgress);
/* if non-blocking I/O in progress just return and wait for delivery */
if (sesolaptr->WriteInProgress) return (SS$_NORMAL);
if (ioptr->VmsStatus) sesolaptr->WriteIOsb.Status = ioptr->VmsStatus;
ioptr->WriteCount = 0;
if (VMSok (sesolaptr->WriteIOsb.Status))
{
if (SSL_is_init_finished(sesolaptr->SslPtr))
{
if (value > 0)
{
#if SESOLA_SINCE_110
sesolaptr->WriteCount = bytes;
ioptr->WriteCount = bytes;
#else
sesolaptr->WriteCount = value;
ioptr->WriteCount = value;
#endif
ioptr->WriteStatus = SS$_NORMAL;
}
else
ioptr->WriteStatus = sesolaptr->WriteIOsb.Status;
}
else
ioptr->WriteStatus = SS$_ABORT;
}
else
ioptr->WriteStatus = sesolaptr->WriteIOsb.Status;
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA, "!&S !UL",
ioptr->WriteStatus, ioptr->WriteCount);
/* update the stats of the underlying network I/O structure */
ioptr->BytesRawTx64 += sesolaptr->BytesTallyTx64;
ioptr->BytesTallyTx64 += sesolaptr->BytesTallyTx64;
ioptr->BlocksRawTx64 += sesolaptr->BlocksTallyTx64;
ioptr->BlocksTallyTx64 += sesolaptr->BlocksTallyTx64;
/* reset the intermediate accumulators used to update the stats */
sesolaptr->BytesTallyTx64 = 0;
sesolaptr->BlocksTallyTx64 = 0;
/* decouple the AST delivery */
if (ioptr->WriteAstFunction) SysDclAst (SesolaNetIoWriteAst, ioptr);
return (ioptr->WriteStatus);
}
/*****************************************************************************/
/*
This function decouples SesolaNetIoWrite() from the AST delivery where it might
be recalled to make another write.
*/
void SesolaNetIoWriteAst (NETIO_STRUCT *ioptr)
{
void *AstParam;
VOID_AST AstFunction;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA, "SesolaNetIoWriteAst()");
AstParam = ioptr->WriteAstParam;
AstFunction = ioptr->WriteAstFunction;
ioptr->WriteAstFunction = ioptr->WriteAstParam = NULL;
if (AstFunction) AstFunction (AstParam);
}
/*****************************************************************************/
/*
Implements a required function of a OpenSSL BIO_METHOD.
*/
#if SESOLA_BEFORE_110
int Sesola_netio_write
(
BIO *bioptr,
char *DataPtr,
int DataLength
)
{
int bytes = 0;
Sesola_netio_write_ex (bioptr, DataPtr, DataLength, &bytes);
return (bytes);
}
#endif
int Sesola_netio_write_ex
(
BIO *bioptr,
char *DataPtr,
int DataLength,
int *BytesPtr
)
{
int status;
NETIO_STRUCT *ioptr;
SESOLA_STRUCT *sesolaptr;
/*********/
/* begin */
/*********/
#if SESOLA_SINCE_110
sesolaptr = (SESOLA_STRUCT*)BIO_get_data(bioptr);
#else
sesolaptr = (SESOLA_STRUCT*)bioptr->ptr;
#endif
ioptr = sesolaptr->NetIoPtr;
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"Sesola_netio_write_ex() !&X !&X !UL !&X !&B !&B",
ioptr, DataPtr, DataLength, BytesPtr,
sesolaptr->WriteInProgress, sesolaptr->WriteInProgress);
if (sesolaptr->WriteIsComplete)
{
/* previous non-blocking write is now complete */
sesolaptr->WriteInProgress = sesolaptr->WriteIsComplete = false;
if (VMSok (sesolaptr->WriteIOsb.Status))
{
*BytesPtr = sesolaptr->WriteIOsb.Count;
return (1);
}
return (0);
}
/* if asynchronous write in progress, retry next call */
if (sesolaptr->WriteInProgress) return (0);
/* in case of connection dropped */
if (!ioptr->Channel)
{
BIO_clear_retry_flags (sesolaptr->BioPtr);
return (0);
}
/* no empty writes! */
if (!DataLength)
{
BIO_clear_retry_flags (sesolaptr->BioPtr);
return (0);
}
if (WATCHING (ioptr, WATCH_NETWORK_OCTETS))
{
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"WRITE !UL bytes CIPHER (!&?non-blocking\rblocking\r)",
DataLength, SESOLA_NETIO_WRITE_IN_PROGRESS(sesolaptr));
WatchDataDump (DataPtr, DataLength);
}
if (DataLength > ioptr->QioMaxSeg) DataLength = ioptr->QioMaxSeg;
if (SESOLA_NETIO_WRITE_IN_PROGRESS(sesolaptr))
{
/*******************/
/* non-blocking IO */
/*******************/
BIO_set_retry_write (bioptr);
sesolaptr->WriteInProgress = true;
sesolaptr->WriteIsComplete = false;
status = sys$qio (EfnNoWait, ioptr->Channel,
IO$_WRITEVBLK, &sesolaptr->WriteIOsb,
&Sesola_netio_write_ast, sesolaptr,
sesolaptr->WriteRawPtr = DataPtr, DataLength,
0, 0, 0, 0);
if (VMSok (status)) return (0);
if (status != SS$_EXQUOTA)
{
/* report the status via the AST */
if (status != SS$_IVCHAN)
ErrorNoticed (NULL, status, "sys$qio", FI_LI);
sesolaptr->WriteIOsb.Status = status;
sesolaptr->WriteIOsb.Count = 0;
SysDclAst (&Sesola_netio_write_ast, sesolaptr);
return (0);
}
}
else
{
/***************/
/* blocking IO */
/***************/
sesolaptr->WriteInProgress = false;
sesolaptr->WriteIsComplete = false;
status = sys$qiow (EfnWait, ioptr->Channel,
IO$_WRITEVBLK, &sesolaptr->WriteIOsb, 0, 0,
sesolaptr->WriteRawPtr = DataPtr, DataLength,
0, 0, 0, 0);
if (VMSok (status))
*BytesPtr = sesolaptr->WriteIOsb.Count;
else
{
/* report the status via the AST */
sesolaptr->WriteIOsb.Status = status;
sesolaptr->WriteIOsb.Count = 0;
}
Sesola_netio_write_ast (sesolaptr);
if (status != SS$_EXQUOTA) return (1);
}
/* with resource wait enabled the only quota not waited for is ASTLM */
sys$canexh(0);
/* make the message a little more meaningful */
sys$exit (SS$_EXASTLM);
}
/*****************************************************************************/
/*
Post-process the write for both blocking and non-block I/O.
*/
void Sesola_netio_write_ast (SESOLA_STRUCT *sesolaptr)
{
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
ioptr = sesolaptr->NetIoPtr;
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"Sesola_netio_write_ast() !&X !&F !&S !&B !&S !UL",
ioptr, &Sesola_netio_write_ast,
ioptr->VmsStatus, sesolaptr->WriteInProgress,
sesolaptr->WriteIOsb.Status, sesolaptr->WriteIOsb.Count);
if (ioptr->VmsStatus)
{
/* deliver explicitly set status */
ioptr->WriteIOsb.Status = ioptr->VmsStatus;
ioptr->WriteIOsb.Count = 0;
}
if (WATCHING (ioptr, WATCH_THIS))
{
if (WATCH_CATEGORY(WATCH_NETWORK))
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"WRITE !&S !UL bytes CIPHER (!&?non-blocking\rblocking\r)",
sesolaptr->WriteIOsb.Status,
sesolaptr->WriteIOsb.Count,
SESOLA_NETIO_WRITE_IN_PROGRESS(sesolaptr));
if (WATCH_CATEGORY(WATCH_RESPONSE))
if (VMSnok (sesolaptr->WriteIOsb.Status))
WatchThis (WATCHITM(ioptr), WATCH_RESPONSE,
"NETWORK !&S (!&?non-blocking\rblocking\r)",
sesolaptr->WriteIOsb.Status,
SESOLA_NETIO_WRITE_IN_PROGRESS(sesolaptr));
}
if (VMSok (sesolaptr->WriteIOsb.Status))
{
sesolaptr->Sesola_write_ErrorCount = 0;
sesolaptr->BytesTallyTx64 += sesolaptr->WriteIOsb.Count;
}
else
{
if (sesolaptr->Sesola_write_ErrorCount++ > 8192)
ErrorExitVmsStatus (sesolaptr->WriteIOsb.Status,
ErrorSanityCheck, FI_LI);
ioptr->WriteErrorCount++;
/* just note the first error status */
if (!ioptr->WriteErrorStatus)
ioptr->WriteErrorStatus = sesolaptr->WriteIOsb.Status;
if (!(sesolaptr->WriteIOsb.Status == SS$_ABORT ||
sesolaptr->WriteIOsb.Status == SS$_CANCEL ||
sesolaptr->WriteIOsb.Status == SS$_CONNECFAIL ||
sesolaptr->WriteIOsb.Status == SS$_LINKDISCON ||
sesolaptr->WriteIOsb.Status == SS$_TIMEOUT ||
sesolaptr->WriteIOsb.Status == SS$_IVCHAN ||
sesolaptr->WriteIOsb.Status == 0)) /* TCP/IP Services? */
ErrorNoticed (NULL, sesolaptr->WriteIOsb.Status, NULL, FI_LI);
sesolaptr->WriteIOsb.Count = 0;
}
sesolaptr->BlocksTallyTx64++;
BIO_clear_retry_flags (sesolaptr->BioPtr);
/* if blocking I/O then just return */
if (!sesolaptr->WriteInProgress) return;
sesolaptr->WriteInProgress = false;
sesolaptr->WriteIsComplete = true;
if (sesolaptr->SslStateFunction)
SysDclAst (sesolaptr->SslStateFunction, sesolaptr);
else
SesolaNetIoWrite (ioptr, NULL, 0);
}
/*****************************************************************************/
/*
Read application data from the client via the network. This function uses
SSL_read() to read a stream of encrypted data from the network then provide it
decrypted in the supplied buffer. This function provides BLOCKING (non-AST)
and NON-BLOCKING I/O conforming to the functionality provided by NetRead(). The
network read I/O status block status and count fields are valid for the
high-level calling routine.
*/
SesolaNetIoRead
(
NETIO_STRUCT *ioptr,
void *DataPtr,
int DataSize
)
{
int bytes, error, value;
SESOLA_STRUCT *sesolaptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"SesolaNetIoRead() !&X !&X !UL",
ioptr, DataPtr, DataSize);
sesolaptr = ioptr->SesolaPtr;
if (DataPtr)
{
/* primary call not AST recall */
if (ioptr->VmsStatus)
{
/* deliver explicitly set status */
ioptr->ReadStatus = ioptr->VmsStatus;
ioptr->ReadCount = 0;
if (ioptr->ReadAstFunction) SysDclAst (SesolaNetIoReadAst, ioptr);
return (ioptr->ReadStatus);
}
sesolaptr->ReadPtr = DataPtr;
sesolaptr->ReadSize = DataSize;
sesolaptr->ReadCount = 0;
sesolaptr->ReadIOsb.Count = 0;
sesolaptr->ReadIOsb.Status = 0;
if (WATCHING (ioptr, WATCH_NETWORK))
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"!&?FILL\rREAD\r !UL/!UL bytes (!&?non-blocking\rblocking\r)",
sesolaptr->ReadSize & NETIO_DATA_FILL_BUF,
sesolaptr->ReadCount,
sesolaptr->ReadSize & ~NETIO_DATA_FILL_BUF,
SESOLA_NETIO_READ_IN_PROGRESS(sesolaptr));
}
if (!sesolaptr->ReadSize) ioptr->VmsStatus = SS$_BUGCHECK;
for (;;)
{
DataSize = (sesolaptr->ReadSize & ~NETIO_DATA_FILL_BUF);
if (ioptr->VmsStatus)
ioptr->ReadStatus = ioptr->VmsStatus;
else
if (VMSnok (sesolaptr->ReadIOsb.Status))
ioptr->ReadStatus = sesolaptr->ReadIOsb.Status;
else
if (sesolaptr->ReadCount >= DataSize)
ioptr->ReadStatus = SS$_BUGCHECK;
if (ioptr->ReadStatus)
if (VMSnok (ioptr->ReadStatus))
{
/* break if an issue around the read */
ioptr->ReadCount = 0;
break;
}
DataSize -= sesolaptr->ReadCount;
(uchar*)DataPtr = (uchar*)sesolaptr->ReadPtr + sesolaptr->ReadCount;
if (sesolaptr->VerifyPeerDataSize &&
sesolaptr->VerifyPeerDataCount > 0)
{
/* application data buffered at time of TLS/SSL renegotiate */
if (sesolaptr->VerifyPeerDataCount > DataSize)
value = DataSize;
else
value = sesolaptr->VerifyPeerDataCount;
memcpy (DataPtr, sesolaptr->VerifyPeerReadPtr, bytes = value);
if (WATCHING (ioptr, WATCH_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_SESOLA,
"BUFFERED client data !UL/!UL !UL",
sesolaptr->VerifyPeerDataCount,
sesolaptr->VerifyPeerDataSize,
value);
sesolaptr->VerifyPeerDataCount -= value;
sesolaptr->VerifyPeerReadPtr += value;
if (!sesolaptr->VerifyPeerDataCount)
{
/* reset the buffer freeing the global memory */
VmFree (sesolaptr->VerifyPeerDataPtr, FI_LI);
sesolaptr->VerifyPeerDataPtr = sesolaptr->VerifyPeerReadPtr = NULL;
sesolaptr->VerifyPeerDataSize = 0;
}
}
else
{
/* OpenSSL (TLS?) maximum of 16kB will be read at a time */
ERR_clear_error ();
bytes = 0;
#if SESOLA_SINCE_110
value = SSL_read_ex (sesolaptr->SslPtr, DataPtr, DataSize, &bytes);
#else
value = SSL_read (sesolaptr->SslPtr, DataPtr, DataSize);
#endif
/* if non-blocking IO in progress just return and wait for delivery */
if (sesolaptr->ReadInProgress)
{
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"SSL_read() in-progress");
return (SS$_NORMAL);
}
}
error = SSL_get_error (sesolaptr->SslPtr, value);
if (value > 0)
{
#if SESOLA_SINCE_110
sesolaptr->ReadCount += bytes;
ioptr->ReadCount += bytes;
#else
sesolaptr->ReadCount += value;
ioptr->ReadCount += value;
#endif
ioptr->ReadStatus = SS$_NORMAL;
}
else
if (value <= 0)
{
ioptr->ReadCount = 0;
if (error == SSL_ERROR_ZERO_RETURN ||
error == SSL_ERROR_SYSCALL ||
error == SSL_ERROR_SSL)
ioptr->ReadStatus = SS$_ABORT;
else
ioptr->ReadStatus = sesolaptr->ReadIOsb.Status;
}
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"SSL_read() !SL !SL !SL !SL/!SL !&S",
value, error, bytes,
sesolaptr->ReadCount,
sesolaptr->ReadSize & ~NETIO_DATA_FILL_BUF,
ioptr->ReadStatus);
if (VMSnok (ioptr->ReadStatus))
{
/* deliver explicitly set status */
if (ioptr->ReadAstFunction) SysDclAst (SesolaNetIoReadAst, ioptr);
return (ioptr->ReadStatus);
}
/* just the one read if not filling a buffer */
if (!(sesolaptr->ReadSize & NETIO_DATA_FILL_BUF)) break;
}
if (WATCHING (ioptr, WATCH_THIS) &&
(WATCH_CATEGORY(WATCH_NETWORK) ||
WATCH_CATEGORY(WATCH_NETWORK_OCTETS)))
{
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"READ !&S !UL bytes PLAIN (!&?non-blocking\rblocking\r)",
ioptr->ReadStatus, ioptr->ReadCount,
SESOLA_NETIO_READ_IN_PROGRESS(sesolaptr));
if (WATCH_CATEGORY(WATCH_NETWORK_OCTETS))
WatchDataDump (ioptr->ReadPtr, ioptr->ReadCount);
}
/* update the stats of the underlying network I/O structure */
ioptr->BytesRawRx64 += sesolaptr->BytesTallyRx64;
ioptr->BytesTallyRx64 += sesolaptr->BytesTallyRx64;
ioptr->BlocksRawRx64 += sesolaptr->BlocksTallyRx64;
ioptr->BlocksTallyRx64 += sesolaptr->BlocksTallyRx64;
/* reset the intermediate accumulators used to update the stats */
sesolaptr->BytesTallyRx64 = 0;
sesolaptr->BlocksTallyRx64 = 0;
/* decouple the AST delivery */
if (ioptr->ReadAstFunction) SysDclAst (SesolaNetIoReadAst, ioptr);
return (ioptr->ReadStatus);
}
/*****************************************************************************/
/*
This function decouples SesolaNetIoRead() from the AST delivery where it might
be recalled to make another read.
*/
void SesolaNetIoReadAst (NETIO_STRUCT *ioptr)
{
void *AstParam;
VOID_AST AstFunction;
/*********/
/* begin */
/*********/
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA, "SesolaNetIoReadAst()");
AstParam = ioptr->ReadAstParam;
AstFunction = ioptr->ReadAstFunction;
ioptr->ReadAstFunction = ioptr->ReadAstParam = NULL;
if (AstFunction) AstFunction (AstParam);
}
/*****************************************************************************/
/*
Implements a required function of a OpenSSL BIO_METHOD. It provides blocking
and more importantly non-blocking reads of (encrypted) data from the network
connection. With blocking IO it returns immediately.
*/
#if SESOLA_BEFORE_110
int Sesola_netio_read
(
BIO *bioptr,
char *DataPtr,
int DataSize
)
{
int bytes = 0;
Sesola_netio_read_ex (bioptr, DataPtr, DataSize, &bytes);
return (bytes);
}
#endif
int Sesola_netio_read_ex
(
BIO *bioptr,
char *DataPtr,
int DataSize,
int *BytesPtr
)
{
int status;
NETIO_STRUCT *ioptr;
SESOLA_STRUCT *sesolaptr;
/*********/
/* begin */
/*********/
#if SESOLA_SINCE_110
sesolaptr = (SESOLA_STRUCT*)BIO_get_data(bioptr);
#else
sesolaptr = (SESOLA_STRUCT*)bioptr->ptr;
#endif
ioptr = sesolaptr->NetIoPtr;
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"Sesola_netio_read() !&X !&X !&X !UL !&B !&B",
ioptr, DataPtr, DataSize, BytesPtr,
sesolaptr->ReadInProgress, sesolaptr->ReadIsComplete);
if (sesolaptr->ReadIsComplete)
{
/* previous non-blocking read is now complete */
sesolaptr->ReadInProgress = sesolaptr->ReadIsComplete = false;
if (VMSok (sesolaptr->ReadIOsb.Status))
{
*BytesPtr = sesolaptr->ReadIOsb.Count;
return (sesolaptr->ReadIOsb.Count);
}
return (0);
}
/* if non-blocking read (already) in progress, retry next call */
if (sesolaptr->ReadInProgress) return (-1);
/* in case of connection dropped */
if (!ioptr->Channel)
{
BIO_clear_retry_flags (sesolaptr->BioPtr);
return (0);
}
/* no null buffers! */
if (!DataSize)
{
BIO_clear_retry_flags (sesolaptr->BioPtr);
return (0);
}
if (WATCHING (ioptr, WATCH_NETWORK_OCTETS))
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"READ !UL bytes max CIPHER (!&?non-blocking\rblocking\r)",
DataSize, SESOLA_NETIO_READ_IN_PROGRESS(sesolaptr));
if (DataSize > ioptr->QioMaxSeg) DataSize = ioptr->QioMaxSeg;
if (SESOLA_NETIO_READ_IN_PROGRESS(sesolaptr))
{
/*******************/
/* non-blocking IO */
/*******************/
BIO_set_retry_read (bioptr);
sesolaptr->ReadInProgress = true;
sesolaptr->ReadIsComplete = false;
status = sys$qio (EfnNoWait, ioptr->Channel,
IO$_READVBLK, &sesolaptr->ReadIOsb,
&Sesola_netio_read_ast, sesolaptr,
sesolaptr->ReadRawPtr = DataPtr, DataSize,
0, 0, 0, 0);
/* return indicating non-blocking I/O */
if (VMSok (status)) return (-1);
if (status != SS$_EXQUOTA)
{
/* report the status via the AST */
ErrorNoticed (NULL, status, "sys$qio", FI_LI);
sesolaptr->ReadIOsb.Status = status;
sesolaptr->ReadIOsb.Count = 0;
SysDclAst (&Sesola_netio_read_ast, sesolaptr);
return (-1);
}
}
else
{
/***************/
/* blocking IO */
/***************/
sesolaptr->ReadInProgress = false;
sesolaptr->ReadIsComplete = false;
/* see HTTP detection in Sesola_netio_read_ast() */
if (sesolaptr->ReadIOsb.Status == SS$_BADESCAPE) return (0);
status = sys$qiow (EfnWait, ioptr->Channel,
IO$_READVBLK, &sesolaptr->ReadIOsb, 0, 0,
sesolaptr->ReadRawPtr = DataPtr, DataSize,
0, 0, 0, 0);
if (VMSok (status))
*BytesPtr = sesolaptr->ReadIOsb.Count;
else
{
/* report the status via the AST */
sesolaptr->ReadIOsb.Status = status;
sesolaptr->ReadIOsb.Count = 0;
}
Sesola_netio_read_ast (sesolaptr);
if (status != SS$_EXQUOTA) return (1);
}
/* with resource wait enabled the only quota not waited for is ASTLM */
sys$canexh(0);
/* make the message a little more meaningful */
sys$exit (SS$_EXASTLM);
}
/*****************************************************************************/
/*
Post-process the read for both blocking and non-block I/O. This function
contains code that attempts to check for HTTP transactions with an SSL service.
*/
void Sesola_netio_read_ast (SESOLA_STRUCT *sesolaptr)
{
char *cptr;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
ioptr = sesolaptr->NetIoPtr;
if (WATCHMOD (ioptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(ioptr), WATCH_MOD_SESOLA,
"Sesola_netio_read_ast() !&X !&F !&S !&S !UL",
ioptr, &Sesola_netio_read_ast, ioptr->VmsStatus,
sesolaptr->ReadIOsb.Status, sesolaptr->ReadIOsb.Count);
if (ioptr->VmsStatus)
{
/* deliver explicitly set status */
ioptr->ReadIOsb.Status = ioptr->VmsStatus;
ioptr->ReadIOsb.Count = 0;
}
if (WATCHING (ioptr, WATCH_THIS) &&
(WATCH_CATEGORY(WATCH_NETWORK) ||
WATCH_CATEGORY(WATCH_NETWORK_OCTETS)))
{
WatchThis (WATCHITM(ioptr), WATCH_NETWORK,
"READ !&S !UL bytes CIPHER (!&?non-blocking\rblocking\r)",
sesolaptr->ReadIOsb.Status, sesolaptr->ReadIOsb.Count,
SESOLA_NETIO_READ_IN_PROGRESS(sesolaptr));
if (WATCH_CATEGORY(WATCH_NETWORK_OCTETS))
WatchDataDump (sesolaptr->ReadRawPtr, sesolaptr->ReadIOsb.Count);
}
if (VMSok (sesolaptr->ReadIOsb.Status))
{
if (!sesolaptr->ReadIOsb.Count)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
sesolaptr->Sesola_read_ErrorCount = 0;
/* if first read then check for what might be HTTP */
if (!ioptr->BytesRawRx64)
{
/* first SSL/TLS octet should be 0x16 then major/minor (e.g. 0x0301) */
cptr = sesolaptr->ReadRawPtr;
if (*cptr >= 'A' && *cptr <= 'Z' &&
(SAME4 (cptr, 'GET ') ||
SAME4 (cptr, 'HEAD') ||
SAME4 (cptr, 'POST') ||
SAME4 (cptr, 'CONN') ||
SAME4 (cptr, 'COPY') ||
SAME4 (cptr, 'DELE') ||
SAME4 (cptr, 'LOCK') ||
SAME4 (cptr, 'MKCO') ||
SAME4 (cptr, 'MOVE') ||
SAME4 (cptr, 'OPTI') ||
SAME4 (cptr, 'PRI ') || /* i.e. HTTP/2 preface */
SAME4 (cptr, 'PROP') ||
SAME4 (cptr, 'PUT ') ||
SAME4 (cptr, 'TRAC') ||
SAME4 (cptr, 'UNLO') ||
MATCH5 (cptr, "HTTP/")))
{
/* ordinarily this status never would occur with network I/O */
sesolaptr->ReadIOsb.Status = SS$_BADESCAPE;
sesolaptr->HTTPduringHandshake = true;
}
else
if (SAME4 (cptr, 'SSH-'))
{
/* ordinarily this status never would occur with network I/O */
sesolaptr->ReadIOsb.Status = SS$_BADESCAPE;
sesolaptr->SSHduringHandshake = true;
/* store the fifth character from the handshake (version digit) */
ioptr->SSHversionDigit = cptr[4];
}
}
sesolaptr->BlocksTallyRx64++;
sesolaptr->BytesTallyRx64 += sesolaptr->ReadIOsb.Count;
}
if (VMSnok (sesolaptr->ReadIOsb.Status))
{
if (sesolaptr->Sesola_read_ErrorCount++ > 8192)
ErrorExitVmsStatus (sesolaptr->ReadIOsb.Status,
ErrorSanityCheck, FI_LI);
ioptr->ReadErrorCount++;
/* just note the first error status */
if (!ioptr->ReadErrorStatus)
ioptr->ReadErrorStatus = sesolaptr->ReadIOsb.Status;
if (!(sesolaptr->ReadIOsb.Status == SS$_ABORT ||
sesolaptr->ReadIOsb.Status == SS$_BADESCAPE || /* see above */
sesolaptr->ReadIOsb.Status == SS$_CANCEL ||
sesolaptr->ReadIOsb.Status == SS$_CONNECFAIL ||
sesolaptr->ReadIOsb.Status == SS$_IVCHAN ||
sesolaptr->ReadIOsb.Status == SS$_LINKDISCON ||
sesolaptr->ReadIOsb.Status == SS$_TIMEOUT ||
sesolaptr->ReadIOsb.Status == SS$_UNREACHABLE || /* MultiNet? */
sesolaptr->ReadIOsb.Status == 0)) /* TCP/IP Services? */
ErrorNoticed (NULL, sesolaptr->ReadIOsb.Status, NULL, FI_LI);
sesolaptr->ReadIOsb.Count = 0;
}
BIO_clear_retry_flags (sesolaptr->BioPtr);
/* if blocking I/O then just return */
if (!sesolaptr->ReadInProgress) return;
sesolaptr->ReadInProgress = false;
sesolaptr->ReadIsComplete = true;
if (sesolaptr->SslStateFunction)
SysDclAst (sesolaptr->SslStateFunction, sesolaptr);
else
SesolaNetIoRead (ioptr, NULL, 0);
}
/****************************************************************************/
/*
Ensure any memory that may have ben allocated (see SesolaClientRequestData())
but not fully consumed (see SesolaNetIoRead()) during client certiicate
renegotiation is freed at the conclusion of each request.
*/
void SesolaNetIoReset (NETIO_STRUCT *ioptr)
{
SESOLA_STRUCT *sesolaptr;
/*********/
/* begin */
/*********/
sesolaptr = ioptr->SesolaPtr;
if (WATCHMOD (sesolaptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(sesolaptr), WATCH_MOD_SESOLA, "SesolaNetIoReset()");
if (sesolaptr->VerifyPeerDataSize)
{
VmFree (sesolaptr->VerifyPeerDataPtr, FI_LI);
sesolaptr->VerifyPeerDataPtr = sesolaptr->VerifyPeerReadPtr = NULL;
sesolaptr->VerifyPeerDataCount = sesolaptr->VerifyPeerDataSize = 0;
}
}
/****************************************************************************/
/*
Return true if there is the merest whiff of I/O going on.
*/
BOOL SesolaNetIoInProgress (NETIO_STRUCT *ioptr)
{
SESOLA_STRUCT *sesolaptr;
/*********/
/* begin */
/*********/
sesolaptr = ioptr->SesolaPtr;
if (WATCHMOD (sesolaptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(sesolaptr), WATCH_MOD_SESOLA,
"SesolaNetIoInProgress() !&B !&B !&A",
sesolaptr->WriteInProgress,
sesolaptr->ReadInProgress,
sesolaptr->SslStateFunction);
return (sesolaptr->WriteInProgress ||
sesolaptr->ReadInProgress ||
sesolaptr->SslStateFunction);
}
/****************************************************************************/
/*
Explicitly set the status to SS$_CANCEL and cancel any actual I/O.
*/
void SesolaNetIoCancel (NETIO_STRUCT *ioptr)
{
SESOLA_STRUCT *sesolaptr;
/*********/
/* begin */
/*********/
sesolaptr = ioptr->SesolaPtr;
if (WATCHMOD (sesolaptr, WATCH_MOD_SESOLA))
WatchThis (WATCHITM(sesolaptr), WATCH_MOD_SESOLA, "SesolaNetIoCancel()");
sesolaptr->NetIoPtr->VmsStatus = SS$_CANCEL;
if (sesolaptr->WriteInProgress || sesolaptr->ReadInProgress)
sys$cancel (sesolaptr->NetIoPtr->Channel);
}
/*****************************************************************************/
/*
For compilations without SSL these functions provide LINKage stubs for the
rest of the HTTPd modules, allowing for just recompiling the Sesola module to
integrate the SSL functionality.
*/
/*********************/
#else /* not SESOLA */
/*********************/
/* external storage */
extern char ErrorSanityCheck[];
BOOL SesolaNetIoCancel (void *sesolaptr)
{
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
int SesolaNetIoWrite
(
NETIO_STRUCT *ioptr,
void *DataPtr,
int DataLength
)
{
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
void SesolaNetIoWriteAst (void *sesolaptr)
{
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
int SesolaNetIoRead
(
NETIO_STRUCT *ioptr,
void *DataPtr,
int DataSize
)
{
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
void SesolaNetIoReadAst (void *sesolaptr)
{
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
void Sesola_netio_read_ast (void *sesolaptr)
{
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
void Sesola_netio_write_ast (void *sesolaptr)
{
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
void SesolaNetIoReset (void *sesolaptr)
{
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
BOOL SesolaNetIoInProgress (NETIO_STRUCT *ioptr)
{
return (false);
}
/************************/
#endif /* ifdef SESOLA */
/************************/
/*****************************************************************************/