Hibbian
/
linbpq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
linbpq/Cmd.c

5989 lines
139 KiB
C
Raw Blame History

/*
Copyright 2001-2022 John Wiseman G8BPQ
This file is part of LinBPQ/BPQ32.
LinBPQ/BPQ32 is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LinBPQ/BPQ32 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. S"paclenee the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with LinBPQ/BPQ32. If not, see http://www.gnu.org/licenses
*/
//
// C replacement for cmd.asm
//
#define Kernel
#define _CRT_SECURE_NO_DEPRECATE
#pragma data_seg("_BPQDATA")
//#include "windows.h"
//#include "winerror.h"
#include "time.h"
#include "stdio.h"
#include <fcntl.h>
//#include "vmm.h"
//#include "SHELLAPI.H"
#include "CHeaders.h"
#include "bpqaprs.h"
#include "kiss.h"
#pragma pack()
#include "tncinfo.h"
#include "telnetserver.h"
//#include "GetVersion.h"
//#define DllImport __declspec( dllimport )
//#define DllExport __declspec( dllexport )
BOOL DecodeCallString(char * Calls, BOOL * Stay, BOOL * Spy, UCHAR *AXCalls);
VOID Send_AX_Datagram(PDIGIMESSAGE Block, DWORD Len, UCHAR Port);
int APIENTRY ClearNodes();
VOID GetJSONValue(char * _REPLYBUFFER, char * Name, char * Value);
VOID SendHTTPRequest(SOCKET sock, char * Host, int Port, char * Request, char * Params, int Len, char * Return);
SOCKET OpenWL2KHTTPSock();
VOID FormatTime3(char * Time, time_t cTime);
VOID Format_Addr(unsigned char * Addr, char * Output, BOOL IPV6);
VOID Tel_Format_Addr(struct ConnectionInfo * sockptr, char * dst);
VOID FindLostBuffers();
BOOL CheckCMS(struct TNCINFO * TNC);
VOID L2SENDXID(struct _LINKTABLE * LINK);
int CountBits(unsigned long in);
VOID SaveMH();
BOOL RestartTNC(struct TNCINFO * TNC);
void GetPortCTEXT(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID WriteMiniDump();
int CheckKissInterlock(struct PORTCONTROL * PORT, int Exclusive);
int seeifInterlockneeded(struct PORTCONTROL * PORT);
extern VOID KISSTX(struct KISSINFO * KISS, PMESSAGE Buffer);
char COMMANDBUFFER[81] = ""; // Command Hander input buffer
char OrigCmdBuffer[81] = ""; // Command Hander input buffer before toupper
struct DATAMESSAGE * REPLYBUFFER = NULL;
UINT APPLMASK = 0;
UCHAR SAVEDAPPLFLAGS = 0;
UCHAR ALIASINVOKED = 0;
VOID * CMDPTR = 0;
short CMDPACLEN = 0;
char OKMSG[] = "Ok\r";
char CMDERRMSG[] = "Invalid command - Enter ? for command list\r";
#define CMDERRLEN sizeof(CMDERRMSG) - 1
char PASSWORDMSG[] = "Command requires SYSOP status - enter password\r";
#define LPASSMSG sizeof(PASSWORDMSG) - 1
char CMDLIST[] = "CONNECT BYE INFO NODES PORTS ROUTES USERS MHEARD";
#define CMDLISTLEN sizeof(CMDLIST) - 1
char BADMSG[] = "Bad Parameter\r";
char BADPORT[] = "Invalid Port Number\r";
char NOTEXTPORT[] = "Only valid on EXT ports\r";
char NOVALCALLS[] = "No Valid Calls defined on this port\r";
char BADVALUEMSG[] = "Invalid parameter\r";
char BADCONFIGMSG[] = "Configuration File check falled - will continue with old config\r";
#ifdef LINBPQ
char REBOOTOK[] = "Rebooting\r";
#else
char REBOOTOK[] = "Rebooting in 20 secs\r";
#endif
char REBOOTFAILED[] = "Shutdown failed\r";
char RESTARTOK[] = "Restarting\r";
char RESTARTFAILED[] = "Restart failed\r";
UCHAR ARDOP[7] = {'A'+'A','R'+'R','D'+'D','O'+'O','P'+'P',' '+' '}; // ARDOP IN AX25
UCHAR VARA[7] = {'V'+'V','A'+'A','R'+'R','A'+'A',' '+' ',' '+' '}; // VARA IN AX25
int STATSTIME = 0;
int MAXBUFFS = 0;
int QCOUNT = 0;
int MINBUFFCOUNT = 65535;
int NOBUFFCOUNT = 0;
int BUFFERWAITS = 0;
int MAXDESTS = 0;
int NUMBEROFNODES = 0;
int L4CONNECTSOUT = 0;
int L4CONNECTSIN = 0;
int L4FRAMESTX = 0;
int L4FRAMESRX = 0;
int L4FRAMESRETRIED = 0;
int OLDFRAMES = 0;
int L3FRAMES = 0;
VOID SENDSABM(struct _LINKTABLE * LINK);
VOID RESET2(struct _LINKTABLE * LINK);
int APPL1 = 0;
int PASSCMD = 0;
#pragma pack(1)
struct _EXTPORTDATA DP; // Only way I can think of to get offets to port data into cmd table
char CMDALIAS[ALIASLEN][NumberofAppls] = {0};
char * ALIASPTR = &CMDALIAS[0][0];
extern int RigReconfigFlag;
struct CMDX COMMANDS[];
int CMDXLEN = sizeof (struct CMDX);
VOID SENDNODESMSG();
VOID KISSCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID STOPCMS(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID STARTCMS(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID STOPPORT(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID STARTPORT(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID FINDBUFFS(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID WL2KSYSOP(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID AXRESOLVER(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID AXMHEARD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID SHOWTELNET(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID SHOWAGW(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID SHOWARP(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID SHOWNAT(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID PING(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID SHOWIPROUTE(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID FLMSG(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD);
void ListExcludedCalls(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID APRSCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID RECONFIGTELNET (TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID HELPCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID UZ7HOCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD);
VOID QTSMCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD);
void hookL2SessionAttempt(int Port, char * fromCall, char * toCall, struct _LINKTABLE * LINK);
char * __cdecl Cmdprintf(TRANSPORTENTRY * Session, char * Bufferptr, const char * format, ...)
{
// Send Command response checking PACLEN
char Mess[4096];
va_list(arglist);
int OldLen;
int MsgLen;
struct DATAMESSAGE * Buffer;
char * Messptr = Mess;
int Paclen = Session->SESSPACLEN;
if (Paclen == 0)
Paclen = 255;
va_start(arglist, format);
MsgLen = vsprintf(Mess, format, arglist);
OldLen = (int)(Bufferptr - (char *)REPLYBUFFER->L2DATA);
while ((OldLen + MsgLen) > Paclen)
{
// Have to send Paclen then get a new buffer
int ThisBit = Paclen - OldLen; // What we can send this time
if (ThisBit < 0)
ThisBit = 0; // How can this happen??
memcpy(Bufferptr, Messptr, ThisBit);
Messptr += ThisBit;
MsgLen -= ThisBit;
// QUEUE IT AND GET ANOTHER BUFFER
Buffer = (struct DATAMESSAGE *)GetBuff();
if (Buffer == NULL)
// No buffers, so just reuse the old one (better than crashing !!)
Buffer = REPLYBUFFER;
else
SendCommandReply(Session, REPLYBUFFER, Paclen + (4 + sizeof(void *)));
REPLYBUFFER = Buffer;
Buffer->PID = 0xf0;
Bufferptr = &Buffer->L2DATA[0];
OldLen = 0;
}
// Add last bit to buffer
memcpy(Bufferptr, Messptr, MsgLen);
return Bufferptr + MsgLen;
}
VOID SENDNODES(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
SENDNODESMSG();
strcpy(Bufferptr, OKMSG);
Bufferptr += (int)strlen(OKMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID SAVEMHCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
SaveMH();
strcpy(Bufferptr, OKMSG);
Bufferptr += (int)strlen(OKMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID SAVENODES(struct _TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
SaveNodes();
strcpy(Bufferptr, OKMSG);
Bufferptr += (int)strlen(OKMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID DUMPCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
WriteMiniDump();
strcpy(Bufferptr, OKMSG);
Bufferptr += (int)strlen(OKMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID RIGRECONFIG(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
if (!ProcessConfig())
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Configuration File check falled - will continue with old config");
}
else
{
RigReconfigFlag = TRUE;
Bufferptr = Cmdprintf(Session, Bufferptr, "Rigcontrol Reconfig requested");
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID REBOOT(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
if (Reboot())
{
strcpy(Bufferptr, REBOOTOK);
Bufferptr += (int)strlen(REBOOTOK);
}
else
{
strcpy(Bufferptr, REBOOTFAILED);
Bufferptr += (int)strlen(REBOOTFAILED);
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID RESTART(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
if (Restart())
{
strcpy(Bufferptr, RESTARTOK);
Bufferptr += (int)strlen(RESTARTOK);
}
else
{
strcpy(Bufferptr, RESTARTFAILED);
Bufferptr += (int)strlen(RESTARTFAILED);
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID RESTARTTNC(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char * ptr, *Context;
int portno;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
{
portno = atoi (ptr);
if (portno && portno < 33)
{
struct TNCINFO * TNC = TNCInfo[portno];
if (TNC == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
}
else
{
if (TNC->ProgramPath)
{
if (RestartTNC(TNC))
Bufferptr = Cmdprintf(Session, Bufferptr, "Restart %s Ok\r", TNC->ProgramPath);
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Restart %s Failed\r", TNC->ProgramPath);
}
else
{
Bufferptr = Cmdprintf(Session, Bufferptr, "PATH not defined so can't restart TNC\r");
}
}
}
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
UCHAR VALNODESFLAG = 0, EXTONLY = 0;
VOID PORTVAL (TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD);
VOID VALNODES(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
VALNODESFLAG = 1;
PORTVAL(Session, Bufferptr, CmdTail, CMD);
}
VOID EXTPORTVAL(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
EXTONLY = 1;
PORTVAL(Session, Bufferptr, CmdTail, CMD);
}
VOID PORTVAL(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// PROCESS PORT VALUE COMMANDS
char * ptr, *Context, * ptr1;
int portno;
UCHAR oldvalue, newvalue;
struct PORTCONTROL * PORT = PORTTABLE;
int n = NUMBEROFPORTS;
UCHAR * valueptr;
// Get port number
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
{
portno = atoi (ptr);
if (portno)
{
while (n--)
{
if (PORT->PORTNUMBER == portno)
{
if (VALNODESFLAG)
{
char * VNPtr = PORT->PERMITTEDCALLS;
char Normcall[10];
VALNODESFLAG = 0;
if (VNPtr)
{
while (VNPtr[0])
{
Normcall[ConvFromAX25(VNPtr, Normcall)] = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "%s ", Normcall);
VNPtr += 7;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
}
else
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", NOVALCALLS);
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (EXTONLY)
{
// Make sure an Extenal Port
EXTONLY = 0;
if (PORT->PORTTYPE != 0x10)
{
strcpy(Bufferptr, NOTEXTPORT);
Bufferptr += (int)strlen(NOTEXTPORT);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
}
valueptr = (UCHAR *)PORT + CMD->CMDFLAG;
oldvalue = *valueptr;
// Display Param Namee
ptr1 = &CMD->String[0];
n = 12;
while (*(ptr1) != ' ' && n--)
*(Bufferptr++) = *(ptr1++);
// See if another param - if not, just display current value
ptr = strtok_s(NULL, " ", &Context);
if (ptr && ptr[0])
{
// Get new value
newvalue = atoi(ptr);
*valueptr = newvalue;
Bufferptr = Cmdprintf(Session, Bufferptr, " was %d now %d\r", oldvalue, newvalue);
}
else
Bufferptr = Cmdprintf(Session, Bufferptr, " %d\r", oldvalue);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
PORT = PORT->PORTPOINTER;
}
}
}
// Bad port
strcpy(Bufferptr, BADPORT);
Bufferptr += (int)strlen(BADPORT);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID SWITCHVAL (TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// Update switch 8 bit value
char * ptr, *Context, * ptr1;
UCHAR oldvalue, newvalue;
int n;
UCHAR * valueptr;
valueptr = (UCHAR *)CMD->CMDFLAG;
oldvalue = *valueptr;
// Display Param Name
ptr1 = &CMD->String[0];
n = 12;
while (*(ptr1) != ' ' && n--)
*(Bufferptr++) = *(ptr1++);
// See if a param - if not, just display current value
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr && ptr[0])
{
// Get new value
newvalue = atoi(ptr);
*valueptr = newvalue;
Bufferptr = Cmdprintf(Session, Bufferptr, " was %d now %d\r", oldvalue, newvalue);
if (memcmp(CMD->String, "NODESINT ", 8) == 0)
L3TIMER = L3INTERVAL;
}
else
Bufferptr = Cmdprintf(Session, Bufferptr, " %d\r", oldvalue);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID SWITCHVALW (TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// Update switch 16 bit value
char * ptr, *Context, * ptr1;
USHORT oldvalue, newvalue;
int n;
USHORT * valueptr;
valueptr = (USHORT *)CMD->CMDFLAG;
oldvalue = (USHORT)*valueptr;
// Display Param Name
ptr1 = &CMD->String[0];
n = 12;
while (*(ptr1) != ' ' && n--)
*(Bufferptr++) = *(ptr1++);
// See if a param - if not, just display current value
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr && ptr[0])
{
// Get new value
newvalue = atoi(ptr);
*valueptr = newvalue;
Bufferptr = Cmdprintf(Session, Bufferptr, " was %d now %d\r", oldvalue, newvalue);
}
else
Bufferptr = Cmdprintf(Session, Bufferptr, " %d\r", oldvalue);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
TRANSPORTENTRY * SetupSessionFromSession(TRANSPORTENTRY * Session, PBPQVECSTRUC HOSTSESS, UINT APPLMASK)
{
// Create a Transport (L4) session linked to an incoming Session
TRANSPORTENTRY * NewSess = L4TABLE;
int Index = 0;
while (Index < MAXCIRCUITS)
{
if (NewSess->L4USER[0] == 0)
{
// Got One
UCHAR * ourcall = &MYCALL[0];
Session->L4CROSSLINK = NewSess;
NewSess->L4CROSSLINK = Session;
if (APPLMASK)
{
// Circuit for APPL - look for an APPLCALL
APPLCALLS * APPL = APPLCALLTABLE;
while ((APPLMASK & 1) == 0)
{
APPLMASK >>= 1;
APPL++;
}
if (APPL->APPLCALL[0] > 0x40) // We have an applcall
ourcall = &APPL->APPLCALL[0];
}
memcpy(NewSess->L4USER, ourcall, 7);
memcpy(NewSess->L4MYCALL, Session->L4MYCALL, 7);
NewSess->CIRCUITINDEX = Index; //OUR INDEX
NewSess->CIRCUITID = NEXTID;
NEXTID++;
if (NEXTID == 0)
NEXTID++; // kEEP nON-ZERO
NewSess->SESSIONT1 = Session->SESSIONT1;
NewSess->L4WINDOW = (UCHAR)L4DEFAULTWINDOW;
NewSess->SESSPACLEN = PACLEN; // Default;
NewSess->L4TARGET.HOST = HOSTSESS;
NewSess->L4STATE = 5;
return NewSess;
}
Index++;
NewSess++;
}
return NULL;
}
extern int GETCONNECTIONINFO();
BOOL cATTACHTOBBS(TRANSPORTENTRY * Session, UINT Mask, int Paclen, int * AnySessions)
{
PBPQVECSTRUC HOSTSESS = BPQHOSTVECTOR;
TRANSPORTENTRY * NewSess;
int ApplNum;
int n = BPQHOSTSTREAMS;
int ConfigedPorts = 0;
// LOOK FOR A FREE HOST SESSION
while (n--)
{
if (HOSTSESS->HOSTAPPLMASK & Mask)
{
// Right appl
ConfigedPorts++;
if (HOSTSESS->HOSTSESSION == NULL && (HOSTSESS->HOSTFLAGS & 3) == 0) // Not attached and no report outstanding
{
// WEVE GOT A FREE BPQ HOST PORT - USE IT
NewSess = SetupSessionFromSession(Session, HOSTSESS, Mask);
if (NewSess == NULL)
return FALSE; // Appl not available
HOSTSESS->HOSTSESSION = NewSess;
// Convert APPLMASK to APPLNUM
ApplNum = 1;
while (APPLMASK && (APPLMASK & 1) == 0)
{
ApplNum++;
APPLMASK >>= 1;
}
HOSTSESS->HOSTAPPLNUM = ApplNum;
HOSTSESS->HOSTFLAGS |= 2; // Indicate State Change
NewSess->L4CIRCUITTYPE = BPQHOST | DOWNLINK;
PostStateChange(NewSess);
NewSess->SESS_APPLFLAGS = HOSTSESS->HOSTAPPLFLAGS;
NewSess->SESSPACLEN = Paclen;
return TRUE;
}
}
HOSTSESS++;
}
*AnySessions = ConfigedPorts; // to distinguish between none and all in use
return FALSE;
}
VOID APPLCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
BOOL CONFAILED = 0;
UINT CONERROR ;
char APPName[13];
char * ptr1, *ptr2;
int n = 12;
BOOL Stay = FALSE;
// Copy Appl and Null Terminate
ptr1 = &CMD->String[0];
ptr2 = APPName;
while (*(ptr1) != ' ' && n--)
*(ptr2++) = *(ptr1++);
*(ptr2) = 0;
if (Session->LISTEN)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Can't use %s while listening\r", APPName);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (CmdTail[0] == 'S')
Stay = TRUE;
Session->STAYFLAG = Stay;
memcpy(Session->APPL, CMD->String, 12);
// SEE IF THERE IS AN ALIAS DEFINDED FOR THIS COMMAND
if (ALIASPTR[0] > ' ')
{
// COPY ALIAS TO COMMAND BUFFER, THEN REENTER COMMAND HANDLER
int SaveSecure = Session->Secure_Session;
memcpy(COMMANDBUFFER, ALIASPTR, ALIASLEN);
_strupr(COMMANDBUFFER);
memcpy(OrigCmdBuffer, ALIASPTR, ALIASLEN); // In case original case version needed
ALIASINVOKED = 1; // To prevent Alias Loops
// Set secure session for application alias in case telnet outward connect
Session->Secure_Session = 1;
DoTheCommand(Session);
Session->Secure_Session = SaveSecure;
return;
}
if (cATTACHTOBBS(Session, APPLMASK, CMDPACLEN, &CONERROR) == 0)
{
// No Streams
if (CONERROR)
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, All %s Ports are in use - Please try later\r", APPName);
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, Application %s is not running - Please try later\r", APPName);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// IF CMD_TO_APPL SET IN APPLFLAGS, SEND INPUT MSG TO APPL
if (Session->L4CROSSLINK->SESS_APPLFLAGS & CMD_TO_APPL)
{
struct DATAMESSAGE * Msg = (struct DATAMESSAGE *)GetBuff();
TRANSPORTENTRY * XSession = Session->L4CROSSLINK;
if (Msg)
{
COMMANDBUFFER[72] = 13;
memcpy(Msg->L2DATA, COMMANDBUFFER, 73);
Msg->LENGTH = 73 + 4 + sizeof(void *);
Msg->PID = 0xf0;
C_Q_ADD(&XSession->L4TX_Q, (UINT *)Msg);
PostDataAvailable(XSession);
}
}
if (Stay)
Session->L4CROSSLINK->L4TARGET.HOST->HOSTFLAGS |= 0x20;
// IF MSG_TO_USER SET, SEND 'CONNECTED' MESSAGE TO USER
Session->SESS_APPLFLAGS = Session->L4CROSSLINK->SESS_APPLFLAGS;
if (Session->L4CROSSLINK->SESS_APPLFLAGS & MSG_TO_USER)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Connected to %s\r", APPName);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// DONT NEED BUFFER ANY MORE
ReleaseBuffer((UINT *)REPLYBUFFER);
return;
}
VOID CMDI00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", INFOMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID CMDV00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
if (sizeof(void *) == 4)
Bufferptr = Cmdprintf(Session, Bufferptr, "Version %s\r", VersionString);
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Version %s (64 bit)\r", VersionString);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID BYECMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
CLOSECURRENTSESSION(Session); // Kills any crosslink, plus local link
ReleaseBuffer((UINT *)REPLYBUFFER);
return;
}
VOID CMDPAC(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// SET PACLEN FOR THIS SESSION
char * ptr, *Context;
int newvalue;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr && ptr[0])
{
// Get new value
newvalue = atoi(ptr);
if (newvalue > 29 && newvalue < 256)
Session->SESSPACLEN = newvalue & 0xff;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "PACLEN - %d\r", Session->SESSPACLEN);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID CMDIDLE(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// SET IDLETIME FOR THIS SESSION
char * ptr, *Context;
int newvalue;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr && ptr[0])
{
// Get new value
newvalue = atoi(ptr);
if (newvalue > 59 && newvalue < 901)
Session->L4LIMIT = newvalue;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "IDLETIME - %d\r", Session->L4LIMIT);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID CMDT00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// SET L4 TIMEOUT FOR CONNECTS ON THIS SESSION
char * ptr, *Context;
int newvalue;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr && ptr[0])
{
// Get new value
newvalue = atoi(ptr);
if (newvalue > 20)
Session->SESSIONT1 = newvalue;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "L4TIMEOUT - %d\r", Session->SESSIONT1);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
UCHAR PWLen;
char PWTEXT[80];
VOID PWDCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char * ptr, *Context;
USHORT pwsum = 0;
int n = 5, p1, p2, p3, p4, p5;
if (Session->Secure_Session) // HOST - SET AUTHORISED REGARDLESS
{
Session->PASSWORD = 0xFFFF; // SET AUTHORISED
Session->Secure_Session = 1;
strcpy(Bufferptr, OKMSG);
Bufferptr += (int)strlen(OKMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr && ptr[0])
{
// Check Password
n = 5;
while (n--)
pwsum += *(ptr++);
if (Session->PASSWORD == pwsum)
{
Session->PASSWORD = 0xFFFF; // SET AUTHORISED
Session->Secure_Session = 1;
strcpy(Bufferptr, OKMSG);
Bufferptr += (int)strlen(OKMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
ReleaseBuffer((UINT *)REPLYBUFFER);
return;
}
// SEND PASSWORD PROMPT
if (PWLen == 0)
PWLen = 1;
p1 = rand() % PWLen;
pwsum += PWTEXT[p1++];
p2 = rand() % PWLen;
pwsum += PWTEXT[p2++];
p3 = rand() % PWLen;
pwsum += PWTEXT[p3++];
p4 = rand() % PWLen;
pwsum += PWTEXT[p4++];
p5 = rand() % PWLen;
pwsum += PWTEXT[p5++];
Session->PASSWORD = pwsum;
Bufferptr = Cmdprintf(Session, Bufferptr, "%d %d %d %d %d\r", p1, p2, p3, p4, p5);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID CMDSTATS(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char * ptr, *Context;
int Port = 0, cols = NUMBEROFPORTS, i;
char * uptime;
struct PORTCONTROL * PORT = PORTTABLE;
struct PORTCONTROL * STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
// SEE IF ANY PARAM
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr && ptr[0])
Port = atoi(ptr);
// IF ASKING FOR PORT STATS, DONT DO SYSTEM ONES
if (Port == 0)
{
uptime = FormatUptime(STATSTIME);
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", uptime);
Bufferptr = Cmdprintf(Session, Bufferptr, "Semaphore Get-Rel/Clashes %9d%9d\r",
Semaphore.Gets - Semaphore.Rels, Semaphore.Clashes);
Bufferptr = Cmdprintf(Session, Bufferptr, "Buffers:Max/Cur/Min/Out/Wait%9d%9d%9d%9d%9d\r",
MAXBUFFS, QCOUNT, MINBUFFCOUNT, NOBUFFCOUNT, BUFFERWAITS);
Bufferptr = Cmdprintf(Session, Bufferptr, "Known Nodes/Max Nodes %9d%9d\r",
NUMBEROFNODES, MAXDESTS);
Bufferptr = Cmdprintf(Session, Bufferptr, "L4 Connects Sent/Rxed %9d%9d\r",
L4CONNECTSOUT, L4CONNECTSIN);
Bufferptr = Cmdprintf(Session, Bufferptr, "L4 Frames TX/RX/Resent/Reseq%9d%9d%9d%9d\r",
L4FRAMESTX, L4FRAMESRX, L4FRAMESRETRIED, OLDFRAMES);
Bufferptr = Cmdprintf(Session, Bufferptr, "L3 Frames Relayed %9d\r", L3FRAMES);
if (ptr && ptr[0] == 'S')
{
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
}
// POSITION TO REQUESTED PORT
if (Port)
{
while (PORT && PORT->PORTNUMBER != Port)
{
PORT = PORT->PORTPOINTER;
cols--;
}
}
if (PORT == NULL) // REQUESTED PORT NOT FOUND
{
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
STARTPORT = PORT;
if (cols > 7)
cols = 7;
Bufferptr = Cmdprintf(Session, Bufferptr, " ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Port %02d ", PORT->PORTNUMBER);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "L2 Frames Digied");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2DIGIED);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "L2 Frames Heard ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2FRAMES);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "L2 Frames Rxed ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2FRAMESFORUS);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "L2 Frames Sent ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2FRAMESSENT);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "L2 Timeouts ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2TIMEOUTS);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "REJ Frames Rxed ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2REJCOUNT);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "RX out of Seq ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2OUTOFSEQ);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "L2 Resequenced ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2RESEQ);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "Undrun/Poll T/o ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2URUNC);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "RX Overruns ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2ORUNC);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "RX CRC Errors ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->RXERRORS);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "FRMRs Sent ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2FRMRTX);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "FRMRs Received ");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L2FRMRRX);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "Frames abandoned");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%9d", PORT->L1DISCARD);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
PORT = STARTPORT;
// Bufferptr = Cmdprintf(Session, Bufferptr, "Link Active %% ");
Bufferptr = Cmdprintf(Session, Bufferptr, "Active(TX/Busy) %%");
for (i = 0; i < cols; i++)
{
Bufferptr = Cmdprintf(Session, Bufferptr, " %2d %3d ", PORT->AVSENDING, PORT->AVACTIVE);
PORT = PORT->PORTPOINTER;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID CMDL00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// PROCESS 'LINKS' MESSAGE
struct _LINKTABLE * LINK = LINKS;
int n = MAXLINKS;
int len;
char Normcall[11] = "";
Bufferptr = Cmdprintf(Session, Bufferptr, "Links\r");
while (n--)
{
if (LINK->LINKCALL[0])
{
len = ConvFromAX25(LINK->LINKCALL, Normcall);
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", Normcall);
len = ConvFromAX25(LINK->OURCALL, Normcall);
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", Normcall);
if (LINK->Ver2point2)
Bufferptr = Cmdprintf(Session, Bufferptr, " S=%d P=%d T=%d V=2.2\r",
LINK->L2STATE, LINK->LINKPORT->PORTNUMBER, LINK->LINKTYPE);
else
Bufferptr = Cmdprintf(Session, Bufferptr, " S=%d P=%d T=%d V=%d\r",
LINK->L2STATE, LINK->LINKPORT->PORTNUMBER, LINK->LINKTYPE, 2 - LINK->VER1FLAG);
}
LINK++;
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID CMDS00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// PROCESS 'USERS'
int n = MAXCIRCUITS;
TRANSPORTENTRY * L4 = L4TABLE;
TRANSPORTENTRY * Partner;
int MaxLinks = MAXLINKS;
char State[12] = "", Type[12] = "Uplink";
char LHS[50] = "", MID[10] = "", RHS[50] = "";
char Line[100];
Bufferptr = Cmdprintf(Session, Bufferptr, "%s%d)\r", SESSIONHDDR, QCOUNT);
while (n--)
{
if (L4->L4USER[0])
{
RHS[0] = MID[0] = 0;
if ((L4->L4CIRCUITTYPE & UPLINK) == 0) //SHORT CMDS10A ; YES
{
// IF DOWNLINK, ONLY DISPLAY IF NO CROSSLINK
if (L4->L4CROSSLINK == 0) //jne CMDS60 ; WILL PROCESS FROM OTHER END
{
// ITS A DOWNLINK WITH NO PARTNER - MUST BE A CLOSING SESSION
// DISPLAY TO THE RIGHT FOR NOW
strcpy(LHS, "(Closing) ");
DISPLAYCIRCUIT(L4, RHS);
goto CMDS50;
}
else
goto CMDS60; // WILL PROCESS FROM OTHER END
}
if (L4->L4CROSSLINK == 0)
{
// Single Entry
DISPLAYCIRCUIT(L4, LHS);
}
else
{
DISPLAYCIRCUIT(L4, LHS);
Partner = L4->L4CROSSLINK;
if (Partner->L4STATE == 5)
strcpy(MID, "<-->");
else
strcpy(MID, "<~~>");
DISPLAYCIRCUIT(Partner, RHS);
}
CMDS50:
memset(Line, 32, 100);
memcpy(Line, LHS, (int)strlen(LHS));
memcpy(&Line[35], MID, (int)strlen(MID));
strcpy(&Line[40], RHS);
strcat(&Line[40], "\r");
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", Line);
}
CMDS60:
L4++;
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
extern int MasterPort[MAXBPQPORTS+1]; // Pointer to first BPQ port for a specific MPSK or UZ7HO host
VOID CMDP00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// Process PORTS Message
// If extended show state of TNC (Open, Active, etc)
struct PORTCONTROL * PORT = PORTTABLE;
char Extended = CmdTail[0];
struct PORTCONTROL * SAVEPORT;
Bufferptr = Cmdprintf(Session, Bufferptr, "Ports\r");
while (PORT)
{
char Status[32] = "???????";
int Portno = PORT->PORTNUMBER;
if (PORT->Hide)
{
PORT = PORT->PORTPOINTER;
continue;
}
if (Extended != 'E')
{
Bufferptr = Cmdprintf(Session, Bufferptr, " %2d %s\r", PORT->PORTNUMBER, PORT->PORTDESCRIPTION);
PORT = PORT->PORTPOINTER;
continue;
}
// Try to get port status - may not be possible with some
if (PORT->PortStopped)
{
strcpy(Status, "Stopped");
Bufferptr = Cmdprintf(Session, Bufferptr, " %2d %-7s %s\r", PORT->PORTNUMBER, Status, PORT->PORTDESCRIPTION);
PORT = PORT->PORTPOINTER;
continue;
}
if (PORT->PORTTYPE == 0)
{
struct KISSINFO * KISS = (struct KISSINFO *)PORT;
NPASYINFO Port;
SAVEPORT = PORT;
if (KISS->FIRSTPORT && KISS->FIRSTPORT != KISS)
{
// Not first port on device
PORT = (struct PORTCONTROL *)KISS->FIRSTPORT;
Port = KISSInfo[Portno];
}
Port = KISSInfo[PORT->PORTNUMBER];
if (Port)
{
// KISS like - see if connected
if (PORT->PORTIPADDR.s_addr || PORT->KISSSLAVE)
{
// KISS over UDP or TCP
if (PORT->KISSTCP)
{
if (Port->Connected)
strcpy(Status, "Open ");
else
if (PORT->KISSSLAVE)
strcpy(Status, "Listen");
else
strcpy(Status, "Closed");
}
else
strcpy(Status, "UDP");
}
else
if (Port->idComDev) // Serial port Open
strcpy(Status, "Open ");
else
strcpy(Status, "Closed");
PORT = SAVEPORT;
}
}
else if (PORT->PORTTYPE == 14) // Loopback
strcpy(Status, "Open ");
else if (PORT->PORTTYPE == 16) // External
{
if (PORT->PROTOCOL == 10) // 'HF' Port
{
struct TNCINFO * TNC = TNCInfo[Portno];
if (TNC == NULL)
{
PORT = PORT->PORTPOINTER;
continue;
}
switch (TNC->Hardware) // Hardware Type
{
case H_SCS:
case H_KAM:
case H_AEA:
case H_HAL:
case H_TRK:
case H_SERIAL:
// Serial
if (TNC->hDevice)
strcpy(Status, "Open ");
else
strcpy(Status, "Closed");
break;
case H_UZ7HO:
if (TNCInfo[MasterPort[Portno]]->CONNECTED)
strcpy(Status, "Open ");
else
strcpy(Status, "Closed");
break;
case H_WINMOR:
case H_V4:
case H_MPSK:
case H_FLDIGI:
case H_UIARQ:
case H_ARDOP:
case H_VARA:
case H_KISSHF:
case H_WINRPR:
case H_FREEDATA:
// TCP
if (TNC->CONNECTED)
{
if (TNC->Streams[0].Attached)
strcpy(Status, "In Use");
else
strcpy(Status, "Open ");
}
else
strcpy(Status, "Closed");
break;
case H_TELNET:
strcpy(Status, "Open ");
}
}
else
{
// External but not HF - AXIP, BPQETHER VKISS, ??
struct _EXTPORTDATA * EXTPORT = (struct _EXTPORTDATA *)PORT;
strcpy(Status, "Open ");
}
}
Bufferptr = Cmdprintf(Session, Bufferptr, " %2d %-7s %s\r", PORT->PORTNUMBER, Status, PORT->PORTDESCRIPTION);
PORT = PORT->PORTPOINTER;
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
char * DisplayRoute(TRANSPORTENTRY * Session, char * Bufferptr, struct ROUTE * Routes, char Verbose)
{
char Normcall[10];
char locked[] = " ! ";
int NodeCount;
int Percent = 0;
char PercentString[20];
int Iframes, Retries;
char Active[10];
int Queued;
int Port = 0;
int len = ConvFromAX25(Routes->NEIGHBOUR_CALL, Normcall);
Normcall[9]=0;
if ((Routes->NEIGHBOUR_FLAG & 1) == 1)
strcpy(locked, "!");
else
strcpy(locked, " ");
NodeCount = COUNTNODES(Routes);
if (Routes->NEIGHBOUR_LINK && Routes->NEIGHBOUR_LINK->L2STATE >= 5)
strcpy(Active, ">");
else
strcpy(Active, " ");
if (Verbose)
{
if (Routes->NEIGHBOUR_LINK)
Queued = COUNT_AT_L2(Routes->NEIGHBOUR_LINK); // SEE HOW MANY QUEUED
else
Queued = 0;
Iframes = Routes->NBOUR_IFRAMES;
Retries = Routes->NBOUR_RETRIES;
if (Iframes)
{
Percent = (Retries * 100) / Iframes;
sprintf(PercentString, "%3d%%", Percent);
}
else
strcpy(PercentString, " ");
Bufferptr = Cmdprintf(Session, Bufferptr, "%s%2d %s %3d %3d%s%4d %4d %s %d %d %02d:%02d %d %d",
Active, Routes->NEIGHBOUR_PORT, Normcall,
Routes->NEIGHBOUR_QUAL, NodeCount, locked, Iframes, Retries, PercentString, Routes->NBOUR_MAXFRAME, Routes->NBOUR_FRACK,
Routes->NEIGHBOUR_TIME >> 8, (Routes->NEIGHBOUR_TIME) & 0xff, Queued, Routes->OtherendsRouteQual);
// IF INP3 DISPLAY SRTT
if (Routes->INP3Node) // INP3 Enabled?
{
double srtt = Routes->SRTT/1000.0;
double nsrtt = Routes->NeighbourSRTT/1000.0;
Bufferptr = Cmdprintf(Session, Bufferptr, " %4.2fs %4.2fs", srtt, nsrtt);
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
}
else
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%s %d %s %d %d%s\r",
Active, Routes->NEIGHBOUR_PORT, Normcall, Routes->NEIGHBOUR_QUAL, NodeCount, locked);
}
return Bufferptr;
}
VOID CMDR00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
struct ROUTE * Routes = NEIGHBOURS;
int MaxRoutes = MAXNEIGHBOURS;
char locked[] = " ! ";
int Percent = 0;
char * ptr, * Context;
char Verbose = 0;
int Port = 0;
char AXCALL[7];
BOOL Found;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr && (int)strlen(ptr) > 1)
{
// Route Update
goto ROUTEUPDATE;
}
if (ptr)
{
Verbose = ptr[0];
ptr = strtok_s(NULL, " ", &Context);
if (ptr)
Port = atoi(ptr);
}
Bufferptr = Cmdprintf(Session, Bufferptr, "Routes\r");
while (MaxRoutes--)
{
if (Routes->NEIGHBOUR_CALL[0] != 0)
if (Port == 0 || Port == Routes->NEIGHBOUR_PORT)
Bufferptr = DisplayRoute(Session, Bufferptr, Routes, Verbose);
Routes++;
}
goto SendReply;
ROUTEUPDATE:
if (Session->PASSWORD != 0xFFFF)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", PASSWORDMSG);
goto SendReply;
}
// Line is
// ROUTES G8BPQ-2 2 100 - Set quality to 100
// ROUTES G8BPQ-2 2 ! - Toggle 'Locked Route' flag
// ROUTES G8BPQ-2 2 100 ! - Set quality and toggle 'locked' flag
ConvToAX25(ptr, AXCALL);
ptr = strtok_s(NULL, " ", &Context);
if (ptr)
Port = atoi(ptr);
if (Port == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Number Missing \r");
goto SendReply;
}
Found = FindNeighbour(AXCALL, Port, &Routes);
if (Context && Context[0] > 32)
{
// More Params
ptr = strtok_s(NULL, " ", &Context);
if (ptr)
{
// Adding
memcpy(Routes->NEIGHBOUR_CALL, AXCALL, 7); // In case Add
Routes->NEIGHBOUR_PORT = Port;
Found = TRUE;
}
if (strcmp(ptr, "!") == 0)
{
// Toggle Lock
Routes->NEIGHBOUR_FLAG ^= 1; // FLIP LOCKED BIT
goto Displayit;
}
if (strcmp(ptr, "Z") == 0)
{
// Clear Counts
Routes->NBOUR_IFRAMES = 0;
Routes->NBOUR_RETRIES = 0;
goto Displayit;
}
Routes->NEIGHBOUR_QUAL = atoi(ptr);
if (Context && Context[0] == '!')
{
// Toggle Lock
Routes->NEIGHBOUR_FLAG ^= 1; // FLIP LOCKED BIT
goto Displayit;
}
}
Displayit:
// Just display
if (Found)
Bufferptr = DisplayRoute(Session, Bufferptr, Routes, 1);
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Not Found\r");
/* MOV ROUTEDISP,1
CMP BYTE PTR [ESI],20H
JE SHORT JUSTDISPLAY
MOV ZAPFLAG,0
CMP BYTE PTR [ESI],'Z'
JNE SHORT NOTZAP
MOV ZAPFLAG,1
JMP SHORT JUSTDISPLAY
PUBLIC NOTZAP
NOTZAP:
MOV ROUTEDISP,2 ; LOCK UPDATE
CMP BYTE PTR [ESI],'!'
JE SHORT JUSTDISPLAY
;
; LOOK FOR V FOR ADDING A DIGI
;
CMP WORD PTR [ESI],' V' ; V [SPACE]
JE ADDDIGI
CALL GETVALUE ; GET NUMBER, UP TO SPACE , CR OR OFFH
JC SHORT BADROUTECMD ; INVALID DIGITS
MOV NEWROUTEVAL,AL
MOV ROUTEDISP,0
CALL SCAN ; SEE IF !
MOV AH,[ESI]
PUBLIC JUSTDISPLAY
JUSTDISPLAY:
MOV ESI,OFFSET32 AX25CALL
CALL _FINDNEIGHBOUR
JZ SHORT FOUNDROUTE ; IN LIST - OK
CMP EBX,0
JE SHORT BADROUTECMD ; TABLE FULL??
MOV ECX,7
MOV EDI,EBX
REP MOVSB ; PUT IN CALL
MOV AL,SAVEPORT
MOV NEIGHBOUR_PORT[EBX],AL
JMP SHORT FOUNDROUTE
PUBLIC BADROUTECMD
BADROUTECMD:
POP EDI
JMP PBADVALUE
PUBLIC FOUNDROUTE
FOUNDROUTE:
CMP ZAPFLAG,1
JNE SHORT NOTCLEARCOUNTS
XOR AX,AX
MOV ES:WORD PTR NBOUR_IFRAMES[EDI],AX
MOV ES:WORD PTR NBOUR_IFRAMES+2[EDI],AX
MOV ES:WORD PTR NBOUR_RETRIES[EDI],AX
MOV ES:WORD PTR NBOUR_RETRIES+2[EDI],AX
JMP SHORT NOUPDATE
PUBLIC NOTCLEARCOUNTS
NOTCLEARCOUNTS:
CMP ROUTEDISP,1
JE SHORT NOUPDATE
CMP ROUTEDISP,2
JE SHORT LOCKUPDATE
MOV AL,NEWROUTEVAL
MOV NEIGHBOUR_QUAL[EBX],AL
CMP AH,'!'
JNE SHORT NOUPDATE
PUBLIC LOCKUPDATE
LOCKUPDATE:
XOR NEIGHBOUR_FLAG[EBX],1 ; FLIP LOCKED BIT
PUBLIC NOUPDATE
NOUPDATE:
MOV ESI,EBX
POP EDI
POP EBX
CALL DISPLAYROUTE
JMP SENDCOMMANDREPLY
PUBLIC ADDDIGI
ADDDIGI:
ADD ESI,2
PUSH ESI ; SAVE INPUT BUFFER
MOV ESI,OFFSET32 AX25CALL
CALL _FINDNEIGHBOUR
POP ESI
JZ SHORT ADD_FOUND ; IN LIST - OK
JMP BADROUTECMD
PUBLIC ADD_FOUND
ADD_FOUND:
CALL CONVTOAX25 ; GET DIGI CALLSIGN
PUSH ESI
MOV ESI,OFFSET32 AX25CALL
LEA EDI,NEIGHBOUR_DIGI[EBX]
MOV ECX,7
REP MOVSB
POP ESI ; MSG BUFFER
;
; SEE IF ANOTHER DIGI
;
CMP BYTE PTR [ESI],20H
JE SHORT NOMORE
CALL CONVTOAX25 ; GET DIGI CALLSIGN
MOV ESI,OFFSET32 AX25CALL
LEA EDI,NEIGHBOUR_DIGI+7[EBX]
MOV ECX,7
REP MOVSB
PUBLIC NOMORE
NOMORE:
JMP NOUPDATE
*/
SendReply:
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID LISTENCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// PROCESS LISTEN COMMAND
// for monitoring a remote ax.25 port
int Port = 0, index =0;
uint64_t ListenMask = 0;
char * ptr, *Context;
struct PORTCONTROL * PORT = NULL;
char ListenPortList[128] = "";
ptr = strtok_s(CmdTail, " ,", &Context);
// Now accepts a list of ports
if (ptr == 0 || memcmp(ptr, "OFF", 3) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Listening disabled\r");
Session->LISTEN = 0;
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
while (ptr)
{
Port = atoi(ptr);
if (Port == 0 && NUMBEROFPORTS == 1)
Port = 1;
ptr = strtok_s(NULL, ", ", &Context); // Get port String
if (Port)
PORT = GetPortTableEntryFromPortNum(Port);
if (PORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port %d\r", Port);
continue;
}
if (PORT->PROTOCOL == 10 && PORT->UICAPABLE == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, port %d is not an ax.25 port\r", Port);
continue;
}
if (PORT->PORTL3FLAG)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, port %d is for internode traffic only\r", Port);
continue;
}
if (Session->L4CIRCUITTYPE == L2LINK + UPLINK)
{
if (Session->L4TARGET.LINK->LINKPORT->PORTNUMBER == Port)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "You can't Listen to the port you are connected on\r");
continue;
}
}
sprintf(ListenPortList, "%s %d", ListenPortList, Port);
ListenMask |= ((uint64_t)1 << (Port - 1));
}
Session->LISTEN = ListenMask;
if (ListenMask)
{
if (CountBits64(ListenMask) == 1)
Bufferptr = Cmdprintf(Session, Bufferptr, "Listening on port%s. Use CQ to send a beacon, LIS to disable\r", ListenPortList);
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Listening on ports%s. Use LIS to disable\r", ListenPortList);
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID UNPROTOCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// PROCESS UNPROTO COMMAND
int Port = 0, index =0;
char * ptr, *Context;
struct PORTCONTROL * PORT = NULL;
UCHAR axcalls[64];
BOOL Stay, Spy;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
Port = atoi(ptr);
if (Port == 0 && NUMBEROFPORTS == 1)
Port = 1;
else
ptr = strtok_s(NULL, " ", &Context); // Get Unproto String
if (Port)
PORT = GetPortTableEntryFromPortNum(Port);
if (PORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (ptr == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Destination missing\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
ptr[strlen(ptr)] = ' '; // Put param back together
if (DecodeCallString(ptr, &Stay, &Spy, &axcalls[0]) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Call\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (PORT->PROTOCOL == 10 && PORT->UICAPABLE == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, port is not an ax.25 port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (PORT->PORTL3FLAG)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, port is for internode traffic only\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// Copy Address Info to Session Record
Session->UNPROTO = Port;
Session->UAddrLen = (int)strlen(axcalls);
memcpy(Session->UADDRESS, axcalls, 63);
Bufferptr = Cmdprintf(Session, Bufferptr, "Unproto Mode - enter ctrl/z or /ex to exit\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID CALCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// PROCESS CAL COMMAND
int Port = 0, index = 0, Count = 0;
char * ptr, *Context;
struct PORTCONTROL * PORT = NULL;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
Port = atoi(ptr);
if (Port == 0 && NUMBEROFPORTS == 1)
Port = 1;
else
ptr = strtok_s(NULL, " ", &Context); // Get Unproto String
if (Port)
PORT = GetPortTableEntryFromPortNum(Port);
if (PORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (PORT->PROTOCOL == 10 && PORT->UICAPABLE == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, port is not an ax.25 port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (ptr == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Count Missing\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Count = atoi(ptr);
ptr = strtok_s(NULL, " ", &Context); // Get Unproto String
Bufferptr = Cmdprintf(Session, Bufferptr, "Ok\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID CQCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// Send a CQ Beacon on a radio port. Must be in LISTEN state
DIGIMESSAGE Msg;
int Port = 0;
int OneBits = 0;
uint64_t MaskCopy = Session->LISTEN;
int Len;
UCHAR CQCALL[7];
char Empty[] = "";
char * ptr1 = &OrigCmdBuffer[3];
UCHAR * axptr = &Msg.DIGIS[0][0];
char * ptr2, *Context;
while (MaskCopy)
{
if (MaskCopy & 1)
OneBits++;
Port++;
MaskCopy = MaskCopy >> 1;
}
if (OneBits == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "You must enter LISTEN before calling CQ\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (OneBits > 1)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "You can't call CQ if LISTENing on more than one port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Len = (int)strlen(OrigCmdBuffer) - 3;
if (Len < 0)
Len = 0;
memset(&Msg, 0, sizeof(Msg));
Msg.PORT = Port;
Msg.CTL = 3; // UI
// see if a Via specified
if (_memicmp(ptr1, "via ", 4) == 0)
{
ptr2 = strtok_s(ptr1 + 4, ",", &Context);
while (ptr2)
{
if (ConvToAX25(ptr2, axptr) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid via string\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
axptr += 7;
if (axptr == &Msg.DIGIS[7][0])
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Too many digis\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
ptr1 = ptr2;
ptr2 = strtok_s(NULL, ",", &Context);
}
// ptr1 is start of last digi call. We need to position to data
ptr1 = strchr(ptr1, ' ');
if (ptr1 == NULL)
ptr1 = Empty;
else
ptr1++ ; // to message
Len = (int)strlen(ptr1);
}
ConvToAX25("CQ", CQCALL);
memcpy(Msg.DEST, CQCALL, 7);
Msg.DEST[6] |= 0x80; // set Command Bit
memcpy(Msg.ORIGIN, Session->L4USER, 7);
Msg.ORIGIN[6] ^= 0x1e; // Flip SSID
Msg.PID = 0xf0; // Data PID
memcpy(&Msg.L2DATA, ptr1, Len);
Send_AX_Datagram(&Msg, Len + 2, Port); // Len is Payload ie CTL, PID and Data
Bufferptr = Cmdprintf(Session, Bufferptr, "CQ sent\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
TRANSPORTENTRY * SetupNewSession(TRANSPORTENTRY * Session, char * Bufferptr)
{
TRANSPORTENTRY * NewSess = L4TABLE;
int Index = 0;
while (Index < MAXCIRCUITS)
{
if (NewSess->L4USER[0] == 0)
{
// Got One
Session->L4CROSSLINK = NewSess;
NewSess->L4CROSSLINK = Session;
memcpy(NewSess->L4USER, Session->L4USER, 7);
memcpy(NewSess->L4MYCALL, Session->L4MYCALL, 7);
NewSess->CIRCUITINDEX = Index; //OUR INDEX
NewSess->CIRCUITID = NEXTID;
NEXTID++;
if (NEXTID == 0)
NEXTID++; // kEEP nON-ZERO
NewSess->SESSIONT1 = Session->SESSIONT1;
NewSess->L4WINDOW = (UCHAR)L4DEFAULTWINDOW;
return NewSess;
}
Index++;
NewSess++;
}
if (Bufferptr)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry - System Tables Full\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
return NULL;
}
VOID DoNetromConnect(TRANSPORTENTRY * Session, char * Bufferptr, struct DEST_LIST * Dest, BOOL Spy)
{
TRANSPORTENTRY * NewSess;
NewSess = SetupNewSession(Session, Bufferptr);
if (NewSess == NULL)
return; // Tables Full
NewSess->L4CIRCUITTYPE = SESSION + DOWNLINK;
NewSess->L4TARGET.DEST = Dest;
NewSess->L4STATE = 2; // CONNECTING
NewSess->SPYFLAG = Spy;
ReleaseBuffer((UINT *)REPLYBUFFER);
SENDL4CONNECT(NewSess);
L4CONNECTSOUT++;
return;
}
BOOL FindLink(UCHAR * LinkCall, UCHAR * OurCall, int Port, struct _LINKTABLE ** REQLINK)
{
struct _LINKTABLE * LINK = LINKS;
struct _LINKTABLE * FIRSTSPARE = NULL;
int n = MAXLINKS;
while (n--)
{
if (LINK->LINKCALL[0] == 0) // Spare
{
if (FIRSTSPARE == NULL)
FIRSTSPARE = LINK;
LINK++;
continue;
}
if ((LINK->LINKPORT->PORTNUMBER == Port) && CompareCalls(LINK->LINKCALL, LinkCall) && CompareCalls(LINK->OURCALL, OurCall))
{
*REQLINK = LINK;
return TRUE;
}
LINK++;
}
// ENTRY NOT FOUND - FIRSTSPARE HAS FIRST FREE ENTRY, OR ZERO IF TABLE FULL
*REQLINK = FIRSTSPARE;
return FALSE;
}
VOID ATTACHCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD);
VOID CMDC00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// PROCESS CONNECT COMMAND
TRANSPORTENTRY * NewSess;
int CONNECTPORT, Port;
BOOL CallEvenIfInNodes = FALSE;
char * ptr, *Context;
UCHAR axcalls[64];
UCHAR ourcall[7]; // Call we are using (may have SSID bits inverted
int ret;
struct PORTCONTROL * PORT = PORTTABLE;
struct _LINKTABLE * LINK;
int CQFLAG = 0; // NOT CQ CALL
BOOL Stay, Spy;
int n;
char TextCall[10];
int TextCallLen;
char PortString[10];
char cmdCopy[256];
struct _EXTPORTDATA * EXTPORT = (struct _EXTPORTDATA *)PORT;
#ifdef EXCLUDEBITS
if (CheckExcludeList(Session->L4USER) == FALSE)
{
// CONNECTS FROM THIS STATION ARE NOT ALLOWED
ReleaseBuffer((UINT *)REPLYBUFFER);
return;
}
#endif
if (Session->LISTEN)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Can't connect while listening\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
CONNECTPORT = 0; // NO PORT SPECIFIED
ptr = strtok_s(CmdTail, " ", &Context);
strcpy(cmdCopy, Context); // Save in case Telnet Connect
if (ptr == 0)
{
// No param
if (CFLAG) // C Command Disabled ?
{
// Convert to HOST (appl 32) command
//MOV _CMDPTR,OFFSET32 _HOSTCMD
//MOV _ALIASPTR,OFFSET32 _HOSTCMD + 32 * 31
//MOV _APPLMASK, 80000000H ; Internal Term
}
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Call\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Port = atoi(ptr);
if (Port)
{
// IF THERE IS NOTHING FOLLOWING THE NUMBER, ASSUME IT IS A
// NUMERIC ALIAS INSTEAD OF A PORT
sprintf(PortString, "%d", Port);
if (strlen(PortString) < (int)strlen(ptr))
goto NoPort;
PORT = GetPortTableEntryFromPortNum(Port);
if (PORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
EXTPORT = (struct _EXTPORTDATA *)PORT;
ptr = strtok_s(NULL, " ", &Context);
if (ptr == 0)
{
// No param
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Call\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
CONNECTPORT = Port;
if (strcmp(ptr, "CMS") == 0 || strcmp(ptr, "HOST") == 0) // In case someeone has CMS or HOST as an alias
goto Downlink;
}
NoPort:
ptr[strlen(ptr)] = ' '; // Put param back together
if (ptr[0] == '!')
{
CallEvenIfInNodes = TRUE;
ptr++;
}
if (memcmp(ptr, "RELAY ", 5) == 0 || memcmp(ptr, "SYNC ", 5) == 0)
{
// c p relay with extra parms
goto Downlink;
}
// Skip call validation if using a ptc to allow 1:call, 2:call format
if (Port && PORT->PROTOCOL == 10 && memcmp(EXTPORT->PORT_DLL_NAME, "SCSPACTOR", 9) == 0)
{
char * p;
if (p = strstr(cmdCopy, " S "))
{
Stay = TRUE;
p++;
*p = ' ';
}
if (p = strstr(cmdCopy, " Z "))
{
Spy = TRUE;
p++;
*p = ' ';
}
goto Downlink;
}
else
{
if (DecodeCallString(ptr, &Stay, &Spy, &axcalls[0]) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Call\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
}
Session->STAYFLAG = Stay;
TextCallLen = ConvFromAX25(axcalls, TextCall);
if (CallEvenIfInNodes)
goto Downlink;
// SEE IF CALL TO ANY OF OUR HOST SESSIONS - UNLESS DIGIS SPECIFIED
if (axcalls[7] == 0)
{
// If this connect is as a result of a command alias, don't check appls or we will loop
if (ALIASINVOKED == 0)
{
APPLCALLS * APPL = APPLCALLTABLE;
int n = NumberofAppls;
APPLMASK = 1;
while (n--)
{
if (memcmp(axcalls, APPL->APPLALIAS, 6) == 0 || CompareCalls(axcalls, APPL->APPLCALL))
{
// Call to an appl
// Convert to an APPL command, so any alias is actioned
// SEE IF THERE IS AN ALIAS DEFINDED FOR THIS COMMAND
if (APPL->APPLHASALIAS && APPL->APPLALIASVAL[0] != 0x20)
{
// COPY ALIAS TO COMMAND _BUFFER, THEN REENTER COMMAND HANDLER
memcpy(COMMANDBUFFER, APPL->APPLALIASVAL, ALIASLEN);
COMMANDBUFFER[80] = 0;
_strupr(COMMANDBUFFER);
memcpy(OrigCmdBuffer, APPL->APPLALIASVAL, ALIASLEN); // In case original case version needed
ALIASINVOKED = TRUE; // To prevent Alias Loops
}
else
{
// Copy Appl Command to Command Buffer. Ensure doesn't contain old command
memset(COMMANDBUFFER, ' ', 72);
memcpy(COMMANDBUFFER, APPL->APPLCMD, 12);
}
DoTheCommand(Session);
return;
}
APPL++;
APPLMASK <<= 1;
}
}
}
if (axcalls[7] == 0)
{
// SEE IF CALL TO ANOTHER NODE
struct DEST_LIST * Dest = DESTS;
int n = MAXDESTS;
if (axcalls[6] == 0x60) // if SSID, dont check aliases
{
while (n--)
{
if (memcmp(Dest->DEST_ALIAS, TextCall, 6) == 0)
{
DoNetromConnect(Session, Bufferptr, Dest, Spy);
return;
}
Dest++;
}
}
Dest = DESTS;
n = MAXDESTS;
while (n--)
{
if (CompareCalls(Dest->DEST_CALL, axcalls))
{
DoNetromConnect(Session, Bufferptr, Dest, Spy);
return;
}
Dest++;
}
}
// Must be Downlink Connect
Downlink:
if (CONNECTPORT == 0 && NUMBEROFPORTS > 1)
{
// L2 NEEDS PORT NUMBER
Bufferptr = Cmdprintf(Session, Bufferptr, "Downlink connect needs port number - C P CALLSIGN\r");
// Send Port List
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// ENSURE PORT IS AVAILABLE FOR L2 USE
if (PORT->PROTOCOL >= 10) // Pactor=-style port?
{
int count;
// if Via PACTOR ARDOP WINMOR or VARA, convert to attach and call = Digi's are in AX25STRING (+7)
if (memcmp(&axcalls[7], &WINMOR[0], 6) == 0 ||
memcmp(&axcalls[7], &ARDOP[0], 6) == 0 ||
memcmp(&axcalls[7], &VARA[0], 6) == 0 ||
memcmp(&axcalls[7], &PACTORCALL[0], 6) == 0)
{
char newcmd[80];
TextCall[TextCallLen] = 0;
sprintf(newcmd, "%s %s", CmdTail, TextCall);
ATTACHCMD(Session, Bufferptr, newcmd, NULL);
return;
}
// If on a KAM or SCS with ax.25 on port 2, do an Attach command, then pass on connect
if (EXTPORT->MAXHOSTMODESESSIONS <= 1)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, port is not an ax.25 port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// Only Allow Attach VHF from Secure Applications or if PERMITGATEWAY is set
if (EXTPORT->PERMITGATEWAY == 0 && Session->Secure_Session == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, you are not allowed to use this port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
count = EXTPORT->MAXHOSTMODESESSIONS;
count--; // First is Pactor Stream, count is now last ax.25 session
while (count)
{
if (EXTPORT->ATTACHEDSESSIONS[count] == 0)
{
int Paclen, PortPaclen;
struct DATAMESSAGE * Buffer;
struct DATAMESSAGE Message = {0};
char Callstring[80];
int len;
// Found a free one - use it
// See if TNC is OK
Message.PORT = count;
ret = PORT->PORTTXCHECKCODE(PORT, Message.PORT);
if ((ret & 0xff00) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - TNC Not Ready\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// GET CIRCUIT TABLE ENTRY FOR OTHER END OF LINK
NewSess = SetupNewSession(Session, Bufferptr);
if (NewSess == NULL)
return;
// if a UZ7HO port, and the uplink is L2 or Uz7HO invert SSID bits
// We only get here if multisession
if (memcmp(EXTPORT->PORT_DLL_NAME, "UZ7HO", 5) != 0)
goto noFlip;
if ((Session->L4CIRCUITTYPE & BPQHOST))// host
goto noFlip;
if ((Session->L4CIRCUITTYPE & PACTOR))
{
// incoming is Pactorlike - see if UZ7HO
if (memcmp(Session->L4TARGET.EXTPORT->PORT_DLL_NAME, "UZ7HO", 5) != 0)
goto noFlip;
else
NewSess->L4USER[6] ^= 0x1e; // UZ7HO Uplink - flip
}
else
// Must be L2 uplink - flip
NewSess->L4USER[6] ^= 0x1e; // Flip SSID
noFlip:
EXTPORT->ATTACHEDSESSIONS[count] = NewSess;
NewSess->KAMSESSION = count;
// Set paclen to lower of incoming and outgoing
Paclen = Session->SESSPACLEN; // Incoming PACLEN
if (Paclen == 0)
Paclen = 256; // 0 = 256
PortPaclen = PORT->PORTPACLEN;
if (PortPaclen == 0)
PortPaclen = 256; // 0 = 256
if (PortPaclen < Paclen)
Paclen = PortPaclen;
NewSess->SESSPACLEN = Paclen;
Session->SESSPACLEN = Paclen;
NewSess->L4STATE = 5;
NewSess->L4CIRCUITTYPE = DOWNLINK + PACTOR;
NewSess->L4TARGET.PORT = PORT;
// Send the connect command to the TNC
Buffer = REPLYBUFFER;
Buffer->PORT = count;
Buffer->PID = 0xf0;
// if on Telnet Port convert use original cmd tail
// Why just on telnet - what not all ports??
if (memcmp(EXTPORT->PORT_DLL_NAME, "TELNET", 6) == 0 || memcmp(EXTPORT->PORT_DLL_NAME, "SCSPACTOR", 9) == 0)
{
NewSess->Secure_Session = Session->Secure_Session;
len = sprintf(Callstring,"C %s", cmdCopy);
}
else
{
TextCall[TextCallLen] = 0;
len = sprintf(Callstring,"C %s", TextCall);
if (axcalls[7])
{
int digi = 7;
// we have digis
len += sprintf(&Callstring[len], " via");
while (axcalls[digi])
{
TextCall[ConvFromAX25(&axcalls[digi], TextCall)] = 0;
len += sprintf(&Callstring[len], " %s", TextCall);
digi += 7;
}
}
}
Callstring[len++] = 13;
Callstring[len] = 0;
Buffer->LENGTH = len + MSGHDDRLEN + 1;
memcpy(Buffer->L2DATA, Callstring, len);
C_Q_ADD(&PORT->PORTTX_Q, (UINT *)Buffer);
return;
}
count--;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - No free streams on this port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if ((Session->L4CIRCUITTYPE & BPQHOST) == 0 && PORT->PORTL3FLAG)
{
//Port only for L3
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, port is for internode traffic only\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (PORT->PortUIONLY)
{
//Port only for UI
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, port is for UI traffic only\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
ret = CheckKissInterlock(PORT, TRUE);
if (ret)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, Interlocked port %d is in use\r", ret);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (Session->L4USER[6] == 0x42 || Session->L4USER[6] == 0x44)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry - Can't make ax.25 calls with SSID of T or R\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// Get Session Entry for Downlink
NewSess = SetupNewSession(Session, Bufferptr);
if (NewSess == NULL)
return;
NewSess->L4CIRCUITTYPE = L2LINK + DOWNLINK;
// FORMAT LINK TABLE ENTRY FOR THIS CONNECTION
memcpy(ourcall, NewSess->L4USER, 7);
// SSID SWAP TEST - LEAVE ALONE FOR HOST or Pactor like (unless UZ7HO)
if ((Session->L4CIRCUITTYPE & BPQHOST))// host
goto noFlip3;
if ((Session->L4CIRCUITTYPE & PACTOR))
{
// incoming is Pactorlike - see if UZ7HO
if (memcmp(Session->L4TARGET.EXTPORT->PORT_DLL_NAME, "UZ7HO", 5) != 0)
goto noFlip3;
if (Session->L4TARGET.EXTPORT->MAXHOSTMODESESSIONS < 2) // Not multisession
goto noFlip3;
ourcall[6] ^= 0x1e; // UZ7HO Uplink - flip
}
else
// Must be L2 uplink - flip
ourcall[6] ^= 0x1e; // Flip SSID
noFlip3:
// SET UP NEW SESSION (OR RESET EXISTING ONE)
FindLink(axcalls, ourcall, Port, &LINK);
if (LINK == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry - System Tables Full\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
// Should release NewSess
return;
}
memcpy(LINK->LINKCALL, axcalls, 7);
memcpy(LINK->OURCALL, ourcall, 7);
LINK->LINKPORT = PORT;
LINK->L2TIME = PORT->PORTT1;
// Copy Digis
n = 7;
ptr = &LINK->DIGIS[0];
while (axcalls[n])
{
memcpy(ptr, &axcalls[n], 7);
n += 7;
ptr += 7;
LINK->L2TIME += 2 * PORT->PORTT1; // ADJUST TIMER VALUE FOR 1 DIGI
}
LINK->LINKTYPE = 2; // DOWNLINK
LINK->LINKWINDOW = PORT->PORTWINDOW;
RESET2(LINK); // RESET ALL FLAGS
if (CMD->String[0] == 'N' && SUPPORT2point2)
LINK->L2STATE = 1; // New (2.2) send XID
else
LINK->L2STATE = 2; // Send SABM
LINK->CIRCUITPOINTER = NewSess;
NewSess->L4TARGET.LINK = LINK;
if (PORT->PORTPACLEN)
NewSess->SESSPACLEN = Session->SESSPACLEN = PORT->PORTPACLEN;
if (CQFLAG == 0) // if a CQ CALL DONT SEND SABM
{
seeifInterlockneeded(PORT);
if (LINK->L2STATE == 1)
L2SENDXID(LINK);
else
SENDSABM(LINK);
}
ReleaseBuffer((UINT *)REPLYBUFFER);
return;
}
BOOL DecodeCallString(char * Calls, BOOL * Stay, BOOL * Spy, UCHAR * AXCalls)
{
// CONVERT CALL + OPTIONAL DIGI STRING TO AX25, RETURN
// CONVERTED STRING IN AXCALLS. Return FALSE if invalied
char * axptr = AXCalls;
char * ptr, *Context;
int CQFLAG = 0; // NOT CQ CALL
int n = 8; // Max digis
*Stay = 0;
*Spy = 0;
memset(AXCalls, 0, 64);
ptr = strtok_s(Calls, " ,", &Context);
if (ptr == NULL)
return FALSE;
// First field is Call
if (ConvToAX25(ptr, axptr) == 0)
return FALSE;
axptr += 7;
ptr = strtok_s(NULL, " ,", &Context);
while (ptr && n--)
{
// NEXT FIELD = COULD BE CALLSIGN, VIA, OR S (FOR STAY)
if (strcmp(ptr, "S") == 0)
*Stay = TRUE;
else if (strcmp(ptr, "Z") == 0)
*Spy = TRUE;
else if (memcmp(ptr, "VIA", (int)strlen(ptr)) == 0)
{
} //skip via
else
{
// Convert next digi
if (ConvToAX25(ptr, axptr) == 0)
return FALSE;
axptr += 7;
}
ptr = strtok_s(NULL, " ,", &Context);
}
return TRUE;
}
VOID LINKCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// PROCESS *** LINKED to CALLSIGN
char * ptr, *Context;
UCHAR axcall[7];
int ret;
if (LINKEDFLAG == 'Y' || // UNCONDITIONAL?
(LINKEDFLAG == 'A' &&
((Session->L4CIRCUITTYPE & BPQHOST) || Session->Secure_Session || Session->PASSWORD == 0xffff)))
{
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
ptr = strtok_s(NULL, " ", &Context);
if (ptr)
{
ret = ConvToAX25Ex(ptr, axcall);
if (ret)
{
memcpy(Session->L4USER, axcall, 7);
strcpy(Bufferptr, OKMSG);
Bufferptr += (int)strlen(OKMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
}
strcpy(Bufferptr, BADMSG);
Bufferptr += (int)strlen(BADMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
memcpy(Bufferptr, PASSWORDMSG, LPASSMSG);
Bufferptr += LPASSMSG;
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
int CompareNode(const void *a, const void *b);
int CompareAlias(const void *a, const void *b);
char * DoOneNode(TRANSPORTENTRY * Session, char * Bufferptr, struct DEST_LIST * Dest)
{
char Normcall[10];
char Alias[10];
struct NR_DEST_ROUTE_ENTRY * NRRoute;
struct DEST_ROUTE_ENTRY * Route;
struct ROUTE * Neighbour;
int i, Active, len;
Alias[6] = 0;
memcpy(Alias, Dest->DEST_ALIAS, 6);
strlop(Alias, ' ');
Normcall[ConvFromAX25(Dest->DEST_CALL, Normcall)] = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "Routes to: %s:%s", Alias, Normcall);
if (Dest->DEST_COUNT)
Bufferptr = Cmdprintf(Session, Bufferptr, " RTT=%4.2f FR=%d %c %.1d\r",
Dest->DEST_RTT /1000.0, Dest->DEST_COUNT,
(Dest->DEST_STATE & 0x40)? 'B':' ', (Dest->DEST_STATE & 63));
else
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
NRRoute = &Dest->NRROUTE[0];
Active = Dest->DEST_ROUTE;
for (i = 1; i < 4; i++)
{
Neighbour = NRRoute->ROUT_NEIGHBOUR;
if (Neighbour)
{
len = ConvFromAX25(Neighbour->NEIGHBOUR_CALL, Normcall);
Normcall[len] = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "%c %d %d %d %s\r",
(Active == i)?'>':' ',NRRoute->ROUT_QUALITY, NRRoute->ROUT_OBSCOUNT, Neighbour->NEIGHBOUR_PORT, Normcall);
}
NRRoute++;
}
// DISPLAY INP3 ROUTES
Route = &Dest->ROUTE[0];
Active = Dest->DEST_ROUTE;
for (i = 1; i < 4; i++)
{
Neighbour = Route->ROUT_NEIGHBOUR;
if (Neighbour)
{
double srtt = Route->SRTT/1000.0;
len = ConvFromAX25(Neighbour->NEIGHBOUR_CALL, Normcall);
Normcall[len] = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "%c %d %4.2fs %d %s\r",
(Active == i + 3)?'>':' ',Route->Hops, srtt, Neighbour->NEIGHBOUR_PORT, Normcall);
}
Route++;
}
return Bufferptr;
}
int DoViaEntry(struct DEST_LIST * Dest, int n, char * line, int cursor)
{
char Portcall[10];
int len;
if (Dest->NRROUTE[n].ROUT_NEIGHBOUR != 0 && Dest->NRROUTE[n].ROUT_NEIGHBOUR->INP3Node == 0)
{
len=ConvFromAX25(Dest->NRROUTE[n].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Portcall);
Portcall[len]=0;
len=sprintf(&line[cursor],"%s %d %d ",
Portcall,
Dest->NRROUTE[n].ROUT_NEIGHBOUR->NEIGHBOUR_PORT,
Dest->NRROUTE[n].ROUT_QUALITY);
cursor+=len;
if (Dest->NRROUTE[n].ROUT_OBSCOUNT > 127)
{
len=sprintf(&line[cursor],"! ");
cursor+=len;
}
}
return cursor;
}
int DoINP3ViaEntry(struct DEST_LIST * Dest, int n, char * line, int cursor)
{
char Portcall[10];
int len;
double srtt;
if (Dest->ROUTE[n].ROUT_NEIGHBOUR != 0)
{
srtt = Dest->ROUTE[n].SRTT/1000.0;
len=ConvFromAX25(Dest->ROUTE[n].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Portcall);
Portcall[len]=0;
len=sprintf(&line[cursor],"%s %d %d %4.2fs ",
Portcall,
Dest->ROUTE[n].ROUT_NEIGHBOUR->NEIGHBOUR_PORT,
Dest->ROUTE[n].Hops, srtt);
cursor+=len;
if (Dest->NRROUTE[n].ROUT_OBSCOUNT > 127)
{
len=sprintf(&line[cursor],"! ");
cursor+=len;
}
}
return cursor;
}
int WildCmp(char * pattern, char * string)
{
// Check if string is at end or not.
if (*pattern == '\0')
return *string == '\0';
// Check for single character missing or match
if (*pattern == '?' || *pattern == *string)
return *string != '\0' && WildCmp(pattern + 1, string + 1);
if (*pattern == '*')
{
// Check for multiple character missing
return WildCmp(pattern + 1, string) || (*string != '\0' && WildCmp(pattern, string + 1));
}
return 0;
}
VOID CMDN00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
struct DEST_LIST * Dest = DESTS;
int count = MAXDESTS, i;
char Normcall[10];
char Alias[10];
int Width = 4;
int x = 0, n = 0;
struct DEST_LIST * List[1000];
char Param = 0;
char * ptr, * param2,* Context;
char Nodeline[21];
char AXCALL[7];
char * Call;
char * Qualptr;
int Qual;
char line[160];
int cursor, len;
UCHAR axcall[7];
int SavedOBSINIT = OBSINIT;
struct ROUTE * ROUTE = NULL;
char Pattern[80] = "";
char * firststar;
int minqual = 0;
ptr = strtok_s(CmdTail, " ", &Context);
param2 = strtok_s(NULL, " ", &Context);
if (ptr)
{
if (strcmp(ptr, "ADD") == 0)
goto NODE_ADD;
if (strcmp(ptr, "DEL") == 0)
goto NODE_DEL;
if (strcmp(ptr, "VIA") == 0)
goto NODE_VIA;
}
if (ptr)
{
// Could be C or a pattern. Accept C pattern or pattern C
if ((int)strlen(ptr) > 1)
{
strcpy(Pattern, ptr);
if (param2 && param2[0] == 'C')
Param = 'C';
}
else
{
Param = ptr[0];
if (param2)
strcpy(Pattern, param2);
}
}
// Pattern >nnn selects nodes with at least that quality
if (Pattern[0] == '>')
{
minqual = atoi(&Pattern[1]);
Pattern[0] = 0;
}
// We need to pick out CALL or CALL* from other patterns (as call use detail display)
firststar = strchr(Pattern, '*');
if ((firststar && *(firststar + 1) != 0)|| strchr(Pattern, '?')) //(* not on end)
// definitely pattern
goto DoNodePattern;
// If it works as CALL*, process, else drop through
if (Pattern[0])
{
UCHAR AXCall[8];
int count;
int paramlen = (int)strlen(ptr);
char parampadded[20];
int n = 0;
Alias[8] = 0;
strcpy(parampadded, Pattern);
strcat(parampadded, " ");
ConvToAX25(Pattern, AXCall);
// if * on end, list all ssids
if (firststar)
{
AXCall[6] = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
while (AXCall[6] < 32)
{
Dest = DESTS;
for (count = 0; count < MAXDESTS; count++)
{
if (memcmp(Dest->DEST_ALIAS, parampadded, 6) == 0 || CompareCalls(Dest->DEST_CALL, AXCall))
{
break;
}
Dest++;
}
if (count < MAXDESTS)
{
Bufferptr = DoOneNode(Session, Bufferptr, Dest);
n++;
}
AXCall[6] += 2;
}
if (n) // Found Some
{
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Dest = DESTS; // Reset
// Drop through to try as pattern
}
else
{
// process as just call
for (count = 0; count < MAXDESTS; count++)
{
if (memcmp(Dest->DEST_ALIAS, parampadded, 6) == 0 || CompareCalls(Dest->DEST_CALL, AXCall))
{
break;
}
Dest++;
}
if (count == MAXDESTS)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not found\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Bufferptr = DoOneNode(Session, Bufferptr, Dest);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
}
DoNodePattern:
Bufferptr = Cmdprintf(Session, Bufferptr, "Nodes\r");
while (count--)
{
if (Dest->DEST_CALL[0] != 0)
{
if (Dest->NRROUTE->ROUT_QUALITY >= minqual)
if (Param != 'T' || Dest->DEST_COUNT)
List[n++] = Dest;
if (n > 999)
break;
}
Dest++;
}
if (Param == 'C')
qsort(List, n, sizeof(void *), CompareNode);
else
qsort(List, n, sizeof(void *), CompareAlias);
for (i = 0; i < n; i++)
{
int len = ConvFromAX25(List[i]->DEST_CALL, Normcall);
Normcall[len]=0;
memcpy(Alias, List[i]->DEST_ALIAS, 6);
Alias[6] = 0;
strlop(Alias, ' ');
if (strlen(Alias))
strcat(Alias, ":");
if (Alias[0] == '#' && HIDENODES == 1 && Param != '*') // Hidden Node and not N * command
continue;
if (Pattern[0])
if (!WildCmp(Pattern, Normcall) && !WildCmp(Pattern, Alias))
continue;
if (Param == 'T')
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%s%s RTT=%4.2f Frames = %d %c %.1d\r",
Alias, Normcall, List[i]->DEST_RTT /1000.0, List[i]->DEST_COUNT,
(List[i]->DEST_STATE & 0x40)? 'B':' ', (List[i]->DEST_STATE & 63));
}
else
{
len = sprintf(Nodeline, "%s%s", Alias, Normcall);
memset(&Nodeline[len], ' ', 20 - len);
Nodeline[20] = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", Nodeline);
if (++x == Width)
{
x = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
}
}
}
if (x)
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
goto SendReply;
NODE_VIA:
// List Nodes reachable via a neighbour
ptr = param2;
if (ptr == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Missing Call\r");
goto SendReply;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
ConvToAX25(ptr, AXCALL);
Dest = DESTS;
Dest-=1;
for (count=0; count<MAXDESTS; count++)
{
Dest+=1;
if (Dest->NRROUTE[0].ROUT_NEIGHBOUR == 0 && Dest->ROUTE[0].ROUT_NEIGHBOUR == 0)
continue;
if ((Dest->NRROUTE[0].ROUT_NEIGHBOUR && CompareCalls(Dest->NRROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL))
|| (Dest->NRROUTE[1].ROUT_NEIGHBOUR && CompareCalls(Dest->NRROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL))
|| (Dest->NRROUTE[2].ROUT_NEIGHBOUR && CompareCalls(Dest->NRROUTE[2].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL))
|| (Dest->ROUTE[0].ROUT_NEIGHBOUR && CompareCalls(Dest->ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL))
|| (Dest->ROUTE[1].ROUT_NEIGHBOUR && CompareCalls(Dest->ROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL))
|| (Dest->ROUTE[2].ROUT_NEIGHBOUR && CompareCalls(Dest->ROUTE[2].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL)))
{
len=ConvFromAX25(Dest->DEST_CALL,Normcall);
Normcall[len]=0;
memcpy(Alias,Dest->DEST_ALIAS,6);
Alias[6]=0;
for (i=0;i<6;i++)
{
if (Alias[i] == ' ')
Alias[i] = 0;
}
cursor=sprintf(line,"%s:%s ", Alias,Normcall);
cursor = DoViaEntry(Dest, 0, line, cursor);
cursor = DoViaEntry(Dest, 1, line, cursor);
cursor = DoViaEntry(Dest, 2, line, cursor);
cursor = DoINP3ViaEntry(Dest, 0, line, cursor);
cursor = DoINP3ViaEntry(Dest, 1, line, cursor);
cursor = DoINP3ViaEntry(Dest, 2, line, cursor);
line[cursor++]='\r';
line[cursor++]=0;
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", line);
}
}
goto SendReply;
NODE_ADD:
// FORMAT IS NODE ADD ALIAS:CALL QUAL ROUTE PORT
if (Session->PASSWORD != 0xFFFF)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", PASSWORDMSG);
goto SendReply;
}
ptr = param2;
if (ptr == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Missing Alias:Call\r");
goto SendReply;
}
Call = strlop(ptr, ':');
if (Call == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Missing Alias:Call\r");
goto SendReply;
}
ConvToAX25(Call, AXCALL);
Qualptr = strtok_s(NULL, " ", &Context);
if (Qualptr == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Quality missing\r");
goto SendReply;
}
Qual = atoi(Qualptr);
if (Qual < MINQUAL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Quality is below MINQUAL\r");
goto SendReply;
}
if (FindDestination(AXCALL, &Dest))
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Node already in Table\r");
goto SendReply;
}
if (Dest == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Node Table Full\r");
goto SendReply;
}
memcpy(Dest->DEST_CALL, AXCALL, 7);
memcpy(Dest->DEST_ALIAS, ptr, 6);
NUMBEROFNODES++;
ptr = strtok_s(NULL, " ", &Context);
if (ptr == NULL || ptr[0] == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Neighbour missing\r");
goto SendReply;
}
if (ConvToAX25(ptr, axcall) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Neighbour\r");
goto SendReply;
}
else
{
int Port;
ptr = strtok_s(NULL, " ", &Context);
if (ptr == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Port missing\r");
goto SendReply;
}
Port = atoi(ptr);
if (Context[0] == '!')
{
OBSINIT = 255; //; SPECIAL FOR LOCKED
}
if (FindNeighbour(axcall, Port, &ROUTE))
{
PROCROUTES(Dest, ROUTE, Qual);
}
OBSINIT = SavedOBSINIT;
Bufferptr = Cmdprintf(Session, Bufferptr, "Node Added\r");
goto SendReply;
}
/*
PNODE48:
; GET NEIGHBOURS FOR THIS DESTINATION
;
CALL CONVTOAX25
JNZ SHORT BADROUTE
;
CALL GETVALUE
MOV SAVEPORT,AL ; SET PORT FOR _FINDNEIGHBOUR
CALL GETVALUE
MOV ROUTEQUAL,AL
;
MOV ESI,OFFSET32 AX25CALL
PUSH EBX ; SAVE DEST
CALL _FINDNEIGHBOUR
MOV EAX,EBX ; ROUTE TO AX
POP EBX
JZ SHORT NOTBADROUTE
JMP SHORT BADROUTE
NOTBADROUTE:
;
; UPDATE ROUTE LIST FOR THIS DEST
;
MOV ROUT1_NEIGHBOUR[EBX],EAX
MOV AL,ROUTEQUAL
MOV ROUT1_QUALITY[EBX],AL
MOV ROUT1_OBSCOUNT[EBX],255 ; LOCKED
;
POP EDI
POP EBX
INC _NUMBEROFNODES
JMP SENDOK
BADROUTE:
;
; KILL IT
;
MOV ECX,TYPE DEST_LIST
MOV EDI,EBX
MOV AL,0
REP STOSB
JMP BADROUTECMD
*/
goto SendReply;
NODE_DEL:
if (Session->PASSWORD != 0xFFFF)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", PASSWORDMSG);
goto SendReply;
}
ptr = param2;
if (ptr == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Missing Call\r");
goto SendReply;
}
if (strcmp(ptr, "ALL") == 0)
{
struct DEST_LIST * DEST = DESTS;
int n = MAXDESTS;
while (n--)
{
if (DEST->DEST_CALL[0] && ((DEST->DEST_STATE & 0x80) == 0)) // Don't delete appl node
REMOVENODE(DEST);
DEST++;
}
ClearNodes();
Bufferptr = Cmdprintf(Session, Bufferptr, "All Nodes Deleted\r");
goto SendReply;
}
ConvToAX25(ptr, AXCALL);
if (FindDestination(AXCALL, &Dest) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not Found\r");
goto SendReply;
}
if (Dest->DEST_STATE & 0x80)
Bufferptr = Cmdprintf(Session, Bufferptr, "APPL Node - Can't delete\r");
else
{
REMOVENODE(Dest);
Bufferptr = Cmdprintf(Session, Bufferptr, "Node Deleted\r");
}
Bufferptr = Cmdprintf(Session, Bufferptr, "Node Deleted\r");
SendReply:
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID CMDQUERY(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD)
{
// DISPLAY AVAILABLE COMMANDS
int n;
char * ptr;
char ApplList[2048];
char * out = ApplList;
struct CMDX * CMD = &COMMANDS[APPL1];
for (n = 0; n < NumberofAppls; n++)
{
ptr = &CMD->String[0];
if (*(ptr) != '*')
{
while (*ptr != ' ')
{
*(out++) = *(ptr++);
}
*(out++) = ' ';
}
CMD++;
}
*(out) = 0;
n = CMDLISTLEN;
if (NEEDMH == 0)
n -= 7; // Dont show MH
Bufferptr = Cmdprintf(Session, Bufferptr, "%s%s\r", ApplList, CMDLIST);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
char * FormatMH(MHSTRUC * MH, char Format);
VOID MHCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// DISPLAY HEARD LIST
int Port = 0, sess = 0;
char * ptr, *Context, *pattern;
struct PORTCONTROL * PORT = NULL;
MHSTRUC * MH;
int count = MHENTRIES;
int n;
char Normcall[20];
char From[10];
char DigiList[100];
char * Output;
int len;
char Digi = 0;
// Note that the MHDIGIS field may contain rubbish. You have to check End of Address bit to find
// how many digis there are
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr == NULL || ptr[0] == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Number needed eg MH 1\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (ptr)
Port = atoi(ptr);
if (Port)
PORT = GetPortTableEntryFromPortNum(Port);
if (PORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
pattern = strtok_s(NULL, " ", &Context);
if (pattern)
_strupr(pattern); // Optional filter
MH = PORT->PORTMHEARD;
if (MH == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "MHEARD not enabled on that port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (pattern && strstr(pattern, "CLEAR"))
{
if (Session->Secure_Session)
{
memset(MH, 0, MHENTRIES * sizeof(MHSTRUC));
SaveMH();
Bufferptr = Cmdprintf(Session, Bufferptr, "Heard List for Port %d Cleared\r", Port);
}
else
{
Bufferptr = Cmdprintf(Session, Bufferptr, "MH Clear needs SYSOP status\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
}
else
{
if (CMD->String[2] == 'V') // MHV
{
Bufferptr = Cmdprintf(Session, Bufferptr, "MHeard List %s for Port %d\r", MYNODECALL, Port);
Bufferptr = Cmdprintf(Session, Bufferptr, "Callsign Last heard Pkts RX via Digi ;) \r");
Bufferptr = Cmdprintf(Session, Bufferptr, "--------- ----------- ------- ------------------------------------------\r");
}
else
if (pattern)
Bufferptr = Cmdprintf(Session, Bufferptr, "Heard List for Port %d filtered by %s\r", Port, pattern);
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Heard List for Port %d\r", Port);
}
while (count--)
{
if (MH->MHCALL[0] == 0)
break;
Digi = 0;
len = ConvFromAX25(MH->MHCALL, Normcall);
Normcall[len++] = MH->MHDIGI;
Normcall[len++] = 0;
if (pattern && strstr(Normcall, pattern) == 0)
{
MH++;
continue;
}
n = 8; // Max number of digi-peaters
ptr = &MH->MHCALL[6]; // End of Address bit
Output = &DigiList[0];
if ((*ptr & 1) == 0)
{
// at least one digi
strcpy(Output, "via ");
Output += 4;
while ((*ptr & 1) == 0)
{
// MORE TO COME
From[ConvFromAX25(ptr + 1, From)] = 0;
Output += sprintf((char *)Output, "%s", From);
ptr += 7;
n--;
if (n == 0)
break;
// See if digi actioned - put a * on last actioned
if (*ptr & 0x80)
{
if (*ptr & 1) // if last address, must need *
{
*(Output++) = '*';
Digi = '*';
}
else
if ((ptr[7] & 0x80) == 0) // Repeased by next?
{
*(Output++) = '*'; // No, so need *
Digi = '*';
}
}
*(Output++) = ',';
}
*(--Output) = 0; // remove last comma
}
else
*(Output) = 0;
// if we used a digi set * on call and display via string
if (Digi)
Normcall[len++] = Digi;
else
DigiList[0] = 0; // Dont show list if not used
Normcall[len++] = 0;
ptr = FormatMH(MH, CMD->String[2]);
if (CMD->String[2] == 'V') // MHV
Bufferptr = Cmdprintf(Session, Bufferptr, "%-10s %-10s %-10d %-30s\r",
Normcall, ptr, MH->MHCOUNT, DigiList);
else
Bufferptr = Cmdprintf(Session, Bufferptr, "%-10s %s %s\r", Normcall, ptr, DigiList);
MH++;
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
int Rig_Command(TRANSPORTENTRY * Session, char * Command);
VOID RADIOCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD)
{
char * ptr;
if (Rig_Command(Session, CmdTail))
{
ReleaseBuffer((UINT *)REPLYBUFFER);
return;
}
// Error Message is in buffer
ptr = strchr(CmdTail, 13);
if (ptr)
{
int len = (int)(++ptr - CmdTail);
memcpy(Bufferptr, CmdTail, len);
Bufferptr += len;
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID SendNRRecordRoute(struct DEST_LIST * DEST, TRANSPORTENTRY * Session);
VOID NRRCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD)
{
// PROCESS 'NRR - Netrom Record Route' COMMAND
char * ptr, *Context;
struct DEST_LIST * Dest = DESTS;
int count = MAXDESTS;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
{
UCHAR AXCall[8];
int count;
ConvToAX25(ptr, AXCall);
strcat(ptr, " ");
for (count = 0; count < MAXDESTS; count++)
{
if (memcmp(Dest->DEST_ALIAS, ptr, 6) == 0 || CompareCalls(Dest->DEST_CALL, AXCall))
{
SendNRRecordRoute(Dest, Session);
memcpy(Bufferptr, OKMSG, 3);
Bufferptr += 3;
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Dest++;
}
}
Bufferptr = Cmdprintf(Session, Bufferptr, "Not found\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
int CHECKINTERLOCK(struct PORTCONTROL * OURPORT)
{
// See if any Interlocked ports are Busy
struct PORTCONTROL * PORT = PORTTABLE;
struct _EXTPORTDATA * EXTPORT;
int n = NUMBEROFPORTS;
int ourgroup = OURPORT->PORTINTERLOCK;
while (PORT)
{
if (PORT != OURPORT)
{
if (PORT->PORTINTERLOCK == ourgroup)
{
// Same Group - is it busy
int i = 0;
EXTPORT = (struct _EXTPORTDATA *)PORT;
while (i < 27)
if (EXTPORT->ATTACHEDSESSIONS[i++])
return PORT->PORTNUMBER;
}
}
PORT = PORT->PORTPOINTER;
}
return 0;
}
VOID ATTACHCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD)
{
// ATTACH to a PACTOR or similar port
TRANSPORTENTRY * NewSess;
struct _EXTPORTDATA * EXTPORT;
struct TNCINFO * TNC = 0;
int Port = 0, sess = 0;
char * ptr, *Context;
int ret;
struct PORTCONTROL * PORT = NULL;
struct DATAMESSAGE Message = {0};
int Paclen, PortPaclen;
struct DATAMESSAGE * Buffer;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
Port = atoi(ptr);
if (Port)
PORT = GetPortTableEntryFromPortNum(Port);
if (PORT == NULL || PORT->PROTOCOL < 10)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// If attach on telnet port, find a free stream
EXTPORT = (struct _EXTPORTDATA *)PORT;
if (strstr(EXTPORT->PORT_DLL_NAME, "TELNET"))
{
int count = EXTPORT->MAXHOSTMODESESSIONS;
count--; // First is Pactor Stream, count is now last ax.25 session
while (count)
{
if (EXTPORT->ATTACHEDSESSIONS[count] == 0)
{
int Paclen, PortPaclen;
struct DATAMESSAGE Message = {0};
// Found a free one - use it
// See if TNC is OK
Message.PORT = count;
ret = PORT->PORTTXCHECKCODE(PORT, Message.PORT);
if ((ret & 0xff00) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - TNC Not Ready\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// GET CIRCUIT TABLE ENTRY FOR OTHER END OF LINK
NewSess = SetupNewSession(Session, Bufferptr);
if (NewSess == NULL)
return;
EXTPORT->ATTACHEDSESSIONS[count] = NewSess;
NewSess->Secure_Session = Session->Secure_Session;
NewSess->KAMSESSION = count;
// Set paclen to lower of incoming and outgoing
Paclen = Session->SESSPACLEN; // Incoming PACLEN
if (Paclen == 0)
Paclen = 256; // 0 = 256
PortPaclen = PORT->PORTPACLEN;
if (PortPaclen == 0)
PortPaclen = 256; // 0 = 256
if (PortPaclen < Paclen)
Paclen = PortPaclen;
NewSess->SESSPACLEN = Paclen;
Session->SESSPACLEN = Paclen;
NewSess->L4STATE = 5;
NewSess->L4CIRCUITTYPE = DOWNLINK + PACTOR;
NewSess->L4TARGET.PORT = PORT;
ptr = strtok_s(NULL, " ", &Context);
sess = count;
// Replace command tail with original (before conversion to upper case
Context = Context + (OrigCmdBuffer - COMMANDBUFFER);
goto checkattachandcall;
memcpy(Bufferptr, OKMSG, 3);
Bufferptr += 3;
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
count--;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - No free streams on this port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Message.PORT = 0;
ret = PORT->PORTTXCHECKCODE(PORT, Message.PORT);
if ((ret & 0xff00) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - TNC Not Ready\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// See if "Attach and Call" (for VHF ports)
ptr = strtok_s(NULL, " ", &Context);
if (ptr && strcmp(ptr, "S") == 0)
{
Session->STAYFLAG = TRUE;
ptr = strtok_s(NULL, " ", &Context);
}
if (ptr)
{
// we have another param
// if it is a single char it is a channel number for vhf attach
if (strlen(ptr) == 1)
{
// Only Allow Attach VHF from Secure Applications or if PERMITGATEWAY is set
if (EXTPORT->PERMITGATEWAY == 0 && Session->Secure_Session == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, you are not allowed to use this port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
sess = ptr[0] - '@';
if (sess < 1 || sess > EXTPORT->MAXHOSTMODESESSIONS)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - Invalid Channel\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
ptr = strtok_s(NULL, " ", &Context);
if (ptr && strcmp(ptr, "S") == 0)
{
Session->STAYFLAG = TRUE;
ptr = strtok_s(NULL, " ", &Context);
}
}
}
if (ret & 0x8000) // Disconnecting
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - Port in use\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// Check Interlock. Only ports with a TNC record can be interlocked
TNC = PORT->TNC;
if (TNC)
{
// See if any interlocked ports are in use
struct TNCINFO * OtherTNC;
int i;
int rxInterlock = TNC->RXRadio;
int txInterlock = TNC->TXRadio;
if (rxInterlock || txInterlock)
{
for (i=1; i <= MAXBPQPORTS; i++)
{
OtherTNC = TNCInfo[i];
if (OtherTNC == NULL)
continue;
if (OtherTNC == TNC)
continue;
if (rxInterlock && rxInterlock == OtherTNC->RXRadio || txInterlock && txInterlock == OtherTNC->TXRadio) // Same Group
{
int n;
for (n = 0; n <= 26; n++)
{
if (OtherTNC->PortRecord->ATTACHEDSESSIONS[n])
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Sorry, interlocked port %d is in use\r", i);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
}
}
}
}
}
if (EXTPORT->ATTACHEDSESSIONS[sess] || PORT->PortSuspended)
{
// In use
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - Port in use\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// GET CIRCUIT TABLE ENTRY FOR OTHER END OF LINK
NewSess = SetupNewSession(Session, Bufferptr);
if (NewSess == NULL)
return;
// if a UZ7HO port, and the uplink is L2 or Uz7HO and multisession,
// invert SSID bits
if (memcmp(EXTPORT->PORT_DLL_NAME, "UZ7HO", 5) != 0)
goto noFlip1;
if (EXTPORT->MAXHOSTMODESESSIONS < 2) // Not multisession
goto noFlip1;
if ((Session->L4CIRCUITTYPE & BPQHOST)) // host
goto noFlip1;
if ((Session->L4CIRCUITTYPE & PACTOR))
{
// incoming is Pactorlike - see if UZ7HO
if (memcmp(Session->L4TARGET.EXTPORT->PORT_DLL_NAME, "UZ7HO", 5) != 0)
goto noFlip1;
else
NewSess->L4USER[6] ^= 0x1e; // UZ7HO Uplink - flip
}
else
// Must be L2 uplink - flip
NewSess->L4USER[6] ^= 0x1e; // Flip SSID
noFlip1:
EXTPORT->ATTACHEDSESSIONS[sess] = NewSess;
NewSess->KAMSESSION = sess;
// Set paclen to lower of incoming and outgoing
Paclen = Session->SESSPACLEN; // Incoming PACLEN
if (Paclen == 0)
Paclen = 256; // 0 = 256
PortPaclen = PORT->PORTPACLEN;
if (PortPaclen == 0)
PortPaclen = 256; // 0 = 256
if (PortPaclen < Paclen)
Paclen = PortPaclen;
NewSess->SESSPACLEN = Paclen;
Session->SESSPACLEN = Paclen;
NewSess->L4STATE = 5;
NewSess->L4CIRCUITTYPE = DOWNLINK + PACTOR;
NewSess->L4TARGET.PORT = PORT;
checkattachandcall:
// If set freq on attach is defined, do it
if (TNC && TNC->ActiveRXFreq && TNC->RXRadio)
{
char Msg[128];
sprintf(Msg, "R%d %f", TNC->RXRadio, TNC->ActiveRXFreq);
Rig_Command( (TRANSPORTENTRY *) -1, Msg);
}
if (TNC && TNC->ActiveTXFreq && TNC->TXRadio && TNC->TXRadio != TNC->RXRadio)
{
char Msg[128];
sprintf(Msg, "R%d %f", TNC->TXRadio, TNC->ActiveTXFreq);
Rig_Command( (TRANSPORTENTRY *) -1, Msg);
}
if (ptr)
{
// we have a call to connect to
char Callstring[80];
int len;
Buffer = REPLYBUFFER;
Buffer->PORT = sess;
Buffer->PID = 0xf0;
len = sprintf(Callstring,"C %s", ptr);
ptr = strtok_s(NULL, " ", &Context);
while (ptr) // if any other params (such as digis) copy them
{
if (strcmp(ptr, "S") == 0)
{
Session->STAYFLAG = TRUE;
}
else
len += sprintf(&Callstring[len], " %s", ptr);
ptr = strtok_s(NULL, " ", &Context);
}
Callstring[len++] = 13;
Callstring[len] = 0;
Buffer->LENGTH = len + MSGHDDRLEN + 1;
memcpy(Buffer->L2DATA, Callstring, len);
C_Q_ADD(&PORT->PORTTX_Q, (UINT *)Buffer);
return;
}
memcpy(Bufferptr, OKMSG, 3);
Bufferptr += 3;
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// SYSOP COMMANDS
struct CMDX COMMANDS[] =
{
// "SAVENODES ",8, SAVENODES(struct _TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD), 0,
"SAVENODES ",8, &SAVENODES, 0,
"TELRECONFIG ",4, &RECONFIGTELNET, 0,
"SAVEMH ",6, &SAVEMHCMD, 0,
"REBOOT ",6, &REBOOT, 0,
"RIGRECONFIG ",8, &RIGRECONFIG, 0,
"RESTART ",7, &RESTART,0,
"RESTARTTNC ",10,&RESTARTTNC,0,
"SENDNODES ",8, &SENDNODES,0,
"EXTRESTART ",10, EXTPORTVAL, offsetof(EXTPORTDATA, EXTRESTART),
"TXDELAY ",3, PORTVAL, offsetof(PORTCONTROLX, PORTTXDELAY),
"MAXFRAME ",3, PORTVAL, offsetof(PORTCONTROLX, PORTWINDOW),
"RETRIES ",3, PORTVAL, offsetof(PORTCONTROLX, PORTN2),
"FRACK ",3,PORTVAL, offsetof(PORTCONTROLX, PORTT1),
"RESPTIME ",3,PORTVAL, offsetof(PORTCONTROLX, PORTT2),
"PPACLEN ",3,PORTVAL, offsetof(PORTCONTROLX, PORTPACLEN),
"QUALITY ",3,PORTVAL, offsetof(PORTCONTROLX, PORTQUALITY),
"PERSIST ",2,PORTVAL, offsetof(PORTCONTROLX, PORTPERSISTANCE),
"TXTAIL ",3,PORTVAL, offsetof(PORTCONTROLX, PORTTAILTIME),
"XMITOFF ",7,PORTVAL, offsetof(PORTCONTROLX, PORTDISABLED),
"DIGIFLAG ",5,PORTVAL, offsetof(PORTCONTROLX, DIGIFLAG),
"DIGIPORT ",5,PORTVAL, offsetof(PORTCONTROLX, DIGIPORT),
"MAXUSERS ",4,PORTVAL, offsetof(PORTCONTROLX, USERS),
"L3ONLY ",6,PORTVAL, offsetof(PORTCONTROLX, PORTL3FLAG),
"BBSALIAS ",4,PORTVAL, offsetof(PORTCONTROLX, PORTBBSFLAG),
"VALIDCALLS ",5,VALNODES,0,
"WL2KSYSOP ",5,WL2KSYSOP,0,
"STOPPORT ",4,STOPPORT,0,
"STARTPORT ",5,STARTPORT,0,
"STOPCMS ",7,STOPCMS,0,
"STARTCMS ",8,STARTCMS,0,
"FINDBUFFS ",4,FINDBUFFS,0,
"KISS ",4,KISSCMD,0,
"GETPORTCTEXT",9,GetPortCTEXT, 0,
#ifdef EXCLUDEBITS
"EXCLUDE ",4,ListExcludedCalls,0,
#endif
"FULLDUP ",4,PORTVAL, offsetof(PORTCONTROLX, FULLDUPLEX),
"SOFTDCD ",4,PORTVAL, offsetof(PORTCONTROLX, SOFTDCDFLAG),
"OBSINIT ",7,SWITCHVAL,(size_t)&OBSINIT,
"OBSMIN ",6,SWITCHVAL,(size_t)&OBSMIN,
"NODESINT ",8,SWITCHVAL,(size_t)&L3INTERVAL,
"L3TTL ",5,SWITCHVAL,(size_t)&L3LIVES,
"L4RETRIES ",5,SWITCHVAL,(size_t)&L4N2,
"L4TIMEOUT ",5,SWITCHVALW,(size_t)&L4T1,
"T3 ",2,SWITCHVALW,(size_t)&T3,
"NODEIDLETIME",8,SWITCHVALW,(size_t)&L4LIMIT,
"LINKEDFLAG ",10,SWITCHVAL,(size_t)&LINKEDFLAG,
"IDINTERVAL ",5,SWITCHVAL,(size_t)&IDINTERVAL,
"MINQUAL ",7,SWITCHVAL,(size_t)&MINQUAL,
"FULLCTEXT ",6,SWITCHVAL,(size_t)&FULL_CTEXT,
"HIDENODES ",8,SWITCHVAL,(size_t)&HIDENODES,
"L4DELAY ",7,SWITCHVAL,(size_t)&L4DELAY,
"L4WINDOW ",6,SWITCHVAL,(size_t)&L4DEFAULTWINDOW,
"BTINTERVAL ",5,SWITCHVAL,(size_t)&BTINTERVAL,
"PASSWORD ", 8, PWDCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0,
"************", 12, APPLCMD, 0, // Apppl 32 is internal Terminal
"*** LINKED ",10,LINKCMD,0,
"CQ ",2,CQCMD,0,
"CONNECT ",1,CMDC00,0,
"NC ",2,CMDC00,0,
"BYE ",1,BYECMD,0,
"QUIT ",1,BYECMD,0,
"INFO ",1,CMDI00,0,
"HELP ",1,HELPCMD,0,
"VERSION ",1,CMDV00,0,
"NODES ",1,CMDN00,0,
"LINKS ",1,CMDL00,0,
"LISTEN ",3,LISTENCMD,0,
"L4T1 ",2,CMDT00,0,
"PORTS ",1,CMDP00,0,
"PACLEN ",3,CMDPAC,0,
"IDLETIME ",4,CMDIDLE,0,
"ROUTES ",1,CMDR00,0,
"STATS ",1,CMDSTATS,0,
"USERS ",1,CMDS00,0,
"UNPROTO ",2,UNPROTOCMD,0,
"? ",1,CMDQUERY,0,
"DUMP ",4,DUMPCMD,0,
"MHU ",3,MHCMD,0, // UTC Times
"MHL ",3,MHCMD,0, // Local Times
"MHV ",3,MHCMD,0,
"MHEARD ",1,MHCMD,0,
"APRS ",2,APRSCMD,0,
"ATTACH ",1,ATTACHCMD,0,
"RADIO ",3,RADIOCMD,0,
"AXRESOLVER ",3,AXRESOLVER,0,
"AXMHEARD ",3,AXMHEARD,0,
"TELSTATUS ",3,SHOWTELNET,0,
"NRR ",1,NRRCMD,0,
"PING ",2,PING,0,
"AGWSTATUS ",3,SHOWAGW,0,
"ARP ",3,SHOWARP,0,
"NAT ",3,SHOWNAT,0,
"IPROUTE ",3,SHOWIPROUTE,0,
"UZ7HO ",5,UZ7HOCMD,0,
"QTSM ",4,QTSMCMD,0,
"..FLMSG ",7,FLMSG,0
};
struct CMDX * CMD = NULL;
int NUMBEROFCOMMANDS = sizeof(COMMANDS)/sizeof(struct CMDX);
char * ReplyPointer; // Pointer into reply buffer
int DecodeNodeName(char * NodeName, char * ptr)
{
// NodeName is TABLE ENTRY WITH AX25 CALL AND ALIAS
// Copyies 20 byte 20 DECODED NAME IN FORM ALIAS:CALL to ptr
// Returns significant length of string
int len;
char Normcall[10];
char * alias = &NodeName[7];
int n = 6;
char * start = ptr;
memset(ptr, ' ', 20);
len = ConvFromAX25(NodeName, Normcall);
if (*(alias) > ' ') // Does alias start with a null or a space ?
{
while (*(alias) > ' ' && n--)
{
*ptr++ = *alias++;
}
*ptr++ = ':';
}
memcpy(ptr, Normcall, len);
ptr += len;
return (int)(ptr - start);
}
char * SetupNodeHeader(struct DATAMESSAGE * Buffer)
{
char Header[20];
int len;
char * ptr = &Buffer->L2DATA[0];
len = DecodeNodeName(MYCALLWITHALIAS, Header);
memcpy (ptr, Header, len);
ptr += len;
(*ptr++) = HEADERCHAR;
(*ptr++) = ' ';
return ptr;
}
VOID SendCommandReply(TRANSPORTENTRY * Session, struct DATAMESSAGE * Buffer, int Len)
{
if (Len == (4 + sizeof(void *))) // Null Packet
{
ReleaseBuffer((UINT *)Buffer);
return;
}
Buffer->LENGTH = Len;
C_Q_ADD(&Session->L4TX_Q, (UINT *)Buffer);
PostDataAvailable(Session);
}
VOID CommandHandler(TRANSPORTENTRY * Session, struct DATAMESSAGE * Buffer)
{
// ignore frames with single NULL (Keepalive)
if (Buffer->LENGTH == sizeof(void *) + 5 && Buffer->L2DATA[0] == 0)
{
ReleaseBuffer(Buffer);
return;
}
if (Buffer->LENGTH > 100)
{
// Debugprintf("BPQ32 command too long %s", Buffer->L2DATA);
ReleaseBuffer(Buffer);
return;
}
InnerLoop:
InnerCommandHandler(Session, Buffer);
// See if any more commands in buffer
if (Session->PARTCMDBUFFER)
{
char * ptr1, * ptr2;
int len;
Buffer = Session->PARTCMDBUFFER;
// Check that message has a CR, if not save buffer and exit
len = Buffer->LENGTH - (4 + sizeof(void *));
ptr1 = &Buffer->L2DATA[0];
ptr2 = memchr(ptr1, 13, len);
if (ptr2 == NULL)
return;
Session->PARTCMDBUFFER = NULL;
goto InnerLoop;
}
}
VOID InnerCommandHandler(TRANSPORTENTRY * Session, struct DATAMESSAGE * Buffer)
{
char * ptr1, * ptr2, *ptr3;
int len, oldlen, newlen, rest, n;
struct DATAMESSAGE * OldBuffer;
struct DATAMESSAGE * SaveBuffer;
char c;
// If a partial command is stored, append this data to it.
if (Session->PARTCMDBUFFER)
{
len = Buffer->LENGTH - (sizeof(void *) + 4);
ptr1 = &Buffer->L2DATA[0];
OldBuffer = Session->PARTCMDBUFFER; // Old Data
if (OldBuffer == Buffer)
{
// something has gone horribly wrong
Session->PARTCMDBUFFER = NULL;
return;
}
oldlen = OldBuffer->LENGTH;
newlen = len + oldlen;
if (newlen > 200)
{
// Command far too long - ignore previous
OldBuffer->LENGTH = oldlen = sizeof(void *) + 4;
}
OldBuffer->LENGTH += len;
memcpy(&OldBuffer->L2DATA[oldlen - (sizeof(void *) + 4)], Buffer->L2DATA, len);
ReleaseBuffer((UINT *)Buffer);
Buffer = OldBuffer;
Session->PARTCMDBUFFER = NULL;
}
// Check that message has a CR, if not save buffer and exit
len = Buffer->LENGTH - (sizeof(void *) + 4);
ptr1 = &Buffer->L2DATA[0];
// Check for sending YAPP to Node
if (len == 2 && ptr1[0] == 5 && ptr1[1] == 1)
{
ptr1[0] = 0x15; // NAK
ptr1[1] = sprintf(&ptr1[2], "Node doesn't support YAPP Transfers");
Buffer->LENGTH += ptr1[1];
C_Q_ADD(&Session->L4TX_Q, (UINT *)Buffer);
PostDataAvailable(Session);
return;
}
ptr2 = memchr(ptr1, ';', len);
if (ptr2 == 0)
{
ptr2 = memchr(ptr1, 13, len);
if (ptr2 == 0)
{
// No newline
Session->PARTCMDBUFFER = Buffer;
return;
}
}
ptr2++;
rest = len - (int)(ptr2 - ptr1);
if (rest)
{
// there are chars beyond the cr in the buffer
// see if LF after CR
if ((*ptr2) == 10) // LF
{
ptr2++;
rest--;
}
if (rest) // May only have had LF
{
// Get a new buffer, and copy extra data to it.
SaveBuffer = (struct DATAMESSAGE *)GetBuff();
if (SaveBuffer) //`Just ignore if no buffers
{
SaveBuffer->LENGTH = rest + MSGHDDRLEN + 1;
SaveBuffer->PID = 0xf0;
memcpy(&SaveBuffer->L2DATA[0], ptr2, rest);
Session->PARTCMDBUFFER = SaveBuffer;
}
}
}
// GET PACLEN FOR THIS CONNECTION
CMDPACLEN = Session->SESSPACLEN;
if (CMDPACLEN == 0)
CMDPACLEN = PACLEN; // Use default if no Session PACLEN
// If sesion is in UNPROTO Mode, send message as a UI message
if (Session->UNPROTO)
{
// char LongMsg[512] =
// "VeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessage"
// "VeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessageVeryLongMessage";
DIGIMESSAGE Msg;
int Port = Session->UNPROTO;
int Len = Buffer->LENGTH - (MSGHDDRLEN -1); // Need PID
// First check for UNPROTO exit - ctrl/z or /ex
if (Buffer->L2DATA[0] == 26 || (Len == 6 && _memicmp(&Buffer->L2DATA[0], "/ex", 3) == 0)) // CTRL/Z or /ex
{
REPLYBUFFER = Buffer;
Session->UNPROTO = 0;
memset(Session->UADDRESS, 0, 64);
// SET UP HEADER
Buffer->PID = 0xf0;
ptr1 = SetupNodeHeader(Buffer);
memcpy(ptr1, OKMSG, 3);
ptr1 += 3;
SendCommandReply(Session, Buffer, (int)(ptr1 - (char *)Buffer));
return;
}
memset(&Msg, 0, sizeof(Msg));
Msg.PORT = Port;
Msg.CTL = 3; // UI
memcpy(Msg.DEST, Session->UADDRESS, 7);
Msg.DEST[6] |= 0x80; // set Command Bit
memcpy(Msg.ORIGIN, Session->L4USER, 7);
memcpy(Msg.DIGIS, &Session->UADDRESS[7], Session->UAddrLen - 7);
memcpy(&Msg.PID, &Buffer->PID, Len);
Send_AX_Datagram(&Msg, Len, Port); // Len is Payload - CTL, PID and Data
// memcpy(&Msg.PID + 1, LongMsg, 260);
// Send_AX_Datagram(&Msg, 241, Port); // Len is Payload - CTL, PID and Data
// SendUIModeFrame(Session, (PMESSAGE)Buffer, Session->UNPROTO);
ReleaseBuffer((UINT *)Buffer); // Not using buffer for reply
// Assume we don't allow multiple lines in buffer with UI
if (Session->PARTCMDBUFFER)
{
Buffer = Session->PARTCMDBUFFER;
ReleaseBuffer((UINT *)Buffer); // Not using buffer for reply
Session->PARTCMDBUFFER = NULL;
}
return;
}
memset(COMMANDBUFFER, 32, 80); // Clear to spaces
ptr1 = &Buffer->L2DATA[0];
ptr2 = &COMMANDBUFFER[0];
ptr3 = &OrigCmdBuffer[0];
memset(OrigCmdBuffer, 0, 80);
n = 80;
while (n--)
{
c = *(ptr1++) & 0x7f; // Mask paritu
if (c == 13 || c == ';')
break; // CR
*(ptr3++) = c; // Original Case
c = toupper(c);
*(ptr2++) = c;
}
// USE INPUT MESSAGE _BUFFER FOR REPLY
REPLYBUFFER = Buffer;
// SET UP HEADER
Buffer->PID = 0xf0;
ptr1 = SetupNodeHeader(Buffer);
ReplyPointer = ptr1;
ALIASINVOKED = 0; // Clear "Invoked by APPL ALIAS flag"
DoTheCommand(Session); // We also call DotheCommand when we need to reprocess - eg for alias handling
}
VOID DoTheCommand(TRANSPORTENTRY * Session)
{
struct DATAMESSAGE * Buffer = REPLYBUFFER;
char * ptr1, * ptr2;
int n;
ptr1 = &COMMANDBUFFER[0]; //
n = 10;
while ((*ptr1 == ' ' || *ptr1 == 0) && n--)
ptr1++; // STRIP LEADING SPACES and nulls (from keepalive)
if (n == -1)
{
// Null command
ReleaseBuffer((UINT *)Buffer);
return;
}
ptr2 = ptr1; // Save
CMD = &COMMANDS[0];
n = 0;
for (n = 0; n < NUMBEROFCOMMANDS; n++)
{
int CL = CMD->CMDLEN;
ptr1 = ptr2;
CMDPTR = CMD;
if (n == APPL1) // First APPL command
{
APPLMASK = 1; // FOR APPLICATION ATTACH REQUESTS
ALIASPTR = &CMDALIAS[0][0];
}
// ptr1 is input command
if (memcmp(CMD->String, ptr1, CL) == 0)
{
// Found match so far - check rest
char * ptr2 = &CMD->String[CL];
ptr1 += CL;
if (*(ptr1) != ' ')
{
while(*(ptr1) == *ptr2 && *(ptr1) != ' ')
{
ptr1++;
ptr2++;
}
}
if (*(ptr1) == ' ')
{
Session->BADCOMMANDS = 0; // RESET ERROR COUNT
// SEE IF SYSOP COMMAND, AND IF SO IF PASSWORD HAS BEEN ENTERED
if (n < PASSCMD)
{
//NEEDS PASSWORD FOR SYSOP COMMANDS
if (Session->PASSWORD != 0xFFFF)
{
ptr1 = ReplyPointer;
memcpy(ptr1, PASSWORDMSG, LPASSMSG);
ptr1 += LPASSMSG;
SendCommandReply(Session, Buffer, (int)(ptr1 - (char *)Buffer));
return;
}
}
// VALNODESFLAG = 0; // NOT VALID NODES COMMAND
ptr1++; // Skip space
CMD->CMDPROC(Session, ReplyPointer, ptr1, CMD);
return;
}
}
APPLMASK <<= 1;
ALIASPTR += ALIASLEN;
CMD++;
}
Session->BADCOMMANDS++;
if (Session->BADCOMMANDS > 6) // TOO MANY ERRORS
{
ReleaseBuffer((UINT *)Buffer);
Session->STAYFLAG = 0;
CLOSECURRENTSESSION(Session);
return;
}
ptr1 = ReplyPointer;
memcpy(ptr1, CMDERRMSG, CMDERRLEN);
ptr1 += CMDERRLEN;
SendCommandReply(Session, Buffer, (int)(ptr1 - (char *)Buffer));
}
VOID StatsTimer()
{
struct PORTCONTROL * PORT = PORTTABLE;
uint64_t sum, sum2;
// Interval is 60 secs
while(PORT)
{
int index = PORT->StatsPointer++;
if (index == 1439)
PORT->StatsPointer = 0; // Cyclic through 24 hours (1440 Mins)
if (PORT->TNC)
{
struct TNCINFO * TNC = PORT->TNC;
if (TNC->Hardware == H_ARDOP || TNC->Hardware == H_VARA)
{
sum = TNC->PTTActivemS / 600; // ms but want %
PORT->AVSENDING = (UCHAR)sum;
TNC->PTTActivemS = 0;
sum2 = TNC->BusyActivemS / 600; // ms but want %
PORT->AVACTIVE = (UCHAR)(sum + sum2);
TNC->BusyActivemS = 0;
}
}
else
{
// if KISS port using QtSM Average is already updated
struct KISSINFO * KISS = (struct KISSINFO *)PORT;
if (PORT->PORTNUMBER == 17)
{
int x = 17;
}
if ((void *)PORT->PORTTXROUTINE == (void *)KISSTX && (KISS->QtSMStats || KISS->FIRSTPORT->PORT.QtSMPort)) // KISS Port QtSM Stats
{
}
else
{
sum = PORT->SENDING / 11;
PORT->AVSENDING = (UCHAR)sum;
sum = (PORT->SENDING + PORT->ACTIVE) /11;
PORT->AVACTIVE = (UCHAR)sum;
}
}
if (PORT->TX == NULL && PORT->AVACTIVE)
{
PORT->TX = zalloc(1440); // Keep 1 day history
PORT->BUSY = zalloc(1440);
}
if (PORT->TX)
{
PORT->TX[index] = PORT->AVSENDING;
PORT->BUSY[index] = PORT->AVACTIVE;
}
PORT->SENDING = 0;
PORT->ACTIVE = 0;
PORT = PORT->PORTPOINTER;
}
}
extern struct AXIPPORTINFO * Portlist[];
#define TCPConnected 4
VOID AXRESOLVER(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// DISPLAY AXIP Resolver info
int Port = 0, index =0;
char * ptr, *Context;
struct PORTCONTROL * PORT = NULL;
struct AXIPPORTINFO * AXPORT;
char Normcall[11];
char Flags[10];
struct arp_table_entry * arp;
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
Port = atoi(ptr);
if (Port)
PORT = GetPortTableEntryFromPortNum(Port);
if (PORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
AXPORT = Portlist[Port];
if (AXPORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not an AXIP port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "AXIP Resolver info for Port %d\r", Port);
while (index < AXPORT->arp_table_len)
{
arp = &AXPORT->arp_table[index];
if (arp->ResolveFlag && arp->error != 0)
{
// resolver error - Display Error Code
sprintf(AXPORT->hostaddr, "Error %d", arp->error);
}
else
{
if (arp->IPv6)
Format_Addr((unsigned char *)&arp->destaddr6.sin6_addr, AXPORT->hostaddr, TRUE);
else
Format_Addr((unsigned char *)&arp->destaddr.sin_addr, AXPORT->hostaddr, FALSE);
}
ConvFromAX25(arp->callsign, Normcall);
Flags[0] = 0;
if (arp->BCFlag)
strcat(Flags, "B ");
if (arp->TCPState == TCPConnected)
strcat(Flags, "C ");
if (arp->AutoAdded)
strcat(Flags, "A");
if (arp->port == arp->SourcePort)
Bufferptr = Cmdprintf(Session, Bufferptr,"%.10s = %.64s %d = %-.42s %s\r",
Normcall,
arp->hostname,
arp->port,
AXPORT->hostaddr,
Flags);
else
Bufferptr = Cmdprintf(Session, Bufferptr,"%.10s = %.64s %d<%d = %-.42s %s\r",
Normcall,
arp->hostname,
arp->port,
arp->SourcePort,
AXPORT->hostaddr,
Flags);
index++;
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID AXMHEARD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
// DISPLAY AXIP Mheard info
int Port = 0, index = 0;
char * ptr, *Context;
struct PORTCONTROL * PORT = NULL;
struct AXIPPORTINFO * AXPORT;
int n = MHENTRIES;
char Normcall[11];
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
Port = atoi(ptr);
if (Port)
PORT = GetPortTableEntryFromPortNum(Port);
if (PORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
AXPORT = Portlist[Port];
if (AXPORT == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not an AXIP port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "AXIP Mheard for Port %d\r", Port);
while (index < MaxMHEntries)
{
if (AXPORT->MHTable[index].proto != 0)
{
char Addr[80];
Format_Addr((unsigned char *)&AXPORT->MHTable[index].ipaddr6, Addr, AXPORT->MHTable[index].IPv6);
Normcall[ConvFromAX25(AXPORT->MHTable[index].callsign, Normcall)] = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "%-10s%-15s %c %-6d %-25s%c\r", Normcall,
Addr,
AXPORT->MHTable[index].proto,
AXPORT->MHTable[index].port,
asctime(gmtime( &AXPORT->MHTable[index].LastHeard )),
(AXPORT->MHTable[index].Keepalive == 0) ? ' ' : 'K');
Bufferptr[-3] = ' '; // Clear CR returned by asctime
}
index++;
}
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
#pragma pack()
extern char WL2KCall[10];
extern char WL2KLoc[7];
BOOL GetWL2KSYSOPInfo(char * Call, char * _REPLYBUFFER);
BOOL UpdateWL2KSYSOPInfo(char * Call, char * SQL);
VOID WL2KSYSOP(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char _REPLYBUFFER[1000] = "";
char LastUpdated[100];
char Name[100] = "";
char Addr1[100] = "";
char Addr2[100] = "";
char City[100] = "";
char State[100] = "";
char Country[100] = "";
char PostCode[100] = "";
char Email[100] = "";
char Website[100] = "";
char Phone[100] = "";
char Data[100] = "";
char LOC[100] = "";
BOOL Exists = TRUE;
time_t LastUpdateSecs = 0;
char * ptr1, * ptr2;
SOCKET sock;
int Len;
char Message[2048];
if (WL2KCall[0] < 33)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Winlink reporting is not configured\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (GetWL2KSYSOPInfo(WL2KCall, _REPLYBUFFER) == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Failed to connect to WL2K Database\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (strstr(_REPLYBUFFER, "\"ErrorMessage\":"))
Exists = FALSE;
GetJSONValue(_REPLYBUFFER, "\"SysopName\":", Name);
GetJSONValue(_REPLYBUFFER, "\"StreetAddress1\":", Addr1);
GetJSONValue(_REPLYBUFFER, "\"StreetAddress2\":", Addr2);
GetJSONValue(_REPLYBUFFER, "\"City\":", City);
GetJSONValue(_REPLYBUFFER, "\"State\":", State);
GetJSONValue(_REPLYBUFFER, "\"Country\":", Country);
GetJSONValue(_REPLYBUFFER, "\"PostalCode\":", PostCode);
GetJSONValue(_REPLYBUFFER, "\"Email\":", Email);
GetJSONValue(_REPLYBUFFER, "\"Website\":", Website);
GetJSONValue(_REPLYBUFFER, "\"Phones\":", Phone);
GetJSONValue(_REPLYBUFFER, "\"Comments\":", Data);
GetJSONValue(_REPLYBUFFER, "\"GridSquare\":", LOC);
GetJSONValue(_REPLYBUFFER, "\"Timestamp\":", LastUpdated);
ptr1 = strchr(LastUpdated, '(');
if (ptr1)
{
ptr2 = strchr(++ptr1, ')');
if (ptr2)
{
*(ptr2 - 3) = 0; // remove millisecs
LastUpdateSecs = atoi(ptr1);
FormatTime3(LastUpdated, LastUpdateSecs);
}
}
if (_memicmp(CmdTail, "SET ", 4) == 0)
{
if (Exists)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Record already exists in WL2K Database\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// Set New Values. Any other params are values to set, separated by |
// ptr1 = strtok_s(&CmdTail[4], ",", &Context);
// if (ptr1 == NULL)
// goto DoReplace;
// strcpy(Name, ptr1);
//DoReplace:
Len = sprintf(Message,
"\"Callsign\":\"%s\","
"\"GridSquare\":\"%s\","
"\"SysopName\":\"%s\","
"\"StreetAddress1\":\"%s\","
"\"StreetAddress2\":\"%s\","
"\"City\":\"%s\","
"\"State\":\"%s\","
"\"Country\":\"%s\","
"\"PostalCode\":\"%s\","
"\"Email\":\"%s\","
"\"Phones\":\"%s\","
"\"Website\":\"%s\","
"\"Comments\":\"%s\",",
WL2KCall, WL2KLoc, Name, Addr1, Addr2, City, State, Country, PostCode, Email, Phone, Website, Data);
Debugprintf("Sending %s", Message);
sock = OpenWL2KHTTPSock();
if (sock)
SendHTTPRequest(sock, "api.winlink.org", 80,
"/sysop/add", Message, Len, NULL);
closesocket(sock);
Bufferptr = Cmdprintf(Session, Bufferptr, "Database Updated\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (Exists)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "\rWL2K SYSOP Info for %s\r", WL2KCall);
Bufferptr = Cmdprintf(Session, Bufferptr, "Grid Square: %s\r", LOC);
Bufferptr = Cmdprintf(Session, Bufferptr, "Name: %s\r", Name);
Bufferptr = Cmdprintf(Session, Bufferptr, "Addr Line 1: %s\r", Addr1);
Bufferptr = Cmdprintf(Session, Bufferptr, "Addr Line 2: %s\r", Addr2);
Bufferptr = Cmdprintf(Session, Bufferptr, "City: %s\r", City);
Bufferptr = Cmdprintf(Session, Bufferptr, "State: %s\r", State);
Bufferptr = Cmdprintf(Session, Bufferptr, "Country: %s\r", Country);
Bufferptr = Cmdprintf(Session, Bufferptr, "PostCode: %s\r", PostCode);
Bufferptr = Cmdprintf(Session, Bufferptr, "Email Address: %s\r", Email);
Bufferptr = Cmdprintf(Session, Bufferptr, "Website: %s\r", Website);
Bufferptr = Cmdprintf(Session, Bufferptr, "Phone: %s\r", Phone);
Bufferptr = Cmdprintf(Session, Bufferptr, "Additional Data: %s\r", Data);
Bufferptr = Cmdprintf(Session, Bufferptr, "Last Updated: %s\r", LastUpdated);
}
else
Bufferptr = Cmdprintf(Session, Bufferptr, "No SYSOP record for %s\r", WL2KCall);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID CloseKISSPort(struct PORTCONTROL * PortVector);
VOID STOPCMS(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char _REPLYBUFFER[1000] = "";
char * ptr, * Context;
int portno;
struct TNCINFO * TNC;
struct TCPINFO * TCP;
struct PORTCONTROL * PORT = PORTTABLE;
int n = NUMBEROFPORTS;
// Get port number
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
{
portno = atoi (ptr);
if (portno)
{
while (n--)
{
if (PORT->PORTNUMBER == portno)
{
TNC = TNCInfo[portno];
if (!TNC || !TNC->TCPInfo)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not a Telnet Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
TCP = TNC->TCPInfo;
TCP->CMS = 0;
TCP->CMSOK = FALSE;
#ifndef LINBPQ
CheckMenuItem(TCP->hActionMenu, 3, MF_BYPOSITION | TCP->CMS<<3);
SetWindowText(TCP->hCMSWnd, "CMS Off");
#endif
Bufferptr = Cmdprintf(Session, Bufferptr, "CMS Server Disabled\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
PORT = PORT->PORTPOINTER;
}
}
}
// Bad port
strcpy(Bufferptr, BADPORT);
Bufferptr += (int)strlen(BADPORT);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID STARTCMS(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char _REPLYBUFFER[1000] = "";
char * ptr, * Context;
int portno;
struct TNCINFO * TNC;
struct TCPINFO * TCP;
struct PORTCONTROL * PORT = PORTTABLE;
int n = NUMBEROFPORTS;
// Get port number
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
{
portno = atoi (ptr);
if (portno)
{
while (n--)
{
if (PORT->PORTNUMBER == portno)
{
TNC = TNCInfo[portno];
if (!TNC || !TNC->TCPInfo)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not a Telnet Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
TCP = TNC->TCPInfo;
TCP->CMS = 1;
#ifndef LINBPQ
CheckMenuItem(TCP->hActionMenu, 3, MF_BYPOSITION | TCP->CMS<<3);
#endif
CheckCMS(TNC);
Bufferptr = Cmdprintf(Session, Bufferptr, "CMS Server Enabled\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
PORT = PORT->PORTPOINTER;
}
}
}
// Bad port
strcpy(Bufferptr, BADPORT);
Bufferptr += (int)strlen(BADPORT);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID STOPPORT(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char _REPLYBUFFER[1000] = "";
char * ptr, * Context;
int portno;
struct PORTCONTROL * PORT = PORTTABLE;
int n = NUMBEROFPORTS;
// Get port number
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
{
portno = atoi (ptr);
if (portno)
{
while (n--)
{
if (PORT->PORTNUMBER == portno)
{
struct KISSINFO * KISS;
if (PORT->PORTSTOPCODE)
{
// Port has Close Routine
PORT->PortStopped = TRUE;
if (PORT->PORTSTOPCODE(PORT))
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Closed\r");
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Close Failed\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (PORT->PORTTYPE != 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not a KISS Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (PORT->PORTIPADDR.s_addr || PORT->KISSSLAVE)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not a serial port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
KISS = (struct KISSINFO *) PORT;
if (KISS->FIRSTPORT != KISS)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not first port of a Multidrop Set\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
CloseKISSPort(PORT);
PORT->PortStopped = TRUE;
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Closed\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
PORT = PORT->PORTPOINTER;
}
}
}
// Bad port
strcpy(Bufferptr, BADPORT);
Bufferptr += (int)strlen(BADPORT);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID STARTPORT(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char _REPLYBUFFER[1000] = "";
char * ptr, * Context;
int portno;
struct PORTCONTROL * PORT = PORTTABLE;
int n = NUMBEROFPORTS;
// Get port number
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
{
portno = atoi (ptr);
if (portno)
{
while (n--)
{
if (PORT->PORTNUMBER == portno)
{
struct KISSINFO * KISS;
if (PORT->PORTSTARTCODE)
{
// Port has Open Routine
PORT->PortStopped = FALSE;
if (PORT->PORTSTARTCODE(PORT))
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Opened\r");
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Open Failed\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (PORT->PORTTYPE != 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not a KISS Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (PORT->PORTIPADDR.s_addr || PORT->KISSSLAVE)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not a serial port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
KISS = (struct KISSINFO *) PORT;
if (KISS->FIRSTPORT != KISS)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not first port of a Multidrop Set\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (OpenConnection(PORT))
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Opened\r");
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Port Open Failed\r");
PORT->PortStopped = FALSE;
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
PORT = PORT->PORTPOINTER;
}
}
}
// Bad port
strcpy(Bufferptr, BADPORT);
Bufferptr += (int)strlen(BADPORT);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
int ASYSEND(struct PORTCONTROL * PortVector, char * buffer, int count);
int KissEncode(UCHAR * inbuff, UCHAR * outbuff, int len);
VOID KISSCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char _REPLYBUFFER[1000] = "";
char * ptr, * Context;
int portno = 0;
struct PORTCONTROL * PORT = PORTTABLE;
int n = NUMBEROFPORTS;
UCHAR KissString[128];
UCHAR ENCBUFF[256];
int KissLen = 0;
unsigned char * Kissptr = KissString;
// Send KISS Command to TNC
// Get port number
ptr = strtok_s(CmdTail, " ", &Context);
if (ptr)
{
portno = atoi (ptr);
ptr = strtok_s(NULL, " ", &Context);
while (ptr && ptr[0] && KissLen < 120)
{
*(Kissptr++) = atoi (ptr);
KissLen++;
ptr = strtok_s(NULL, " ", &Context);
}
}
if (portno == 0 || KissLen == 0)
{
strcpy(Bufferptr, BADMSG);
Bufferptr += (int)strlen(BADMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
while (n--)
{
if (PORT->PORTNUMBER == portno)
{
struct KISSINFO * KISS;
if (PORT->PORTTYPE != 0 && PORT->PORTTYPE != 22)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not a KISS Port\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
KISS = (struct KISSINFO *) PORT;
if (KISS->FIRSTPORT != KISS)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Not first port of a Multidrop Set\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
// Send Command
KissLen = KissEncode(KissString, ENCBUFF, KissLen);
PORT = (struct PORTCONTROL *)KISS->FIRSTPORT; // ALL FRAMES GO ON SAME Q
PORT->Session = Session;
PORT->LastKISSCmdTime = time(NULL);
ASYSEND(PORT, ENCBUFF, KissLen);
Bufferptr = Cmdprintf(Session, Bufferptr, "Command Sent\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
PORT = PORT->PORTPOINTER;
}
// Bad port
strcpy(Bufferptr, BADPORT);
Bufferptr += (int)strlen(BADPORT);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID FINDBUFFS(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
FindLostBuffers();
#ifdef WIN32
Bufferptr = Cmdprintf(Session, Bufferptr, "Lost buffer info dumped to Debugview\r");
#else
Bufferptr = Cmdprintf(Session, Bufferptr, "Lost buffer info dumped to syslog\r");
#endif
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
VOID FLMSG(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * UserCMD)
{
// Telnet Connection from FLMSG
CLOSECURRENTSESSION(Session); // Kills any crosslink, plus local link
ReleaseBuffer((UINT *)REPLYBUFFER);
}
BOOL CheckExcludeList(UCHAR * Call)
{
UCHAR * ptr1 = ExcludeList;
while (*ptr1)
{
if (memcmp(Call, ptr1, 6) == 0)
return FALSE;
ptr1 += 7;
}
return TRUE;
}
void ListExcludedCalls(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
UCHAR * ptr = ExcludeList;
char Normcall[10] = "";
UCHAR AXCall[8] = "";
if (*CmdTail == ' ')
goto DISPLIST;
if (*CmdTail == 'Z')
{
// CLEAR LIST
memset(ExcludeList, 0, 70);
goto DISPLIST;
}
ConvToAX25(CmdTail, AXCall);
if (strlen(ExcludeList) < 70)
strcat(ExcludeList, AXCall);
DISPLIST:
while (*ptr)
{
Normcall[ConvFromAX25(ptr, Normcall)] = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "%s ", Normcall);
ptr += 7;
}
*(Bufferptr++) = '\r';
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
BOOL isSYSOP(TRANSPORTENTRY * Session, char * Bufferptr)
{
if (Session->PASSWORD != 0xFFFF)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "%s", PASSWORDMSG);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return FALSE;
}
return TRUE;
}
VOID HELPCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
int FileSize;
char MsgFile[MAX_PATH];
FILE * hFile;
char * MsgBytes;
struct stat STAT;
char * ptr1, * ptr, * ptr2;
sprintf_s(MsgFile, sizeof(MsgFile), "%s/%s", BPQDirectory, "NodeHelp.txt");
if (stat(MsgFile, &STAT) == -1)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Help file not found\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
FileSize = STAT.st_size;
hFile = fopen(MsgFile, "rb");
if (hFile == NULL)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Help file not found\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
MsgBytes = malloc(FileSize+1);
fread(MsgBytes, 1, FileSize, hFile);
fclose(hFile);
MsgBytes[FileSize] = 0;
ptr1 = MsgBytes;
// Replace LF or CRLF with CR
// First remove cr from crlf
while(ptr2 = strstr(ptr1, "\r\n"))
{
memmove(ptr2, ptr2 + 1, strlen(ptr2));
}
// Now replace lf with cr
ptr1 = MsgBytes;
while (*ptr1)
{
if (*ptr1 == '\n')
*(ptr1) = '\r';
ptr1++;
}
ptr = ptr1 = MsgBytes;
Bufferptr = Cmdprintf(Session, Bufferptr, "\r");
// Read and send a line at a time, converting any line endings into CR
while (*ptr1)
{
if (*ptr1 == '\r')
{
*(ptr1++) = 0;
Bufferptr = Cmdprintf(Session, Bufferptr, "%s\r", ptr);
ptr = ptr1;
}
else
ptr1++;
}
free(MsgBytes);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
}
int UZ7HOSetFreq(int port, struct TNCINFO * TNC, struct AGWINFO * AGW, PDATAMESSAGE buff, PMSGWITHLEN buffptr);
int UZ7HOSetModem(int port, struct TNCINFO * TNC, struct AGWINFO * AGW, PDATAMESSAGE buff, PMSGWITHLEN buffptr);
int UZ7HOSetFlags(int port, struct TNCINFO * TNC, struct AGWINFO * AGW, PDATAMESSAGE buff, PMSGWITHLEN buffptr);
VOID UZ7HOCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
char * Cmd;
int port;
struct TNCINFO * TNC;
struct AGWINFO * AGW = 0;
PDATAMESSAGE buff;
PMSGWITHLEN buffptr;
CmdTail = CmdTail + (OrigCmdBuffer - COMMANDBUFFER); // Replace with original case version
Cmd = strlop(CmdTail, ' ');
port = atoi(CmdTail);
// remove trailing spaces
while(strlen(Cmd) && Cmd[strlen(Cmd) - 1] == ' ')
Cmd[strlen(Cmd) - 1] = 0;
TNC = TNCInfo[port];
if (TNC)
AGW = TNC->AGWInfo;
if (TNC == 0 || AGW == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - %d is not UZ7HO port\r", port);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
if (_memicmp(Cmd, "FREQ", 4) == 0 || _memicmp(Cmd, "MODEM", 5) == 0 || _memicmp(Cmd, "FLAGS", 5) == 0)
{
// Pass to procesing code in UZ7HO driver. This expects command in a PDATAMESSAGE amd places response in a PMSGWITHLEN buffer
buff = (PDATAMESSAGE)GetBuff();
buffptr = (PMSGWITHLEN)GetBuff();
if (buffptr == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "UZ7HO Command Failed - no buffers\r");
if (buff)
ReleaseBuffer(buff);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
buff->LENGTH = sprintf(buff->L2DATA, "%s\r", Cmd) + MSGHDDRLEN + 1;
if (_memicmp(Cmd, "FREQ", 4) == 0)
UZ7HOSetFreq(port, TNC, AGW, buff, buffptr);
else if (_memicmp(Cmd, "FLAGS", 5) == 0)
UZ7HOSetFlags(port, TNC, AGW, buff, buffptr);
else
UZ7HOSetModem(port, TNC, AGW, buff, buffptr);
Bufferptr = Cmdprintf(Session, Bufferptr, buffptr->Data);
ReleaseBuffer(buff);
ReleaseBuffer(buffptr);
}
else
Bufferptr = Cmdprintf(Session, Bufferptr, "Invalid UZ7HO Command (not Freq Modem or FLAGS)\r");
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
VOID QTSMCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
{
int port;
struct PORTCONTROL * PORT;
struct KISSINFO * KISS;
CmdTail = CmdTail + (OrigCmdBuffer - COMMANDBUFFER); // Replace with original case version
port = atoi(CmdTail);
PORT = GetPortTableEntryFromPortNum(port);
if (PORT == NULL || (void *)PORT->PORTTXROUTINE != (void *)KISSTX) // Must be a kiss like port
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - Port %d is not a KISS port\r", port);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
KISS = (struct KISSINFO *)PORT;
if (KISS->QtSMModem == 0)
{
Bufferptr = Cmdprintf(Session, Bufferptr, "Error - Port %d has no QtSM information\r", port);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Bufferptr = Cmdprintf(Session, Bufferptr, "Modem %s Centre frequency %d\r",
(KISS->QtSMModem) ? KISS->QtSMModem : "Not Available", KISS->QtSMFreq);
SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
return;
}
Reference in New Issue View Git Blame Copy Permalink