[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]
/*****************************************************************************/
#ifdef COMMENTS_WITH_COMMENTS
/*
wsLIBcl.c
An additional component of the wsLIB WebSocket library for WASD persistent
WebSocket scripts. This module provides functionality to connect to a server
host and port and undertake a WebSocket upgrade handshake. This establishes a
TCP/IP socket that WSLIB.C functions recognise and can use to support client
WebSocket actions. It is less intended to be a real-world client library than
a vehicle for bench-testing the WASD WebSocket and WSLIB.C functionality.
See WS_BENCHC.C utility for a usage example.
FUNCTIONS
---------
int WsLibClConnect
(
struct WsLibStruct *wsptr,
char *ServerHost,
int ServerPort,
char *RequestUri,
void *AstFunction
)
Connects via clear-text TCP/IP to the specified server host and port
and performs a WebSocket upgrade handshake.
int WsLibClSocketStatus (struct WsLibStruct *wsptr)
Returns the the current (most recent) TCP/IP socket status.
This is essentially the VMS status of the HTTP WebSocket upgrade request.
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
---------------
06-DEC-2014 MGD WsLibcl__Init()
06-FEB-2011 MGD WsLibCl__ConnAst() port 8080 kludge for proxy development
13-JUN-2011 MGD initial
*/
#endif /* COMMENTS_WITH_COMMENTS */
/*****************************************************************************/
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <descrip.h>
#include <iodef.h>
#include <ssdef.h>
#include <stsdef.h>
#include <syidef.h>
/* IP-related header files */
#include <socket.h>
#include <in.h>
#include <netdb.h>
#include <inet.h>
#include "../httpd/base64.h"
#include "../httpd/sha1.h"
#include "wslib.h"
#ifndef EFN$C_ENF
# define EFN$C_ENF 128 /* Event No Flag (no stored state) */
#endif
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define FI_LI "WSLIBCL", __LINE__
#if 1
#define WATCH_WSLIB if(wsptr->WatchScript)WsLibWatchScript
#else
#define WATCH_WSLIB if(0)WsLibWatchScript
#endif
/* can be set non-zero by external module, see WsLibClBreakNow() */
int WsLibClBreakEvery = 0,
WsLibClBreakCount;
static $DESCRIPTOR (InetDeviceDsc, "UCX$DEVICE");
static int OptionEnabled = 1,
EfnWait,
EfnNoWait;
static struct {
unsigned short Length;
unsigned short Parameter;
char *Address;
} ReuseAddr =
{ sizeof(OptionEnabled), TCPIP$C_REUSEADDR, (void*)&OptionEnabled },
NoDelaysAtAll [] = {
{ sizeof(OptionEnabled), TCPIP$C_TCP_NODELAY, (void*)&OptionEnabled },
{ sizeof(OptionEnabled), TCPIP$C_TCP_NODELACK, (void*)&OptionEnabled },
},
NoDelAck =
{ sizeof(OptionEnabled), TCPIP$C_TCP_NODELACK, (void*)&OptionEnabled },
NoDelay =
{ sizeof(OptionEnabled), TCPIP$C_TCP_NODELAY, (void*)&OptionEnabled },
ReuseAddressSocketOption =
{ sizeof(ReuseAddr), TCPIP$C_SOCKOPT, (void*)&ReuseAddr },
NoDelAckTcpOption =
{ sizeof(NoDelAck), TCPIP$C_TCPOPT, (void*)&NoDelAck },
NoDelayTcpOption =
{ sizeof(NoDelay), TCPIP$C_TCPOPT, (void*)&NoDelay },
NoDelaysAtAllTcpOption =
{ sizeof(NoDelaysAtAll), TCPIP$C_TCPOPT, (void*)&NoDelaysAtAll };
static struct {
unsigned short Protocol;
unsigned char Type;
unsigned char Family;
} TcpSocket = { TCPIP$C_TCP, INET_PROTYP$C_STREAM, TCPIP$C_AF_INET };
/***
#define __VAX
#undef __ALPHA
***/
/*****************************************************************************/
/*
Make a TCP/IP connection to the specified HTTP server name and port. When
network connected send an HTTP request to upgrade the connection to WebSocket.
If an AST function is supplied then this function completes asynchronously.
*/
int WsLibClConnect
(
struct WsLibStruct *wsptr,
char *ServerHost,
int ServerPort,
char *RequestUri,
void *AstFunction
)
{
int status;
char *cptr, *sptr, *zptr;
struct hostent *HostEntryPtr;
/*********/
/* begin */
/*********/
if (getenv("WATCH_SCRIPT")) wsptr->WatchScript = 1;
WsLibCl__Init ();
if (!ServerPort) ServerPort = 80;
HostEntryPtr = gethostbyname (ServerHost);
if (!HostEntryPtr) return (vaxc$errno);
/* allocate required storage */
wsptr->ClientAcceptSize = 64;
wsptr->ClientAcceptPtr = calloc (1, wsptr->ClientAcceptSize);
if (!wsptr->ClientAcceptPtr) return (vaxc$errno);
wsptr->ClientHeaderSize = 512;
wsptr->ClientHeaderPtr = calloc (1, wsptr->ClientHeaderSize);
if (!wsptr->ClientHeaderPtr) return (vaxc$errno);
wsptr->ClientKeySize = 32;
wsptr->ClientKeyPtr = calloc (1, wsptr->ClientKeySize);
if (!wsptr->ClientKeyPtr) return (vaxc$errno);
wsptr->ClientServerSize = 128;
wsptr->ClientServerPtr = calloc (1, wsptr->ClientServerSize);
if (!wsptr->ClientServerPtr) return (vaxc$errno);
wsptr->ClientUriSize = 256;
wsptr->ClientUriPtr = calloc (1, wsptr->ClientUriSize);
if (!wsptr->ClientUriPtr) return (vaxc$errno);
wsptr->SocketName.sin_family = HostEntryPtr->h_addrtype;
wsptr->SocketName.sin_port = htons (ServerPort);
wsptr->SocketName.sin_addr = *((struct in_addr *)HostEntryPtr->h_addr);
wsptr->SocketNameItem[0] = sizeof(wsptr->SocketName);
wsptr->SocketNameItem[1] = (int)&wsptr->SocketName;
if (strchr (HostEntryPtr->h_name, '.'))
cptr = HostEntryPtr->h_name;
else
cptr = ServerHost;
zptr = (sptr = wsptr->ClientServerPtr) + wsptr->ClientServerSize-1;
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
*sptr = '\0';
wsptr->ClientServerPort = ServerPort;
zptr = (sptr = wsptr->ClientUriPtr) + wsptr->ClientUriSize-1;
for (cptr = RequestUri; *cptr && sptr < zptr; *sptr++ = *cptr++);
*sptr = '\0';
/* assign a channel to the internet template device */
status = sys$assign (&InetDeviceDsc, &wsptr->SocketChannel, 0, 0);
if (VMSnok (status)) return (status);
/* make the channel a TCP, connection-oriented socket */
status = sys$qiow (EfnWait, wsptr->SocketChannel, IO$_SETMODE,
&wsptr->SocketIOsb, 0, 0,
&TcpSocket, 0, 0, 0, &ReuseAddressSocketOption, 0);
if (VMSok (status)) status = wsptr->SocketIOsb.iosb$w_status;
if (VMSnok (status))
{
sys$dassgn (wsptr->SocketChannel);
wsptr->SocketChannel = 0;
return (status);
}
/* turn off Nagle algorithm and acknowlegement delay (the default) */
status = sys$qiow (EfnWait, wsptr->SocketChannel, IO$_SETMODE,
&wsptr->SocketIOsb, 0, 0,
0, 0, 0, 0, &NoDelaysAtAllTcpOption, 0);
if (VMSok (status)) status = wsptr->SocketIOsb.iosb$w_status;
if (VMSnok (status))
{
sys$dassgn (wsptr->SocketChannel);
wsptr->SocketChannel = 0;
return (status);
}
if (wsptr->ConnectAstFunction = AstFunction)
status = sys$qio (EfnNoWait, wsptr->SocketChannel, IO$_ACCESS,
&wsptr->SocketIOsb, &WsLibCl__ConnAst, wsptr,
0, 0, &wsptr->SocketNameItem, 0, 0, 0);
else
{
status = sys$qiow (EfnWait, wsptr->SocketChannel, IO$_ACCESS,
&wsptr->SocketIOsb, &WsLibCl__ConnAst, wsptr,
0, 0, &wsptr->SocketNameItem, 0, 0, 0);
if (VMSok (status)) status = wsptr->SocketIOsb.iosb$w_status;
}
return (status);
}
/*****************************************************************************/
/*
Connection to server has completed (either successfully or unsuccessfully).
*/
static void WsLibCl__ConnAst (struct WsLibStruct *wsptr)
{
static $DESCRIPTOR (HeaderFaoDsc,
"GET !AZ HTTP/1.1\r\n\
Host: !AZ!AZ\r\n\
Upgrade: websocket\r\n\
Connection: Upgrade\r\n\
Sec-WebSocket-Key: !AZ\r\n\
Sec-WebSocket-Version: !UL\r\n\
\r\n\0");
static $DESCRIPTOR (HeaderDsc, "");
static unsigned long RandomNumber,
RandomFiller;
int cnt, status,
Base64Len;
unsigned short HeaderLength;
unsigned long Key16 [4];
char KeyGuid [96],
HostPort [16];
unsigned char KeyGuidHash [20];
SHA1Context Sha1Ctx;
/*********/
/* begin */
/*********/
status = wsptr->SocketIOsb.iosb$w_status;
if (VMSnok (wsptr->SocketIOsb.iosb$w_status))
{
/*****************/
/* connect error */
/*****************/
sys$dassgn (wsptr->SocketChannel);
wsptr->SocketChannel = 0;
if (wsptr->ConnectAstFunction)
{
sys$dclast (wsptr->ConnectAstFunction, wsptr, 0, 0);
wsptr->ConnectAstFunction = NULL;
}
return;
}
/**********************/
/* build HTTP upgrade */
/**********************/
/* pseudo-random 16 bytes */
if (!(RandomNumber & 0xff)) sys$gettim (&RandomNumber);
for (cnt = 0; cnt < 4; cnt++)
Key16[cnt] = RandomNumber = RandomNumber * 69069 + 1;
/* this will be the Sec-WebSocket-Key: field */
Base64Len = wsptr->ClientKeySize;
base64_encode ((unsigned char*)wsptr->ClientKeyPtr, &Base64Len,
(unsigned char*)Key16, 16);
/* also generate the expected server Sec-WebSocket-Accept: value */
strcpy (KeyGuid, wsptr->ClientKeyPtr);
strcat (KeyGuid, WSLIB_GUID);
/* which will be used to ... */
SHA1Reset (&Sha1Ctx);
SHA1Input (&Sha1Ctx, (unsigned char*)KeyGuid, strlen(KeyGuid));
if (!SHA1Result (&Sha1Ctx)) WsLibExit (NULL, FI_LI, SS$_BUGCHECK);
/* copy into the hash buffer (converting from big to little endian) */
SHA1LitEnd (&Sha1Ctx, KeyGuidHash);
/* ... compare to the server response Sec-WebSocket-Accept: */
Base64Len = wsptr->ClientAcceptSize;
base64_encode ((unsigned char*)wsptr->ClientAcceptPtr, &Base64Len,
(unsigned char*)KeyGuidHash, sizeof(KeyGuidHash));
if (wsptr->ClientServerPort == 80 ||
wsptr->ClientServerPort == 8080)
HostPort[0] = '\0';
else
sprintf (HostPort, ":%d", wsptr->ClientServerPort);
HeaderDsc.dsc$a_pointer = wsptr->ClientHeaderPtr;
HeaderDsc.dsc$w_length = wsptr->ClientHeaderSize;
status = sys$fao (&HeaderFaoDsc, &HeaderLength, &HeaderDsc,
wsptr->ClientUriPtr,
wsptr->ClientServerPtr, HostPort,
wsptr->ClientKeyPtr,
wsptr->WebSocketVersion);
if (VMSnok (status)) WsLibExit (NULL, FI_LI, status);
/* not including the null terminator */
HeaderLength--;
/****************/
/* send request */
/****************/
WATCH_WSLIB (wsptr, FI_LI, "!#AZ", HeaderLength, wsptr->ClientHeaderPtr);
if (wsptr->ConnectAstFunction)
status = sys$qio (EfnNoWait, wsptr->SocketChannel, IO$_WRITEVBLK,
&wsptr->SocketIOsb, WsLibCl__ConnRequAst, wsptr,
wsptr->ClientHeaderPtr, HeaderLength, 0, 0, 0, 0);
else
status = sys$qiow (EfnWait, wsptr->SocketChannel, IO$_WRITEVBLK,
&wsptr->SocketIOsb, WsLibCl__ConnRequAst, wsptr,
wsptr->ClientHeaderPtr, HeaderLength, 0, 0, 0, 0);
WsLibClBreakNow (wsptr);
}
/*****************************************************************************/
/*
Request header write has completed (either successfully or unsuccessfully).
*/
static void WsLibCl__ConnRequAst (struct WsLibStruct *wsptr)
{
int status;
/*********/
/* begin */
/*********/
if (VMSnok (wsptr->SocketIOsb.iosb$w_status))
{
/* write error */
sys$dassgn (wsptr->SocketChannel);
wsptr->SocketChannel = 0;
if (wsptr->ConnectAstFunction)
{
sys$dclast (wsptr->ConnectAstFunction, wsptr, 0, 0);
wsptr->ConnectAstFunction = NULL;
}
return;
}
/* peek at response header */
if (wsptr->ConnectAstFunction)
status = sys$qio (EfnNoWait, wsptr->SocketChannel, IO$_READLBLK,
&wsptr->SocketIOsb, WsLibCl__ConnResp1Ast, wsptr,
wsptr->ClientHeaderPtr, wsptr->ClientHeaderSize-1,
0, TCPIP$C_MSG_PEEK, 0, 0);
else
status = sys$qiow (EfnWait, wsptr->SocketChannel, IO$_READLBLK,
&wsptr->SocketIOsb, WsLibCl__ConnResp1Ast, wsptr,
wsptr->ClientHeaderPtr, wsptr->ClientHeaderSize-1,
0, TCPIP$C_MSG_PEEK, 0, 0);
}
/*****************************************************************************/
/*
Assume the response header is complete in the single peek! Calculate the
length of the response header and then read just that many bytes. This appears
necessary because at least the Autobahn test suite sends the first frame at
the same time as the response header. Orchestrating reads with $QIO means this
peek+read is the most practical way to negotiate past the response header.
*/
void WsLibCl__ConnResp1Ast (struct WsLibStruct *wsptr)
{
int status;
char *cptr;
/*********/
/* begin */
/*********/
WATCH_WSLIB (wsptr, FI_LI, "PEEK %X!8XL", wsptr->SocketIOsb.iosb$w_status);
if (VMSnok (wsptr->SocketIOsb.iosb$w_status))
{
/**************/
/* read error */
/**************/
sys$dassgn (wsptr->SocketChannel);
wsptr->SocketChannel = 0;
if (wsptr->ConnectAstFunction)
{
sys$dclast (wsptr->ConnectAstFunction, wsptr, 0, 0);
wsptr->ConnectAstFunction = NULL;
}
return;
}
/* scan down to the header-terminating empty line */
wsptr->ClientHeaderPtr[wsptr->SocketIOsb.iosb$w_bcnt] = '\0';
cptr = wsptr->ClientHeaderPtr;
while (*cptr)
{
while (*cptr && *cptr != '\r' && *cptr != '\n') cptr++;
if (*cptr == '\r') cptr++;
if (*cptr == '\n') cptr++;
if (*cptr != '\r') continue;
cptr++;
if (*cptr != '\n') continue;
cptr++;
break;
}
/* read response header */
if (wsptr->ConnectAstFunction)
status = sys$qio (EfnNoWait, wsptr->SocketChannel, IO$_READLBLK,
&wsptr->SocketIOsb, WsLibCl__ConnResp2Ast, wsptr,
wsptr->ClientHeaderPtr, cptr - wsptr->ClientHeaderPtr,
0, 0, 0, 0);
else
status = sys$qiow (EfnWait, wsptr->SocketChannel, IO$_READLBLK,
&wsptr->SocketIOsb, WsLibCl__ConnResp2Ast, wsptr,
wsptr->ClientHeaderPtr, cptr - wsptr->ClientHeaderPtr,
0, 0, 0, 0);
}
/*****************************************************************************/
/*
Assume the response header is complete in the single read!
*/
void WsLibCl__ConnResp2Ast (struct WsLibStruct *wsptr)
{
int ConUpgrade,
EndOfHeader,
Http11,
HttpStatus,
SecAccept,
UpgradeWebSocket;
char *cptr, *lptr, *sptr, *zptr,
*HttpStatusPtr;
/*********/
/* begin */
/*********/
WATCH_WSLIB (wsptr, FI_LI, "READ %X!8XL", wsptr->SocketIOsb.iosb$w_status);
if (VMSnok (wsptr->SocketIOsb.iosb$w_status))
{
/**************/
/* read error */
/**************/
sys$dassgn (wsptr->SocketChannel);
wsptr->SocketChannel = 0;
if (wsptr->ConnectAstFunction)
{
sys$dclast (wsptr->ConnectAstFunction, wsptr, 0, 0);
wsptr->ConnectAstFunction = NULL;
}
return;
}
ConUpgrade = EndOfHeader = Http11 = SecAccept = UpgradeWebSocket = 0;
wsptr->ClientHeaderPtr[wsptr->SocketIOsb.iosb$w_bcnt] = '\0';
cptr = wsptr->ClientHeaderPtr;
WATCH_WSLIB (wsptr, FI_LI, "!AZ", cptr);
/* response header line */
if (!memcmp (cptr, "HTTP/1.1", 8)) Http11 = 1;
while (*cptr && *cptr != ' ' && *cptr != '\r' && *cptr != '\n') cptr++;
while (*cptr == ' ' && *cptr != '\r' && *cptr != '\n') cptr++;
HttpStatus = atoi(cptr);
HttpStatusPtr = cptr;
while (*cptr && *cptr != '\r' && *cptr != '\n') cptr++;
if (*cptr) *cptr++ = '\0';
while (*cptr)
{
lptr = cptr;
if (toupper(*cptr) == 'C' &&
!strncmp (cptr, "Connection:", 11))
{
cptr += 11;
while (isspace(*cptr) && *cptr != '\r' && *cptr != '\n') cptr++;
wsptr->ServerConnectionPtr = cptr;
while (*cptr && *cptr != '\r' && *cptr != '\n') *cptr++;
if (*cptr) *cptr++ = '\0';
if (strstr (wsptr->ServerConnectionPtr, "Upgrade") ||
strstr (wsptr->ServerConnectionPtr, "upgrade"))
ConUpgrade = 1;
}
else
if (toupper(*cptr) == 'S' &&
!strncmp (cptr, "Sec-WebSocket-Accept:", 21))
{
cptr += 21;
while (isspace(*cptr) && *cptr != '\r' && *cptr != '\n') cptr++;
wsptr->ServerAcceptPtr = cptr;
while (*cptr && *cptr != '\r' && *cptr != '\n') *cptr++;
if (*cptr) *cptr++ = '\0';
if (!strcmp (wsptr->ServerAcceptPtr, wsptr->ClientAcceptPtr))
SecAccept = 1;
}
else
if (toupper(*cptr) == 'S' &&
!strncmp (cptr, "Server:", 7))
{
cptr += 7;
while (isspace(*cptr) && *cptr != '\r' && *cptr != '\n') cptr++;
wsptr->ServerSoftwarePtr = cptr;
while (*cptr && *cptr != '\r' && *cptr != '\n') *cptr++;
if (*cptr) *cptr++ = '\0';
}
else
if (toupper(*cptr) == 'U' &&
!strncmp (cptr, "Upgrade:", 8))
{
cptr += 8;
while (isspace(*cptr) && *cptr != '\r' && *cptr != '\n') cptr++;
wsptr->ServerUpgradePtr = cptr;
while (*cptr && *cptr != '\r' && *cptr != '\n') *cptr++;
if (*cptr) *cptr++ = '\0';
if (strstr (wsptr->ServerUpgradePtr, "websocket"))
UpgradeWebSocket = 1;
}
while (*cptr && *cptr != '\r' && *cptr != '\n') cptr++;
if (*cptr == '\r') cptr++;
if (*cptr == '\n') cptr++;
if (!*cptr) break;
if (*(USHORTPTR)cptr == '\r\n' || *cptr == '\n' )
{
EndOfHeader = 1;
break;
}
}
if (!Http11 || HttpStatus != 101 || !EndOfHeader)
wsptr->SocketIOsb.iosb$w_status = SS$_PROTOCOL;
else
if (!ConUpgrade || !SecAccept || !UpgradeWebSocket)
wsptr->SocketIOsb.iosb$w_status = SS$_PROTOCOL;
else
wsptr->SocketIOsb.iosb$w_status = SS$_NORMAL;
if (VMSok (wsptr->SocketIOsb.iosb$w_status))
{
/* once connected channels become synonymous */
wsptr->InputChannel = wsptr->OutputChannel = wsptr->SocketChannel;
}
else
{
sys$dassgn (wsptr->SocketChannel);
wsptr->SocketChannel = 0;
}
if (wsptr->ConnectAstFunction)
{
sys$dclast (wsptr->ConnectAstFunction, wsptr, 0, 0);
wsptr->ConnectAstFunction = NULL;
}
WsLibClBreakNow (wsptr);
}
/*****************************************************************************/
/*
Return the socket status value (essentially connect status).
*/
int WsLibClSocketStatus (struct WsLibStruct *wsptr)
{
/*********/
/* begin */
/*********/
return (wsptr->SocketIOsb.iosb$w_status);
}
/*****************************************************************************/
/*
Set the maxiumum record szie for the WebSocket. Return the previous value.
*/
int WsLibClSetSocketMrs
(
struct WsLibStruct *wsptr,
int MaxRecSize
)
{
int PrevMaxRecSize;
/*********/
/* begin */
/*********/
PrevMaxRecSize = wsptr->OutputMrs;
if ((wsptr->InputMrs = wsptr->OutputMrs = MaxRecSize) > 65535)
wsptr->InputMrs = wsptr->OutputMrs = 65535;
return (PrevMaxRecSize);
}
/****************************************************************************/
/*
At the specified proportion randomly sever the connection abruptly and return
true, else return false if connection not broken. This function really only
exists to support the exercisor or WS_BENCHC.C test-bench utility.
*/
int WsLibClBreakNow (struct WsLibStruct *wsptr)
{
static int RandomNumber,
RandomFiller;
/*********/
/* begin */
/*********/
if (!WsLibClBreakEvery) return (FALSE);
if (!RandomNumber) sys$gettim (&RandomNumber);
RandomNumber = RandomNumber * 69069 + 1;
if (RandomNumber % WsLibClBreakEvery) return (FALSE);
Shut (wsptr);
WsLibClBreakCount++;
return (TRUE);
}
/*****************************************************************************/
/*
Initialise the client library.
*/
void WsLibCl__Init ()
{
static char GetSyiVer [8];
static struct
{
unsigned short buf_len;
unsigned short item;
void *buf_addr;
void *ret_len;
} SyiItem [] =
{
{ sizeof(GetSyiVer)-1, SYI$_VERSION, &GetSyiVer, 0 },
{ 0,0,0,0 }
};
int status,
VersionInteger;
/*********/
/* begin */
/*********/
/* just the once! */
if (EfnWait) return;
status = sys$getsyiw (0, 0, 0, &SyiItem, 0, 0, 0);
if (VMSnok (status)) WsLibExit (NULL, FI_LI, status);
VersionInteger = ((GetSyiVer[1]-48) * 100) + ((GetSyiVer[3]-48) * 10);
if (GetSyiVer[4] == '-') VersionInteger += GetSyiVer[5]-48;
if (VersionInteger >= 700)
EfnWait = EfnNoWait = EFN$C_ENF;
else
{
if (VMSnok (status = lib$get_ef (&EfnWait)))
WsLibExit (NULL, FI_LI, status);;
if (VMSnok (status = lib$get_ef (&EfnNoWait)))
WsLibExit (NULL, FI_LI, status);;
}
}
/*****************************************************************************/