[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]
/*****************************************************************************/
#ifdef COMMENTS_WITH_COMMENTS
/*
raw_PTD.c
A demonstrator for CGIplus RawSocket scripts. Also see rawLIB.c source.
This essentially behaves as a telnet server and expects a client to connect
using a telnet application. The RawSocket interfaces with the system using
Pseudo-Terminal Driver. This is not intended to be used in production.
Any resemblence to any DCLinabox, living or dead, is purely coincidental :-}
Example configuration:
# WASD_CONFIG_SERVICE
[[http:*:1234]]
[ServiceRawSocket] enabled
# WASD_CONFIG_MAP
[[*:1234]]
map * /cgiplus-bin/raw_ptd
Then to test:
telnet server-host-name 1234
As a telnet client is the expected end-user application RAW_PTD.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
---------------
07-DEC-2016 MGD v1.0.0, initial development
*/
#endif /* COMMENTS_WITH_COMMENTS */
/*****************************************************************************/
#define SOFTWAREVN "1.0.0"
#define SOFTWARENM "RAW_PTD"
#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 <dvidef.h>
#include <lnmdef.h>
#include <ptddef.h>
#include <ssdef.h>
#include <stsdef.h>
#include <ttdef.h>
#include <tt2def.h>
#include "rawlib.h"
#define DC$_TERM 6
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define Debug 0
#define FI_LI "RAW_PTD", __LINE__
#define EXIT_FI_LI(status) { printf ("[%s:%d]", FI_LI); exit(status); }
/* basically the page size on the architecture */
#ifdef VAX
#define PTD_READ_SIZE 512
#define PTD_WRITE_SIZE 512
#else
#define PTD_READ_SIZE 8192
#define PTD_WRITE_SIZE 8192
#endif
#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,
UsageCount;
struct PtdClient {
/* keep these adjacent and aligned on a page boundary */
char PtdReadBuffer [PTD_READ_SIZE],
PtdWriteBuffer [PTD_WRITE_SIZE];
int PtdQueuedRead,
PtdQueuedWrite,
PtdReadCount,
PtdWriteCount,
XoffRx;
unsigned long ClientCount,
IdleCount,
IdleTime,
WriteCount;
unsigned short ptdchan;
char *WritePtr;
char ClientReadBuffer [PTD_WRITE_SIZE],
PtdDevName [64];
struct dsc$descriptor_s PtdDevNameDsc;
struct RawLibStruct *RawLibPtr;
};
long PtdClientPages = (sizeof(struct PtdClient) / 512 ) + 1;
long CharBuf [3];
/* function prototypes */
void AddClient ();
int PtdOpen (struct PtdClient*);
void PtdClose (struct PtdClient*);
int PtdCrePrc (struct PtdClient*);
void PtdRead (struct PtdClient*);
void PtdReadClient (struct RawLibStruct*);
void PtdRemoveClient (struct RawLibStruct *rawptr);
void PtdReadAst (struct PtdClient*);
void PtdReadWriteAst (struct RawLibStruct*);
void PtdReadWriteDelay (struct RawLibStruct*);
void PtdXoffAst (struct PtdClient*);
void PtdXonAst (struct PtdClient*);
void PtdWrite (struct PtdClient*, char*, int);
void PtdWriteAst (struct PtdClient*);
char* SysTrnLnm (char*, char*, int);
uchar* TelnetCommand (struct RawLibStruct*, uchar*, int);
void TelnetLineMode (struct RawLibStruct*);
/*****************************************************************************/
/*
AST delivery is disabled during client acceptance and the add-client function
is deferred using an AST to help minimise the client setup window with a
potentially busy RawSocket application.
*/
main (int argc, char *argv[])
{
int len;
char *aptr, *cptr, *sptr, *zptr,
*wxh;
/*********/
/* begin */
/*********/
/* don't want the C-RTL fiddling with the carriage control */
stdout = freopen ("SYS$OUTPUT", "w", stdout, "ctx=bin");
RawLibInit ();
/* set the terminal characteristics */
CharBuf[0] = (80 << 16) | (TT$_LA100 << 8) | DC$_TERM;
CharBuf[1] = (24 << 24) |
TT$M_EIGHTBIT | TT$M_SCOPE | TT$M_WRAP |
TT$M_MECHTAB | TT$M_LOWER | TT$M_TTSYNC;
CharBuf[2] = TT2$M_EDIT | TT2$M_DRCS | TT2$M_EDITING | TT2$M_HANGUP;
/* no clients is two minutes in seconds */
RawLibSetLifeSecs (2*60);
for (;;)
{
RawLibCgiVar ("");
if (!RawLibIsCgiPlus())
{
/* must be CGIplus */
fprintf (stdout, "Status: 500\r\n\r\nMust be CGIplus!\n");
exit (SS$_NORMAL);
}
sys$setast (0);
UsageCount++;
AddClient ();
sys$setast (1);
RawLibCgiPlusEof ();
}
exit (SS$_NORMAL);
}
/*****************************************************************************/
/*
Allocate a client structure and add it to the head of the list. Establish the
RawSocket IPC, create the user terminal (and process if SSO) and begin
processing.
*/
void AddClient ()
{
int status;
struct PtdClient *clptr;
/*********/
/* begin */
/*********/
/* PTD$ buffers must be page aligned */
status = lib$get_vm_page (&PtdClientPages, &clptr);
if (VMSnok(status)) EXIT_FI_LI (status);
memset (clptr, 0, sizeof(struct PtdClient));
/* create a RawSocket library structure for the client */
if (!(clptr->RawLibPtr = RawLibCreate (clptr, PtdRemoveClient)))
{
/* failed, commonly on some RawSocket protocol issue */
status = lib$free_vm_page (&PtdClientPages, &clptr);
if (VMSnok(status)) EXIT_FI_LI (status);
return;
}
/* open the IPC to the RawSocket (mailboxes) */
status = RawLibOpen (clptr->RawLibPtr);
if (VMSnok(status)) EXIT_FI_LI(status);
status = PtdOpen (clptr);
if (VMSnok(status)) EXIT_FI_LI (status);
/* terminate the session after two minutes idle */
RawLibSetIdleSecs (clptr->RawLibPtr, 60 * 2);
RawLibWatchScript (clptr->RawLibPtr, FI_LI, "!AZ", SOFTWAREID);
TelnetLineMode (clptr->RawLibPtr);
/* queue an asynchronous read into dynamic buffer from the client */
RawLibRead (clptr->RawLibPtr, clptr->ClientReadBuffer,
sizeof(clptr->ClientReadBuffer), PtdReadClient);
ConnectedCount++;
}
/*****************************************************************************/
/*
Remove the client structure from the list and free the memory.
*/
void PtdRemoveClient (struct RawLibStruct *rawptr)
{
int status;
struct PtdClient *clptr;
/*********/
/* begin */
/*********/
clptr = RawLibGetUserData(rawptr);
if (clptr->ptdchan) status = ptd$delete (clptr->ptdchan);
status = lib$free_vm_page (&PtdClientPages, &clptr);
if (VMSnok(status)) EXIT_FI_LI (status);
if (ConnectedCount) ConnectedCount--;
}
/*****************************************************************************/
/*
Create the pseudo-terminal and begin reading from it.
*/
int PtdOpen (struct PtdClient *clptr)
{
int status;
long InAdr [2];
/*********/
/* begin */
/*********/
InAdr[0] = (int)(clptr->PtdReadBuffer);
InAdr[1] = (int)(clptr->PtdReadBuffer +
sizeof(clptr->PtdReadBuffer) +
sizeof(clptr->PtdWriteBuffer)-1);
status = ptd$create (&clptr->ptdchan, 0, CharBuf, sizeof(CharBuf),
0, 0, 0, InAdr);
if (VMSnok (status)) return (status);
status = ptd$set_event_notification (clptr->ptdchan, &PtdXonAst, clptr, 0,
PTD$C_SEND_XON);
if (VMSnok (status)) return (status);
status = ptd$set_event_notification (clptr->ptdchan, &PtdXoffAst, clptr, 0,
PTD$C_SEND_XOFF);
if (VMSnok (status)) return (status);
/* unsolicited input to get LOGINOUT to prompt for username/password */
clptr->PtdWriteBuffer[sizeof(ushort)+sizeof(ushort)] = '\r';
ptd$write (clptr->ptdchan, 0, 0, clptr->PtdWriteBuffer, 1, 0, 0);
clptr->PtdQueuedRead++;
status = ptd$read (0, clptr->ptdchan, &PtdReadAst, clptr,
clptr->PtdReadBuffer, sizeof(clptr->PtdReadBuffer));
return (status);
}
/*****************************************************************************/
/*
Cancel any outstanding terminal I/O.
*/
void PtdClose (struct PtdClient *clptr)
{
/*********/
/* begin */
/*********/
if (clptr->PtdQueuedRead || clptr->PtdQueuedWrite)
{
ptd$cancel (clptr->ptdchan);
return;
}
RawLibClose (clptr->RawLibPtr);
}
/*****************************************************************************/
/*
Data has been read from the PTD (i.e. from the system).
*/
void PtdReadAst (struct PtdClient *clptr)
{
int bcnt, status;
char *bptr, *cptr, *zptr;
/*********/
/* begin */
/*********/
if (clptr->PtdQueuedRead) clptr->PtdQueuedRead--;
status = *(ushort*)clptr->PtdReadBuffer;
if (VMSok(status))
{
bptr = clptr->PtdReadBuffer + sizeof(ushort)+sizeof(ushort);
bcnt = *(ushort*)(clptr->PtdReadBuffer + sizeof(ushort));
RawLibWrite (clptr->RawLibPtr, bptr, bcnt, PtdReadWriteAst);
}
else
PtdClose (clptr);
}
/*****************************************************************************/
/*
Data read from the PTD (system) has been written to the RawSocket client.
Check status and if OK queue another read from the PTD.
*/
void PtdReadWriteAst (struct RawLibStruct *rawptr)
{
int status;
struct PtdClient *clptr;
/*********/
/* begin */
/*********/
clptr = RawLibGetUserData(rawptr);
status = RawLibWriteStatus (rawptr);
if (VMSok (status))
{
clptr->PtdQueuedRead++;
ptd$read (0, clptr->ptdchan, &PtdReadAst, clptr,
clptr->PtdReadBuffer,
sizeof(clptr->PtdReadBuffer)-sizeof(ushort)-sizeof(ushort));
}
else
RawLibClose (rawptr);
}
/*****************************************************************************/
/*
Asynchronous read from a RawSocket client has concluded.
*/
void PtdReadClient (struct RawLibStruct *rawptr)
{
int cnt;
uchar *cptr, *czptr, *sptr;
uchar buf [PTD_WRITE_SIZE];
struct PtdClient *clptr;
/*********/
/* begin */
/*********/
if (VMSnok (RawLibReadStatus(rawptr)))
{
/* WEBSOCKET_INPUT read error (can be EOF) */
RawLibClose (rawptr);
return;
}
clptr = RawLibGetUserData(rawptr);
cnt = RawLibReadCount (rawptr);
cptr = (uchar*)RawLibReadData (rawptr);
sptr = buf;
czptr = cptr + cnt;
while (cptr < czptr)
{
if (*cptr == TELNET_IAC)
{
/* telnet interpret-as-command */
cptr = TelnetCommand (rawptr, cptr, czptr - cptr);
if (cptr >= czptr) break;
if (*cptr != TELNET_IAC) continue;
}
if (*cptr == '\r' && (cptr+1) < czptr && *(cptr+1) == '\0')
{
/* telnet <CR><NUL> */
*sptr++ = *cptr++;
cptr++;
}
else
*sptr++ = *cptr++;
}
cnt = sptr - buf;
if (cnt)
PtdWrite (clptr, (char*)buf, cnt);
else
RawLibRead (clptr->RawLibPtr, clptr->ClientReadBuffer,
sizeof(clptr->ClientReadBuffer), PtdReadClient);
/* keep track of client input (for idle timeout) */
clptr->ClientCount++;
}
/*****************************************************************************/
/*
Write the supplied data to the PTD (i.e. to the system).
*/
void PtdWrite
(
struct PtdClient *clptr,
char *DataPtr,
int DataCount
)
{
int cnt, status;
uchar *bptr, *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
cptr = (uchar*)(clptr->WritePtr = DataPtr);
cnt = clptr->WriteCount = DataCount;
sptr = bptr = (uchar*)clptr->PtdWriteBuffer + sizeof(ushort)+sizeof(ushort);
zptr = sptr + sizeof(clptr->PtdWriteBuffer) - sizeof(ushort)-sizeof(ushort);
while (cnt && sptr < zptr)
{
*sptr++ = *cptr++;
cnt--;
}
clptr->PtdWriteCount = sptr - bptr;
clptr->PtdQueuedWrite++;
ptd$write (clptr->ptdchan, PtdWriteAst, clptr,
clptr->PtdWriteBuffer, clptr->PtdWriteCount, 0, 0);
}
/*****************************************************************************/
/*
PTD write (to system) has completed. If OK continue with remaining data or
read from the RawSocket client.
*/
void PtdWriteAst (struct PtdClient *clptr)
{
int cnt, status;
/*********/
/* begin */
/*********/
if (clptr->PtdQueuedWrite) clptr->PtdQueuedWrite--;
status = *(ushort*)clptr->PtdWriteBuffer;
cnt = *(ushort*)(clptr->PtdWriteBuffer+sizeof(ushort));
/* adjust buffer window according to actual write */
clptr->WritePtr += cnt;
clptr->WriteCount -= cnt;
if (VMSok(status) ||
status == SS$_DATAOVERUN ||
status == SS$_DATALOST)
{
if (status == SS$_DATAOVERUN)
RawLibWatchScript (clptr->RawLibPtr, FI_LI, "DATAOVERUN");
else
if (status == SS$_DATALOST)
{
RawLibWatchScript (clptr->RawLibPtr, FI_LI, "DATALOST");
/* not much point continuing with this */
clptr->WriteCount = 0;
}
if (clptr->XoffRx) return;
if (clptr->WriteCount)
PtdWrite (clptr, clptr->WritePtr, clptr->WriteCount);
else
RawLibRead (clptr->RawLibPtr, clptr->ClientReadBuffer,
sizeof(clptr->ClientReadBuffer), PtdReadClient);
}
else
PtdClose (clptr);
}
/*****************************************************************************/
/*
Flow control - stop/suspend data writes.
*/
void PtdXoffAst (struct PtdClient *clptr)
{
/*********/
/* begin */
/*********/
RawLibWatchScript (clptr->RawLibPtr, FI_LI, "XOFF");
clptr->XoffRx = 1;
}
/*****************************************************************************/
/*
Flow control - start/resume data writes.
*/
void PtdXonAst (struct PtdClient *clptr)
{
/*********/
/* begin */
/*********/
RawLibWatchScript (clptr->RawLibPtr, FI_LI, "XON");
/* ignore anything out-of-order */
if (!clptr->XoffRx) return;
clptr->XoffRx = 0;
if (clptr->WriteCount)
PtdWrite (clptr, clptr->WritePtr, clptr->WriteCount);
else
RawLibRead (clptr->RawLibPtr, clptr->ClientReadBuffer,
sizeof(clptr->ClientReadBuffer), PtdReadClient);
}
/*****************************************************************************/
/*
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);
}
/*****************************************************************************/
/*
Translate a logical name using LNM$FILE_DEV. Returns a pointer to the value
string, or NULL if the name does not exist. If 'LogValue' is supplied the
logical name is translated into that (assumed to be large enough), otherwise
it's translated into an internal static buffer. 'IndexValue' should be zero
for a 'flat' logical name, or 0..127 for interative translations.
*/
char* SysTrnLnm
(
char *LogName,
char *LogValue,
int IndexValue
)
{
static unsigned short ValueLength;
static unsigned long LnmAttributes,
LnmIndex;
static char StaticLogValue [256];
static $DESCRIPTOR (LogNameDsc, "");
static $DESCRIPTOR (LnmTableDsc, "LNM$FILE_DEV");
static struct {
short int buf_len;
short int item;
void *buf_addr;
unsigned short *ret_len;
} LnmItems [] =
{
{ sizeof(LnmIndex), LNM$_INDEX, &LnmIndex, 0 },
{ sizeof(LnmAttributes), LNM$_ATTRIBUTES, &LnmAttributes, 0 },
{ 255, LNM$_STRING, 0, &ValueLength },
{ 0,0,0,0 }
};
int status;
char *cptr;
/*********/
/* begin */
/*********/
LnmIndex = IndexValue;
LogNameDsc.dsc$a_pointer = LogName;
LogNameDsc.dsc$w_length = strlen(LogName);
if (LogValue)
cptr = LnmItems[2].buf_addr = LogValue;
else
cptr = LnmItems[2].buf_addr = StaticLogValue;
status = sys$trnlnm (0, &LnmTableDsc, &LogNameDsc, 0, &LnmItems);
if (!(status & 1) || !(LnmAttributes & LNM$M_EXISTS))
{
if (LogValue) LogValue[0] = '\0';
return (NULL);
}
cptr[ValueLength] = '\0';
return (cptr);
}
/*****************************************************************************/