[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]
/*****************************************************************************/
#ifdef COMMENTS_WITH_COMMENTS
/*
raw_echo.c
A demonstrator for CGIplus RawSocket scripts. Also see rawLIB.c source.
An example of using, and test-bench for, the string descriptor versions of the
rawLIB (RawSocket library) API.
Experiment with the RawLibOnNextRequest() approach to request synchronisation by
defining the logical name RAW_ECHO_ON_NEXT_REQUEST.
(And any resemblence to any WS_ECHO.C living or dead is purely coincidental :-)
Example configuration:
# WASD_CONFIG_SERVICE
[[http:*:1234]]
[ServiceRawSocket] enabled
# WASD_CONFIG_MAP
[[*:1234]]
map * /cgiplus-bin/raw_echo
Then to test:
telnet server-host-name 1234
^@ will switch between character and line modes
^T will print connected client data
^D and ^Z result in application disconnect
As the telnet client is the obvious end-user application RAW_ECHO.C implements
a constrained set of telnet commands and associated options.
COPYRIGHT
---------
Copyright (C) 2016-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
---------------
04-DEC-2016 MGD v1.0.0, initial development
*/
#endif /* COMMENTS_WITH_COMMENTS */
/*****************************************************************************/
#define SOFTWAREVN "1.0.0"
#define SOFTWARENM "RAW_ECHO"
#ifdef __ALPHA
# define SOFTWAREID SOFTWARENM " AXP-" SOFTWAREVN
#endif
#ifdef __ia64
# define SOFTWAREID SOFTWARENM " IA64-" SOFTWAREVN
#endif
#ifdef __VAX
# define SOFTWAREID SOFTWARENM " VAX-" SOFTWAREVN
#endif
#ifdef __x86_64
# define SOFTWAREID SOFTWARENM " X86-" SOFTWAREVN
#endif
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <descrip.h>
#include <iodef.h>
#include <ssdef.h>
#include <stsdef.h>
#include "rawlib.h"
/* from libmsg.h */
#define LIB$_INVSTRDES 1409572
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define Debug 0
#define DEFAULT_UNUSED_TIMEOUT 60
#define FI_LI "RAW_ECHO", __LINE__
#define EXIT_FI_LI(status) { printf ("[%s:%d]", FI_LI); exit(status); }
#define TELNET_SE 240 /* F0 */
#define TELNET_NOP 241 /* F1 */
#define TELNET_DM 242 /* F2 */
#define TELNET_BRK 243 /* F3 */
#define TELNET_IP 244 /* F4 */
#define TELNET_AO 245 /* F5 */
#define TELNET_AYT 246 /* F6 */
#define TELNET_EC 247 /* F7 */
#define TELNET_EL 248 /* F8 */
#define TELNET_GA 249 /* F9 */
#define TELNET_SB 250 /* FA */
#define TELNET_WILL 251 /* FB */
#define TELNET_WONT 252 /* FC */
#define TELNET_DO 253 /* FD */
#define TELNET_DONT 254 /* FE */
#define TELNET_IAC 255 /* FF */
int ConnectedCount,
UnusedTimeout = DEFAULT_UNUSED_TIMEOUT,
UsageCount;
struct EchoClient {
int CharCount,
CloseFrame,
LineCount,
LineMode,
PrevCharCount,
TelnetEcho,
TelnetBinary;
unsigned int ConnectTime,
UnusedTime;
char InputBuffer [256],
LineBuffer [256],
RemoteHost [128],
ServerName [128],
StatusBuffer [256];
struct RawLibStruct *RawLibPtr;
struct dsc$descriptor_s InputDsc,
StatusDsc;
};
/* function prototypes */
void AddClient ();
void EchoThis (struct RawLibStruct*);
void NextRequest ();
void OutputClientStatus (struct RawLibStruct*);
void OutputLine (struct RawLibStruct*);
void RemoveClient (struct RawLibStruct*);
uchar* TelnetCommand (struct RawLibStruct*, uchar*, int);
void TelnetLineMode (struct RawLibStruct*);
/*****************************************************************************/
/*
*/
main ()
{
/*********/
/* begin */
/*********/
/* don't want the C-RTL fiddling with the carriage control */
stdout = freopen ("SYS$OUTPUT", "w", stdout, "ctx=bin");
RawLibInit ();
/* no clients is two minutes in seconds */
RawLibSetLifeSecs (2*60);
if (!RawLibIsCgiPlus())
{
fprintf (stdout, "Status: 500\r\n\r\n\
RawSocket needs to be CGIplus!\n");
}
else
if (getenv("RAW_ECHO_ON_NEXT_REQUEST") != NULL)
{
RawLibOnNextRequest (NextRequest);
/* asynchronous from here-on-in */
for (;;) sys$hiber();
}
else
{
for (;;)
{
RawLibCgiVar ("");
sys$setast (0);
UsageCount++;
AddClient (0);
RawLibCgiPlusEof ();
sys$setast (1);
}
}
exit (SS$_NORMAL);
}
/*****************************************************************************/
/*
Asynchronous notification the next request is available. This function is
called at AST-delivery level and so no need to disable ASTs. Add the client
and then notify the server we're ready for another.
*/
void NextRequest ()
{
/*********/
/* begin */
/*********/
UsageCount++;
AddClient (1);
RawLibCgiPlusEof ();
}
/*****************************************************************************/
/*
Allocate a client structure and add it to the head of the list.
*/
void AddClient (int OnNext)
{
static $DESCRIPTOR (GreetingFaoDsc, "Hello !AZ !AZ (!AZ) at !AZ\r\n");
int len, status;
unsigned int CurrentTime;
char Greeting [256];
struct EchoClient *clptr;
/*********/
/* begin */
/*********/
CurrentTime = RawLibTime ();
clptr = calloc (1, sizeof(struct EchoClient));
if (!clptr) EXIT_FI_LI (vaxc$errno);
strcpy (clptr->ServerName, RawLibCgiVar("SERVER_NAME"));
strcpy (clptr->RemoteHost, RawLibCgiVar("REMOTE_HOST"));
clptr->ConnectTime = CurrentTime;
clptr->UnusedTime = CurrentTime + UnusedTimeout;
clptr->InputDsc.dsc$b_class = DSC$K_CLASS_S;
clptr->InputDsc.dsc$b_dtype = DSC$K_DTYPE_T;
clptr->StatusDsc.dsc$b_class = DSC$K_CLASS_S;
clptr->StatusDsc.dsc$b_dtype = DSC$K_DTYPE_T;
clptr->StatusDsc.dsc$a_pointer = clptr->StatusBuffer;
/* create a RawSocket library structure for the client */
if (!(clptr->RawLibPtr = RawLibCreate (clptr, RemoveClient)))
{
/* failed, commonly on some RawSocket protocol issue */
free (clptr);
return;
}
/* no user interaction is whatever's defined in seconds */
RawLibSetIdleSecs (clptr->RawLibPtr, DEFAULT_UNUSED_TIMEOUT);
/* open the IPC to the RawSocket (mailboxes) */
status = RawLibOpen (clptr->RawLibPtr);
if (VMSnok(status)) EXIT_FI_LI(status);
TelnetLineMode (clptr->RawLibPtr);
clptr->StatusDsc.dsc$w_length = sizeof(clptr->StatusBuffer);
sys$fao (&GreetingFaoDsc, &clptr->StatusDsc.dsc$w_length,
&clptr->StatusDsc, clptr->RemoteHost,
SOFTWAREID, RawLibVersion(), clptr->ServerName);
RawLibWriteDsc (clptr->RawLibPtr, &clptr->StatusDsc, RAWLIB_ASYNCH);
RawLibWrite (clptr->RawLibPtr, "[Char Mode]\r\n", 13, RAWLIB_ASYNCH);
/* queue an asynchronous read from the client */
clptr->InputDsc.dsc$a_pointer = clptr->InputBuffer;
clptr->InputDsc.dsc$w_length = sizeof(clptr->InputBuffer);
RawLibReadDsc (clptr->RawLibPtr, &clptr->InputDsc, 0, EchoThis);
ConnectedCount++;
}
/*****************************************************************************/
/*
Remove the client structure from the list and free the memory.
*/
void RemoveClient (struct RawLibStruct *rawptr)
{
struct EchoClient *clptr;
/*********/
/* begin */
/*********/
clptr = RawLibGetUserData (rawptr);
free (clptr);
if (ConnectedCount) ConnectedCount--;
}
/*****************************************************************************/
/*
Asynchronous read from a RawSocket client has concluded.
*/
void EchoThis (struct RawLibStruct *rawptr)
{
int len;
uchar *cptr, *czptr;
struct EchoClient *clptr;
/*********/
/* begin */
/*********/
if (VMSnok (RawLibReadStatus(rawptr)))
{
/* WEBSOCKET_INPUT read error (can be EOF) */
RawLibClose (rawptr);
return;
}
clptr = RawLibGetUserData(rawptr);
clptr->UnusedTime = RawLibTime() + UnusedTimeout;
/* CAUTION! with multiple concurrent write status becomes unreliable */
cptr = (uchar*)clptr->InputDsc.dsc$a_pointer;
czptr = cptr + clptr->InputDsc.dsc$w_length;
while (cptr < czptr)
{
if (*cptr == TELNET_IAC)
{
/******************/
/* telnet command */
/******************/
cptr = TelnetCommand (rawptr, cptr, czptr - cptr);
if (cptr >= czptr) break;
if (*cptr != TELNET_IAC) continue;
}
/* implicit converstion of linemode <CR><NUL> to <CR><LF> */
if (*cptr == 0x0d && *(cptr+1) == 0x00) *(cptr+1) = '\n';
if (*cptr == 0x00)
{
/**********************************/
/* per-keystroke/line toggle (^@) */
/**********************************/
if (clptr->LineMode && clptr->CharCount) OutputLine (rawptr);
clptr->CharCount = 0;
if (clptr->LineMode = !clptr->LineMode)
RawLibWrite (rawptr, "[Line Mode]\r\n", 13, NULL);
else
RawLibWrite (rawptr, "[Char Mode]\r\n", 13, NULL);
cptr++;
}
else
if (*cptr == 0x14)
{
/**********************/
/* client status (^T) */
/**********************/
OutputClientStatus (rawptr);
cptr++;
}
else
if (*cptr == 0x04 || *cptr == 0x1a)
{
/*************************/
/* disconnect (^D or ^Z) */
/*************************/
RawLibClose (rawptr);
return;
}
else
if (*cptr == 0x0d && clptr->LineMode)
{
/*********************/
/* per-line and <CR> */
/*********************/
OutputLine (rawptr);
/* step over the <CR><LF> */
cptr++;
if (cptr < czptr && *cptr == '\n') cptr++;
}
else
if (clptr->LineMode)
{
/************/
/* per line */
/************/
if (clptr->CharCount < sizeof(clptr->LineBuffer)-1)
clptr->LineBuffer[clptr->CharCount++] = *cptr;
cptr++;
}
else
{
/*****************/
/* per keystroke */
/*****************/
/* asynchronous (without AST target) */
RawLibWrite (clptr->RawLibPtr, (char*)cptr, 1, NULL);
if (*cptr == '\n')
clptr->CharCount = 0;
else
clptr->CharCount++;
cptr++;
}
}
/* queue the next asynchronous read from the client */
clptr->InputDsc.dsc$a_pointer = clptr->InputBuffer;
clptr->InputDsc.dsc$w_length = sizeof(clptr->InputBuffer);
RawLibReadDsc (rawptr, &clptr->InputDsc, 0, EchoThis);
}
/*****************************************************************************/
/*
*/
void OutputLine (struct RawLibStruct *rawptr)
{
static $DESCRIPTOR (BufferDsc, "");
static $DESCRIPTOR (LineFaoDsc, "!UL: !AS\r\n");
ushort slen;
char LineBuffer [32+256];
$DESCRIPTOR (LineDsc, LineBuffer);
struct EchoClient *clptr;
/*********/
/* begin */
/*********/
clptr = RawLibGetUserData (rawptr);
BufferDsc.dsc$a_pointer = clptr->LineBuffer;
BufferDsc.dsc$w_length = clptr->CharCount;
clptr->CharCount = 0;
sys$fao (&LineFaoDsc, &slen, &LineDsc,
++clptr->LineCount, &BufferDsc);
LineDsc.dsc$w_length = slen;
/* blocking (for the test-bench) */
RawLibWriteDsc (rawptr, &LineDsc, NULL);
}
/*****************************************************************************/
/*
*/
void OutputClientStatus (struct RawLibStruct *rawptr)
{
static $DESCRIPTOR (StatusFaoDsc,
"!AZHello !AZ; Connected: !ULS; Timeout: !ULS; \
Connected: !UL; Usage: !UL; Mode: !AZ\r\n");
int len, status;
unsigned int CurrentTime;
char StatusBuffer [256];
$DESCRIPTOR (StatusDsc, StatusBuffer);
struct EchoClient *clptr;
/*********/
/* begin */
/*********/
CurrentTime = RawLibTime ();
clptr = RawLibGetUserData (rawptr);
clptr->StatusDsc.dsc$w_length = sizeof(clptr->StatusBuffer);
sys$fao (&StatusFaoDsc,
&clptr->StatusDsc.dsc$w_length,
&clptr->StatusDsc,
clptr->CharCount && clptr->CharCount > clptr->PrevCharCount ?
"\r\n" : "",
clptr->RemoteHost,
CurrentTime - clptr->ConnectTime,
clptr->UnusedTime - CurrentTime,
ConnectedCount, UsageCount,
clptr->LineMode ? "Line" : "Char");
clptr->PrevCharCount = clptr->CharCount;
RawLibWriteDsc (rawptr, &clptr->StatusDsc, RAWLIB_ASYNCH);
}
/*****************************************************************************/
/*
Simple-minded example assumes the command and options are all in-buffer. Just
ignore all that can be gotten away with. Returns a pointer to the next
available character (if any).
*/
uchar* TelnetCommand
(
struct RawLibStruct *rawptr,
uchar *DataPtr,
int DataLength
)
{
uchar cmd;
uchar *cptr, *czptr;
/*********/
/* begin */
/*********/
/* IAC is *always* followed by a command (so we always need two) */
czptr = (cptr = DataPtr) + DataLength - 1;
while (cptr < czptr && *cptr == TELNET_IAC)
{
cptr++;
cmd = *cptr;
if (cmd == TELNET_IAC) return (cptr);
cptr++;
if (cmd == TELNET_AYT)
{
RawLibWrite (rawptr, "\a", 1, RAWLIB_ASYNCH);
continue;
}
if (cmd == TELNET_SB)
{
while (cptr < czptr)
{
if (*cptr == TELNET_IAC && *(cptr+1) == TELNET_SE)
{
cptr += 2;
break;
}
cptr++;
}
}
else
{
/* step over the option */
if (cmd == TELNET_DO ||
cmd == TELNET_DONT ||
cmd == TELNET_WILL ||
cmd == TELNET_WONT) cptr++;
}
}
return (cptr);
}
/*****************************************************************************/
/*
Request the client provides each character as entered (disable client line
buffer/edit) and the server will echo.
*/
void TelnetLineMode (struct RawLibStruct *rawptr)
{
#define OPT_ECHO 1
#define OPT_LINEMODE 34
static char DoCharBinary [] = { TELNET_IAC, TELNET_DO, OPT_LINEMODE,
TELNET_IAC, TELNET_WILL, OPT_ECHO };
/*********/
/* begin */
/*********/
RawLibWrite (rawptr, DoCharBinary, sizeof(DoCharBinary), RAWLIB_ASYNCH);
}
/*****************************************************************************/