6.0.24.71

.svn/pristine/11/1105d6155b0f09c6edbdbc765bbd700d7d4d582a.svn-base

@@ -0,0 +1,402 @@
+/*
+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.  See 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 TNCCode.asm
+//
+#define Kernel
+
+#define _CRT_SECURE_NO_DEPRECATE 
+
+#pragma data_seg("_BPQDATA")
+
+#include "time.h"
+#include "stdio.h"
+#include <fcntl.h>
+
+#include "cheaders.h"
+#include "tncinfo.h"
+
+int C_Q_COUNT(VOID *PQ);
+VOID SENDUIMESSAGE(struct DATAMESSAGE * Msg);
+
+VOID TNCTimerProc()
+{
+	//	CALLED AT 10 HZ
+
+	int n = BPQHOSTSTREAMS;
+	PBPQVECSTRUC HOSTSESS = BPQHOSTVECTOR;
+	TRANSPORTENTRY * Session;
+	UCHAR DISCFLAG = 0;
+
+	while (n--)
+	{
+		//	Action any DISC Requests (must be done in timer owning process)
+
+		if (HOSTSESS->HOSTFLAGS & 0x40)		// DISC REQUEST
+		{
+			if (HOSTSESS->HOSTFLAGS & 0x20)	// Stay?
+				DISCFLAG = 'S';
+
+			HOSTSESS->HOSTFLAGS &= 0x9F;		// Clear Flags
+
+			Session = HOSTSESS->HOSTSESSION;
+
+			if (Session == 0)					// Gone??
+			{
+				HOSTSESS->HOSTFLAGS |= 3;		//  STATE CHANGE
+#ifndef LINBPQ
+				if (HOSTSESS->HOSTHANDLE);
+				{
+					PostMessage(HOSTSESS->HOSTHANDLE, BPQMsg, HOSTSESS->HOSTSTREAM, 4);
+				}
+#endif
+				continue;
+			}
+		
+			if (Session->L4CROSSLINK)
+				Session->L4CROSSLINK->STAYFLAG = DISCFLAG;
+
+			HOSTSESS->HOSTSESSION = 0;
+			HOSTSESS->HOSTFLAGS |= 3;		//  STATE CHANGE
+
+			PostStateChange(Session);
+
+			CloseSessionPartner(Session);	// SEND CLOSE TO PARTNER (IF PRESENT)
+		}
+	
+		// Check Trace Q
+
+		if (HOSTSESS->HOSTAPPLFLAGS & 0x80)
+		{
+			if (HOSTSESS->HOSTTRACEQ)
+			{
+				int Count = C_Q_COUNT(&HOSTSESS->HOSTTRACEQ);
+
+				if (Count > 100)
+						ReleaseBuffer((void *)Q_REM((void *)&HOSTSESS->HOSTTRACEQ));
+			}
+		}
+		HOSTSESS++;
+	}
+}
+
+VOID SendSmartID(struct PORTCONTROL * PORT)
+{
+	struct _MESSAGE * ID = IDMSG;
+	struct _MESSAGE * Buffer;
+
+	PORT->SmartIDNeeded = 0;
+
+	Buffer = GetBuff();
+
+	if (Buffer)
+	{
+		memcpy(Buffer, ID, ID->LENGTH);
+
+		Buffer->PORT = PORT->PORTNUMBER;
+
+		//	IF PORT HAS A CALLSIGN DEFINED, SEND THAT INSTEAD
+
+		if (PORT->PORTCALL[0] > 0x40)
+		{
+			memcpy(Buffer->ORIGIN, PORT->PORTCALL, 7);
+			Buffer->ORIGIN[6] |= 1;		// SET END OF CALL BIT
+		}
+
+		// If Pactor Style add to UI_Q
+
+		if (PORT->PROTOCOL == 10 && PORT->TNC && PORT->TNC->Hardware != H_KISSHF && PORT->UICAPABLE)
+		{
+			EXTPORTDATA * EXTPORT = (EXTPORTDATA *) PORT;
+
+			C_Q_ADD(&EXTPORT->UI_Q, Buffer);
+			return;
+		}
+
+		PUT_ON_PORT_Q(PORT, Buffer);
+	}
+}
+
+
+VOID SENDIDMSG()
+{
+	struct PORTCONTROL * PORT = PORTTABLE;
+	struct _MESSAGE * ID = IDMSG;
+	struct _MESSAGE * Buffer;
+
+	while (PORT)
+	{
+		if (PORT->PROTOCOL < 10)			// Not Pactor-style
+		{
+			Buffer = GetBuff();
+		
+			if (Buffer)
+			{
+				memcpy(Buffer, ID, ID->LENGTH);
+			
+				Buffer->PORT = PORT->PORTNUMBER;
+
+				//	IF PORT HAS A CALLSIGN DEFINED, SEND THAT INSTEAD
+
+				if (PORT->PORTCALL[0] > 0x40)
+				{
+					memcpy(Buffer->ORIGIN, PORT->PORTCALL, 7);
+					Buffer->ORIGIN[6] |= 1;		// SET END OF CALL BIT
+				}
+				C_Q_ADD(&IDMSG_Q, Buffer);
+			}
+		}
+		PORT = PORT->PORTPOINTER;
+	}
+}
+
+
+
+VOID SENDBTMSG()
+{
+	struct PORTCONTROL * PORT = PORTTABLE;
+	struct _MESSAGE * Buffer;
+	char * ptr1, * ptr2;
+
+	while (PORT)
+	{
+		if (PORT->PROTOCOL >= 10 || PORT->PORTUNPROTO == 0)	// Pactor-style or no UNPROTO ADDR?
+		{
+			PORT = PORT->PORTPOINTER;
+			continue;
+		}
+		
+		Buffer = GetBuff();
+
+		if (Buffer)
+		{
+			memcpy(Buffer->DEST, PORT->PORTUNPROTO, 7);
+			Buffer->DEST[6] |= 0xC0;		// Set Command bits
+
+			//	Send from BBSCALL unless PORTBCALL defined
+
+			if (PORT->PORTBCALL[0] > 32)
+				memcpy(Buffer->ORIGIN, PORT->PORTBCALL, 7);
+			else if (APPLCALLTABLE->APPLCALL[0] > 32) 
+				memcpy(Buffer->ORIGIN, APPLCALLTABLE->APPLCALL, 7);
+			else
+				memcpy(Buffer->ORIGIN, MYCALL, 7);
+
+			ptr1 = &PORT->PORTUNPROTO[7];		// First Digi
+			ptr2 = &Buffer->CTL;				// Digi field in buffer
+
+			// Copy any digis
+
+			while (*(ptr1))
+			{
+				memcpy(ptr2, ptr1, 7);
+				ptr1 += 7;
+				ptr2 += 7;
+			}
+
+			*(ptr2 - 1) |= 1;					// Set End of Address
+			*(ptr2++) = UI;
+	
+			memcpy(ptr2, &BTHDDR.PID, BTHDDR.LENGTH);
+			ptr2 += BTHDDR.LENGTH;
+			Buffer->LENGTH = (int)(ptr2 - (char *)Buffer);			
+			Buffer->PORT = PORT->PORTNUMBER;
+ 	
+			C_Q_ADD(&IDMSG_Q, Buffer);
+		}
+		PORT = PORT->PORTPOINTER;
+	}
+}
+
+VOID SENDUIMESSAGE(struct DATAMESSAGE * Msg)
+{
+	struct PORTCONTROL * PORT = PORTTABLE;
+	struct _MESSAGE * Buffer;
+	char * ptr1, * ptr2;
+
+	Msg->LENGTH -= MSGHDDRLEN;	// Remove Header
+
+	while (PORT)
+	{
+		if ((PORT->PROTOCOL == 10 && PORT->UICAPABLE == 0) || PORT->PORTUNPROTO == 0)	// Pactor-style or no UNPROTO ADDR?
+		{
+			PORT = PORT->PORTPOINTER;
+			continue;
+		}
+
+		Buffer = GetBuff();
+
+		if (Buffer)
+		{
+			memcpy(Buffer->DEST, PORT->PORTUNPROTO, 7);
+			Buffer->DEST[6] |= 0xC0;		// Set Command bits
+
+			//	Send from BBSCALL unless PORTBCALL defined
+
+			if (PORT->PORTBCALL[0] > 32)
+				memcpy(Buffer->ORIGIN, PORT->PORTBCALL, 7);
+			else if (APPLCALLTABLE->APPLCALL[0] > 32) 
+				memcpy(Buffer->ORIGIN, APPLCALLTABLE->APPLCALL, 7);
+			else
+				memcpy(Buffer->ORIGIN, MYCALL, 7);
+
+			ptr1  = &PORT->PORTUNPROTO[7];		// First Digi
+			ptr2 = &Buffer->CTL;				// Digi field in buffer
+
+			// Copy any digis
+
+			while (*(ptr1))
+			{
+				memcpy(ptr2, ptr1, 7);
+				ptr1 += 7;
+				ptr2 += 7;
+			}
+
+			*(ptr2 - 1) |= 1;					// Set End of Address
+			*(ptr2++) = UI;
+	
+			memcpy(ptr2, &Msg->PID, Msg->LENGTH);
+			ptr2 += Msg->LENGTH;
+			Buffer->LENGTH = (int)(ptr2 - (char *)Buffer);			
+			Buffer->PORT = PORT->PORTNUMBER;
+
+			if (PORT->PROTOCOL == 10)
+			{
+				EXTPORTDATA * EXTPORT = (EXTPORTDATA *) PORT;
+				C_Q_ADD(&EXTPORT->UI_Q,	Buffer);
+			}
+			else
+				C_Q_ADD(&IDMSG_Q, Buffer);
+		}
+		PORT = PORT->PORTPOINTER;
+	}
+}
+
+Dll VOID APIENTRY Send_AX(UCHAR * Block, DWORD Len, UCHAR Port)
+{
+	// Block included the 7/11 byte header, Len does not
+
+	struct PORTCONTROL * PORT;
+	PMESSAGE Copy;
+
+	if (Len > 360 - 15)
+		return;
+
+	if (QCOUNT < 50)
+		return;				// Running low
+
+	PORT = GetPortTableEntryFromPortNum(Port);
+
+	if (PORT == 0)
+		return;
+
+	Copy = GetBuff();
+
+	if (Copy == 0)
+		return;
+
+	memcpy(&Copy->DEST[0], &Block[MSGHDDRLEN], Len);
+
+	Copy->LENGTH = (USHORT)Len + MSGHDDRLEN;
+
+	if (PORT->PROTOCOL == 10 && PORT->TNC && PORT->TNC->Hardware != H_KISSHF)
+	{
+		// 	Pactor Style. Probably will only be used for Tracker uneless we do APRS over V4 or WINMOR
+
+		EXTPORTDATA * EXTPORT = (EXTPORTDATA *) PORT;
+
+		if (EXTPORT->UI_Q)
+			C_Q_ADD(&EXTPORT->UI_Q, Copy);
+		else
+			C_Q_ADD(&EXTPORT->UI_Q, Copy);
+		return;
+	}
+
+	Copy->PORT = Port; 
+
+	PUT_ON_PORT_Q(PORT, Copy);
+}
+
+
+TRANSPORTENTRY * SetupSessionFromHost(PBPQVECSTRUC HOST, UINT ApplMask)
+{
+	// Create a Transport (L4) session linked to an incoming HOST (API) Session
+
+	TRANSPORTENTRY * NewSess = L4TABLE;
+	int Index = 0;
+
+	
+	while (Index < MAXCIRCUITS)
+	{
+		if (NewSess->L4USER[0] == 0)
+		{
+			// Got One
+
+			UCHAR * ourcall = &MYCALL[0];
+		
+			// IF APPL PORT USE APPL CALL, ELSE NODE CALL
+
+			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, ourcall, 7);
+
+			NewSess->CIRCUITINDEX = Index;				//OUR INDEX
+			NewSess->CIRCUITID = NEXTID;
+
+			NEXTID++;
+			if (NEXTID == 0)
+				NEXTID++;								// Keep Non-Zero
+
+			NewSess->L4TARGET.HOST = HOST;
+			NewSess->L4STATE = 5;
+
+			
+			NewSess->SESSIONT1 = L4T1;
+			NewSess->L4WINDOW = (UCHAR)L4DEFAULTWINDOW;
+			NewSess->SESSPACLEN = PACLEN;				// Default;
+
+			return NewSess;
+			}
+		Index++;
+		NewSess++;
+	}
+
+	// Table Full
+
+	return NULL;
+}
+
+
+
+

.svn/pristine/82/82b4c07a08ce63307eed7efc5218070bd857ff44.svn-base

@@ -0,0 +1,434 @@
+
+#define _CRT_SECURE_NO_DEPRECATE
+
+#ifndef NOMQTT
+
+#include "MQTTAsync.h"
+#ifndef WIN32
+#include <jansson.h>
+#endif
+
+#include "cheaders.h"
+#include "asmstrucs.h"
+#include "mqtt.h"
+
+extern int MQTT_Connecting;
+extern int MQTT_Connected;
+
+
+DllExport int APIENTRY MQTTSend(char * topic, char * Msg, int MsgLen);
+
+MQTTAsync client = NULL;
+
+time_t MQTTLastStatus = 0;
+
+void MQTTSendStatus()
+{
+	char topic[256];
+	char payload[128];
+	
+	sprintf(topic, "PACKETNODE/%s", NODECALLLOPPED);
+	strcpy(payload,"{\"status\":\"online\"}");
+
+	MQTTSend(topic, payload, strlen(payload));
+	MQTTLastStatus = time(NULL);
+}
+
+void MQTTTimer()
+{
+	if (MQTT_Connecting == 0 && MQTT_Connected == 0)
+		MQTTConnect(MQTT_HOST, MQTT_PORT, MQTT_USER, MQTT_PASS);
+
+	if ((time(NULL) - MQTTLastStatus) > 1800)
+		MQTTSendStatus();
+
+}
+
+
+void MQTTDisconnect()
+{
+	if (MQTT_Connected)
+	{
+		MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer;
+
+		MQTTAsync_disconnect(client, &disc_opts);
+
+		MQTT_Connecting = MQTT_Connected = 0;
+
+		// Try to recconect. If it fails system will rety every minute
+
+		MQTTConnect(MQTT_HOST, MQTT_PORT, MQTT_USER, MQTT_PASS);
+	}
+}
+
+DllExport int APIENTRY MQTTSend(char * topic, char * Msg, int MsgLen)
+{
+	int rc;
+	
+	MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
+	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
+
+	pubmsg.payload = Msg;
+	pubmsg.payloadlen = MsgLen;
+	rc = MQTTAsync_sendMessage(client, topic, &pubmsg, &opts);
+
+	if (rc)
+		MQTTDisconnect();
+
+	return rc;
+}
+
+
+
+void onConnect(void* context, MQTTAsync_successData* response)
+{
+	MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
+	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
+
+	MQTT_Connecting = 0;
+	MQTT_Connected = 1;
+
+	printf("Successful MQTT connection\n");
+
+	// Send start up message
+
+	MQTTSendStatus();
+
+}
+
+void onConnectFailure(void* context, MQTTAsync_failureData* response)
+{
+	printf("MQTT connection failed, rc %d\n", response ? response->code : 0);
+	MQTT_Connecting = 0;
+}
+
+
+
+char* jsonEncodeMessage(MESSAGE *msg)
+{
+	char From[10];
+	char To[10];
+	
+	char buffer[1024];
+	unsigned long long SaveMMASK = MMASK;
+	BOOL SaveMTX = MTX;
+	BOOL SaveMCOM = MCOM;
+	BOOL SaveMUI = MUIONLY;
+	int len;
+	char *msg_str;
+	char payload_timestamp[16];
+
+	struct tm * TM = localtime(&msg->Timestamp);
+	sprintf(payload_timestamp, "%02d:%02d:%02d", TM->tm_hour, TM->tm_min, TM->tm_sec);
+
+	
+	IntSetTraceOptionsEx(MMASK, TRUE, TRUE, FALSE);
+	From[ConvFromAX25(msg->ORIGIN, From)] = 0;
+	To[ConvFromAX25(msg->DEST, To)] = 0;
+
+	len = IntDecodeFrame(msg, buffer, msg->Timestamp, 0xffffffffffffffff, FALSE, FALSE);
+	IntSetTraceOptionsEx(SaveMMASK, SaveMTX, SaveMCOM, SaveMUI);
+
+	buffer[len] = 0;
+
+#ifdef WIN32
+
+	msg_str = zalloc(2048);
+
+	sprintf(msg_str, "{\"from\": \"%s\", \"to\": \"%s\", \"payload\": \"%s\", \"port\": %d, \"timestamp\": \"%s\"}",
+		From, To, buffer, msg->PORT, payload_timestamp);
+
+#else
+
+	json_t *root;
+
+	root = json_object();
+
+	json_object_set_new(root, "from", json_string(From));
+	json_object_set_new(root, "to", json_string(To));
+
+
+	json_object_set_new(root, "payload", json_string(buffer));
+	json_object_set_new(root, "port", json_integer(msg->PORT));
+	sprintf(payload_timestamp, "%02d:%02d:%02d", TM->tm_hour, TM->tm_min, TM->tm_sec);
+	json_object_set_new(root, "timestamp", json_string(payload_timestamp));
+	msg_str = json_dumps(root, 0);
+	json_decref(root);
+
+#endif
+
+	return msg_str;
+}
+
+void MQTTKISSTX(void *message)
+{
+	MESSAGE *msg = (MESSAGE *)message;
+	char topic[256];
+	char *msg_str;
+
+	sprintf(topic, "PACKETNODE/ax25/trace/bpqformat/%s/sent/%d", NODECALLLOPPED, msg->PORT);
+
+	msg_str = jsonEncodeMessage(msg);
+
+	MQTTSend(topic, msg_str, strlen(msg_str));
+
+	free(msg_str);
+}
+
+void MQTTKISSTX_RAW(char* buffer, int bufferLength, void* PORT) 
+{
+	PPORTCONTROL PPORT = (PPORTCONTROL)PORT;
+	char topic[256];
+
+	sprintf(topic, "PACKETNODE/kiss/%s/sent/%d", NODECALLLOPPED, PPORT->PORTNUMBER);
+
+	MQTTSend(topic, buffer, bufferLength);
+}
+
+
+void MQTTKISSRX(void *message)
+{
+	MESSAGE *msg = (MESSAGE *)message;
+	char topic[256];
+	char *msg_str;
+
+
+	sprintf(topic, "PACKETNODE/ax25/trace/bpqformat/%s/rcvd/%d", NODECALLLOPPED, msg->PORT);
+	msg_str = jsonEncodeMessage(msg);
+
+	MQTTSend(topic, msg_str, strlen(msg_str));
+	
+	free(msg_str);
+}
+
+void MQTTKISSRX_RAW(char* buffer, int bufferLength, void* PORT)
+{
+	PPORTCONTROL PPORT = (PPORTCONTROL)PORT;
+	char topic[256];
+
+	sprintf(topic, "PACKETNODE/kiss/%s/rcvd/%d", NODECALLLOPPED, PPORT->PORTNUMBER);
+
+	MQTTSend(topic, buffer, bufferLength);
+
+}
+
+void MQTTReportSession(char * Msg)
+{
+	char topic[256];
+	sprintf(topic, "PACKETNODE/stats/session/%s", NODECALLLOPPED);
+
+	MQTTSend(topic, Msg, strlen(Msg));
+}
+
+
+char* replace(char* str, char* a, char* b)
+{
+	int len  = strlen(str);
+	int lena = strlen(a), lenb = strlen(b);
+	char * p;
+
+	for (p = str; p = strstr(p, a); p) {
+		if (lena != lenb) // shift end as needed
+			memmove(p + lenb, p + lena,
+				len - (p - str) + lenb);
+		memcpy(p, b, lenb);
+	}
+	return str;
+}
+
+int MQTTPublish(void *message, char *topic)
+{
+	MESSAGE *msg = (MESSAGE *)message;
+	char From[10];
+	char To[10];
+	MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
+	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
+
+	unsigned long long SaveMMASK = MMASK;
+	BOOL SaveMTX = MTX;
+	BOOL SaveMCOM = MCOM;
+	BOOL SaveMUI = MUIONLY;
+	int len;
+	char* replaced_buffer;
+	char buffer[1024];
+
+	time_t timestamp = msg->Timestamp;
+
+
+	From[ConvFromAX25(msg->ORIGIN, From)] = 0;
+	To[ConvFromAX25(msg->DEST, To)] = 0;
+
+
+	IntSetTraceOptionsEx(8, TRUE, TRUE, FALSE);
+	len = IntDecodeFrame(msg, buffer, timestamp, 1, FALSE, FALSE);
+	IntSetTraceOptionsEx(SaveMMASK, SaveMTX, SaveMCOM, SaveMUI);
+
+	// MQTT _really_ doesn't like \r, so replace it with something
+	// that is at least human readable
+	
+	replaced_buffer = replace(buffer, "\r", "\r\n");
+
+	pubmsg.payload = replaced_buffer;
+	pubmsg.payloadlen = strlen(replaced_buffer);
+
+	printf("%s\n", replaced_buffer);
+
+	return MQTTAsync_sendMessage(client, topic, &pubmsg, &opts);
+}
+
+int MQTTConnect(char* host, int port, char* user, char* pass)
+{
+	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
+	int rc;
+	char hostString[256];
+
+	sprintf(hostString, "tcp://%s:%d", host, port);
+
+	printf("MQTT Connect to %s\n", hostString);
+
+	rc = MQTTAsync_create(&client, hostString, NODECALLLOPPED, MQTTCLIENT_PERSISTENCE_NONE, NULL);
+
+	if (rc != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to create client, return code %d\n", rc);
+		return rc;
+	}
+
+	conn_opts.keepAliveInterval = 20;
+	conn_opts.cleansession = 1;
+	conn_opts.username = user;
+	conn_opts.password = pass;
+	conn_opts.onSuccess = onConnect;
+	conn_opts.onFailure = onConnectFailure;
+//	conn_opts.automaticReconnect = 1;
+//	conn_opts.minRetryInterval = 30;
+//	conn_opts.maxRetryInterval = 300;
+
+	rc = MQTTAsync_connect(client, &conn_opts);
+
+	if (rc != MQTTASYNC_SUCCESS)
+	{
+		printf("Failed to start connect, return code %d\n", rc);
+		return rc;
+	}
+
+	MQTT_Connecting = 1;
+
+	return 0;
+}
+
+// Message Database Entry. Designed to be compatible with FBB
+
+#define NBBBS 160			// Max BBSes we can forward to. Must be Multiple of 8, and must be 80 for FBB compatibliliy
+#define NBMASK NBBBS/8		// Number of bytes in Forward bitlists.
+
+#pragma pack(1)
+
+struct MsgInfo
+{
+	char	type;
+	char	status;
+	int		number;
+	int		length;
+	int		xdatereceived;
+	char	bbsfrom[7];			// ? BBS we got it from ?
+	char	via[41];
+	char	from[7];
+	char	to[7];
+	char	bid[13];
+	char	title[61];
+	int		nntpnum;			// Number within topic (ie Bull TO Addr) - used for nntp
+
+	UCHAR	B2Flags;			// Not all flags specific to B2
+
+	#define B2Msg 1				// Set if Message File is a formatted B2 message
+	#define Attachments 2		// Set if B2 message has attachments
+	#define FromPaclink 4
+	#define FromCMS 8
+	#define FromRMSExpress 16 
+	#define RadioOnlyMsg 32		// Received using call-T
+	#define RadioOnlyFwd 64		// Received using call-R
+	#define WarnNotForwardedSent 128
+
+	int		xdatecreated;
+	int		xdatechanged;
+	UCHAR	fbbs[NBMASK];
+	UCHAR	forw[NBMASK];
+	char	emailfrom[41];
+	char	Locked;				//	Set if selected for sending (NTS Pickup)
+	char	Defered;			//	FBB response '=' received
+	UCHAR	UTF8;				//	Set if Message is in UTF8 (ie from POP/SMTP)
+
+// For 64 bit time_t compatibility define as long long 
+// (so struct is same with 32 or 64 bit time_t)
+	
+	int64_t datereceived;
+	int64_t datecreated;
+	int64_t datechanged;
+
+	char	Spare[61 - 24];			//  For future use
+} ;
+
+#pragma pack()
+
+void MQTTMessageEvent(void* message)
+{
+	struct MsgInfo* msg = (struct MsgInfo *)message;
+	char *msg_str;
+	char * ptr;
+	MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
+	MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
+	char topic[256];
+
+	json_t *root = json_object();
+	json_object_set_new(root, "id", json_integer(msg->number));
+	json_object_set_new(root, "size", json_integer(msg->length));
+	json_object_set_new(root, "type", json_string(msg->type == 'P' ? "P" : "B"));
+	json_object_set_new(root, "to", json_string(msg->to));
+	json_object_set_new(root, "from", json_string(msg->from));
+	json_object_set_new(root, "subj", json_string(msg->title));
+
+	switch(msg->status) {
+		case 'N':
+			json_object_set_new(root, "event", json_string("newmsg"));
+			break;
+		case 'F':
+			json_object_set_new(root, "event", json_string("fwded"));
+			break;
+		case 'R':
+			json_object_set_new(root, "event", json_string("read"));
+			break;
+		case 'K':
+			json_object_set_new(root, "event", json_string("killed"));
+			break;
+	}
+
+	msg_str = json_dumps(root, 0);
+
+	pubmsg.payload = msg_str;
+	pubmsg.payloadlen = strlen(msg_str);
+
+
+	sprintf(topic, "PACKETNODE/event/%s/pmsg", NODECALLLOPPED);
+
+	MQTTAsync_sendMessage(client, topic, &pubmsg, &opts);
+}
+
+#else
+
+// Dummies ofr build without MQTT libraries
+
+int MQTTConnect(char* host, int port, char* user, char* pass)
+{
+	return 0;
+}
+
+void MQTTKISSTX(void *message) {};
+void MQTTKISSTX_RAW(char* buffer, int bufferLength, void* PORT) {};
+void MQTTKISSRX(void *message) {};
+void MQTTKISSRX_RAW(char* buffer, int bufferLength, void* PORT) {};
+void MQTTTimer() {};
+void MQTTReportSession(char * Msg) {};
+void MQTTMessageEvent(void* message) {};
+
+#endif

.svn/pristine/8e/8e0a2151765d2582d83d719015a50f469a644d6a.svn-base

@@ -0,0 +1,126 @@
+
+#ifdef Kernel
+
+#define Vers 5,2,9,2
+#define Verstring "5.2.9.2\0"
+#define Datestring "September 2012"
+#define VerComments "G8BPQ Packet Switch V5.2.9.2\0"
+#define VerCopyright "Copyright © 2001-2012 John Wiseman G8BPQ\0"
+#define VerDesc "BPQ32 Switch\0"
+
+#endif
+
+#define KVers 6,0,24,71
+#define KVerstring "6.0.24.71\0"
+
+
+#ifdef CKernel
+
+#define Vers KVers
+#define Verstring KVerstring
+#define Datestring "April 2025"
+#define VerComments "G8BPQ Packet Switch (C Version)" KVerstring
+#define VerCopyright "Copyright © 2001-2025 John Wiseman G8BPQ\0"
+#define VerDesc "BPQ32 Switch\0"
+#define VerProduct "BPQ32"
+
+#endif
+
+#ifdef TermTCP
+
+#define Vers 1,0,16,2
+#define Verstring "1.0.16.2\0"
+#define VerComments "Internet Terminal for G8BPQ Packet Switch\0"
+#define VerCopyright "Copyright © 2011-2025 John Wiseman G8BPQ\0"
+#define VerDesc "Simple TCP Terminal Program for G8BPQ Switch\0"
+#define VerProduct "BPQTermTCP"
+
+#endif
+
+#ifdef BPQTerm
+
+#define Vers 2,2,5,2
+#define Verstring "2.2.5.2\0"
+#define VerComments "Simple Terminal for G8BPQ Packet Switch\0"
+#define VerCopyright "Copyright © 1999-2025 John Wiseman G8BPQ\0"
+#define VerDesc "Simple Terminal Program for G8BPQ Switch\0"
+#define VerProduct "BPQTerminal"
+
+#endif
+
+#ifdef BPQTermMDI
+
+#define Vers 2,2,0,3
+#define Verstring "2.2.0.3\0"
+#define VerComments "MDI Terminal for G8BPQ Packet Switch\0"
+#define VerCopyright "Copyright © 1999-2025 John Wiseman G8BPQ\0"
+#define VerDesc "MDI Terminal Program for G8BPQ Switch\0"
+
+#endif
+
+#ifdef MAIL
+
+#define Vers KVers
+#define Verstring KVerstring
+#define VerComments "Mail server for G8BPQ Packet Switch\0"
+#define VerCopyright "Copyright © 2009-2025 John Wiseman G8BPQ\0"
+#define VerDesc "Mail server for G8BPQ's 32 Bit Switch\0"
+#define VerProduct "BPQMail"
+
+#endif
+
+#ifdef HOSTMODES
+
+#define Vers 1,1,8,1
+#define Verstring "1.1.8.1\0"
+//#define SPECIALVERSION "Test 3"
+#define VerComments "Host Modes Emulator for G8BPQ Packet Switch\0"
+#define VerCopyright "Copyright © 2009-2019 John Wiseman G8BPQ\0"
+#define VerDesc "Host Modes Emulator for G8BPQ's 32 Bit Switch\0"
+#define VerProduct "BPQHostModes"
+
+#endif
+
+
+#ifdef UIUTIL
+
+#define Vers 0,1,3,1
+#define Verstring "0.1.3.1\0"
+#define VerComments "Beacon Utility for G8BPQ Packet Switch\0"
+#define VerCopyright "Copyright © 2011-2019 John Wiseman G8BPQ\0"
+#define VerDesc "Beacon Utility for G8BPQ Switch\0"
+#define VerProduct "BPQUIUtil"
+
+#endif
+
+#ifdef AUTH
+
+#define Vers 0,1,0,0
+#define Verstring "0.1.0.0\0"
+#define VerComments "Password Generation Utility for G8BPQ Packet Switch\0"
+#define VerCopyright "Copyright © 2011-2025 John Wiseman G8BPQ\0"
+#define VerDesc "Password Generation Utility for G8BPQ Switch\0"
+
+#endif
+
+#ifdef APRS
+
+#define Vers KVers
+#define Verstring KVerstring
+#define VerComments  "APRS Client for G8BPQ Switch\0"
+#define VerCopyright "Copyright © 2012-2025 John Wiseman G8BPQ\0"
+#define VerDesc "APRS Client for G8BPQ Switch\0"
+#define VerProduct "BPQAPRS"
+
+#endif
+
+#ifdef CHAT
+ 
+#define Vers KVers
+#define Verstring KVerstring
+#define VerComments "Chat server for G8BPQ Packet Switch\0"
+#define VerCopyright "Copyright © 2009-2025 John Wiseman G8BPQ\0"
+#define VerDesc "Chat server for G8BPQ's 32 Bit Switch\0"
+#define VerProduct "BPQChat"
+
+#endif

.svn/pristine/ae/ae497302d0e2bf2b3ce3b157ec788450a8c5c1be.svn-base

@@ -0,0 +1,206 @@
+
+#ifndef CONFIGSTRUCT
+#define CONFIGSTRUCT
+
+
+// MAKE SURE SHORTS ARE CORRECTLY ALLIGNED FOR ARMV5
+
+struct PORTCONFIG
+{
+	short PORTNUM;
+	char ID[30];			//2
+	short TYPE;			    // 32,
+	short PROTOCOL;			// 34,
+	short IOADDR;			// 36,
+	short INTLEVEL;			// 38,
+	unsigned short SPEED;	// 40,
+	unsigned char CHANNEL;	// 42,
+	unsigned char pad;
+	short BBSFLAG;			// 44, 
+	short QUALITY;			// 46, 
+	short MAXFRAME;			// 48,
+	short TXDELAY;			// 50,
+	short SLOTTIME;			// 52, 
+	short PERSIST;			// 54,
+
+	short FULLDUP;			// 56,
+	short SOFTDCD;			// 58, 
+	short FRACK;			// 60, 
+	short RESPTIME;			// 62,
+	short RETRIES;			// 64, 
+
+	short PACLEN;			// 66,
+	short QUALADJUST;		// 68,
+	UCHAR DIGIFLAG;			// 70,
+	UCHAR DIGIPORT;			// 71 
+	short DIGIMASK;			// 72
+	short USERS;			// 74,
+	short TXTAIL;			// 76
+	unsigned char  ALIAS_IS_BBS;		// 78
+	unsigned char pad2;
+	char CWID[10];			// 80,
+	char PORTCALL[10];		//  90,
+	char PORTALIAS[10];		// 100,
+	char L3ONLY;			// 110,
+	char IGNOREUNLOCKED;	// 111
+	short KISSOPTIONS;		// 112,
+	short INTERLOCK;		// 114,
+	short NODESPACLEN;		// 116,
+	short TXPORT;			// 118,
+	UCHAR MHEARD;			// 120,
+	UCHAR CWIDTYPE;			// 121,
+	char MINQUAL;			// 122, 
+	char MAXDIGIS;			//  123,
+	char DefaultNoKeepAlives; // 124
+	char UIONLY;			// 125,
+	unsigned short ListenPort;	// 126
+	char UNPROTO[72];		//  128, 
+	char PORTALIAS2[10];	//  200,
+	char DLLNAME[16];		//  210,
+	char BCALL[10];			// 226,
+	unsigned long IPADDR;	// 236
+	char I2CMode;			// 240
+	char I2CAddr;			// 241
+	char INP3ONLY;			// 242
+	char NoNormalize;		// 243 Normalise Nodes Qualities
+	unsigned short TCPPORT;	// 244
+	char Pad2[10];			// 246
+	char VALIDCALLS[256];	//   256 - 512
+	struct WL2KInfo * WL2K;			// 512
+	char * SerialPortName; // 516
+	struct XDIGI * XDIGIS;	//  596 Cross port digi setup
+	int RIGPORT;			// Linked port with RigControl 
+	unsigned int PERMITTEDAPPLS;	// Appls allowed on this port
+	int HavePermittedAppls;			// Indicated PERMITTEDAPPLS uses
+	int Hide;				// Don't show on Ports display or AGW Connect Menu
+//	long long txOffset;		// Transverter tx offset 
+//	long long rxOffset;		// Transverter rx offset ppa
+	int SmartID;
+	unsigned char * KissParams;
+	int SendtoM0LTEMap;
+	uint64_t PortFreq;
+	char * M0LTEMapInfo;
+	int QtSMPort;
+	int AllowINP3;
+};
+
+struct ROUTECONFIG
+{
+	char call[80];		// May have VIA
+	int quality;
+	int port;
+	int pwind;
+	int pfrack;
+	int ppacl;
+	int farQual;
+};
+
+struct CONFIGTABLE
+{
+//	CONFIGURATION DATA STRUCTURE
+
+//	DEFINES LAYOUT OF CONFIG RECORD PRODUCED BY CONFIGURATION PROG
+
+	char C_NODECALL[10];		// OFFSET = 0 
+	char C_NODEALIAS[10];		// OFFSET = 10
+	char C_BBSCALL[10];			// OFFSET = 20
+	char C_BBSALIAS[10];		// OFFSET = 30
+
+	short C_OBSINIT;			// OFFSET = 40
+	short C_OBSMIN;				// OFFSET = 42
+	short C_NODESINTERVAL;		// OFFSET = 44
+	short C_L3TIMETOLIVE;		// OFFSET = 46
+	short C_L4RETRIES;			// OFFSET = 48
+	short C_L4TIMEOUT;			// OFFSET = 50
+	short C_BUFFERS;			// OFFSET = 52
+	short C_PACLEN;				// OFFSET = 54
+	short C_TRANSDELAY;			// OFFSET = 56
+	short C_T3;					// OFFSET = 58
+	short Spare1;				// OFFSET = 60
+	short Spare2;				// OFFSET = 62
+	short C_IDLETIME;			// OFFSET = 64
+	UCHAR C_EMSFLAG;			// OFFSET = 66
+	UCHAR C_LINKEDFLAG;			// OFFSET = 67
+	UCHAR C_BBS;				// OFFSET = 68
+	UCHAR C_NODE;				// OFFSET = 69
+	UCHAR C_HOSTINTERRUPT;		// OFFSET = 70
+	UCHAR C_DESQVIEW;			// OFFSET = 71
+	short C_MAXLINKS;			// OFFSET = 72
+	short C_MAXDESTS;
+	short C_MAXNEIGHBOURS;
+	short C_MAXCIRCUITS;		// 78
+	UCHAR C_TNCPORTLIST[16];	// OFFSET = 80
+	short C_IDINTERVAL;			// 96
+	short C_FULLCTEXT;			// 98    ; SPARE (WAS DIGIFLAG)
+	short C_MINQUAL;			// 100
+	UCHAR C_HIDENODES;			// 102
+	UCHAR C_AUTOSAVE;			// 103
+	short C_L4DELAY;			// 104
+	short C_L4WINDOW;			// 106
+	short C_BTINTERVAL;			// 108
+	UCHAR C_L4APPL;				// 110
+	UCHAR C_C;					//  111 "C" = HOST Command Enabled
+	UCHAR C_IP;					//  112 IP Enabled
+	UCHAR C_MAXRTT;				// 113
+	UCHAR C_MAXHOPS;			// 114
+	UCHAR C_PM;					// 115 Poermapper Enabled
+	UCHAR C_LogL4Connects;		// 116
+	UCHAR C_SaveMH;				// 117
+	short C_BBSQUAL;			// 118
+	UCHAR C_WASUNPROTO;
+	UCHAR C_BTEXT[120];			// 121
+	char C_VERSTRING[10];		// 241 Version String from Config File
+	UCHAR C_ADIF;
+	UCHAR C_EVENTS;
+	UCHAR C_LogAllConnects;	
+	UCHAR C_SaveAPRSMsgs;
+	UCHAR C_M0LTEMap;
+	UCHAR C_VERSION;			// CONFIG PROG VERSION
+//	Reuse C_APPLICATIONS - no longer used
+	char C_NETROMCALL[10];
+	UCHAR C_EXCLUDE[71];
+	char C_IDMSG[512];
+	char C_CTEXT[512];
+	char C_INFOMSG[2048];
+	UCHAR CfgBridgeMap[MaxBPQPortNo + 1][MaxBPQPortNo + 1];
+	struct ROUTECONFIG C_ROUTE[MaxLockedRoutes];
+	struct APPLCONFIG C_APPL[NumberofAppls];
+	struct PORTCONFIG C_PORT[MaxBPQPortNo + 4];
+	int C_MQTT;
+	char C_MQTT_HOST[80];
+	int C_MQTT_PORT;
+	char C_MQTT_USER[80];
+	char C_MQTT_PASS[80];
+	int C_L4Compress;
+	int C_L4CompMaxframe;
+	int C_L4CompPaclen;
+	int C_L2Compress;
+	int C_L2CompMaxframe;
+	int C_L2CompPaclen;
+	int C_PREFERINP3ROUTES;
+
+
+//#define ApplOffset 80000			// Applications offset in config buffer
+//#define InfoOffset 85000			// Infomsg offset in  buffer
+//#define InfoMax	2000				// Max Info
+
+//#define C_IDMSG	512 
+//#define C_ROUTES 90000				// Allow 2500
+//#define C_CTEXT	2048
+//#define C_PORTS	2560
+//#define C_INFOMSG 85000
+
+};
+
+struct UPNP 
+{
+	struct UPNP * Next;
+	char * Protocol;
+	char * LANport;
+	char * WANPort;
+};
+
+#endif
+
+
+

.svn/pristine/e6/e6f1a50cb47bd75bfc868415b91a1ec6b3f630d5.svn-base

@@ -0,0 +1,216 @@
+// Includes code from MiniUPnPc, used subject to the following conditions:
+
+/*
+
+MiniUPnPc
+Copyright (c) 2005-2020, Thomas BERNARD
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * The name of the author may not be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#define MINIUPNP_STATICLIB
+
+#include <stdio.h>
+#ifdef _WIN32
+#include "upnpcommands.h"
+#include "miniupnpc.h"
+#include "upnperrors.h"
+#include <winsock2.h>
+#endif
+#ifdef LINBPQ
+#ifndef MACBPQ
+#ifndef WIN32
+#include <miniupnpc/upnpcommands.h>
+#include <miniupnpc/miniupnpc.h>
+#include <miniupnpc/upnperrors.h>
+#include <stdio.h>
+#endif
+#endif
+#endif
+#ifdef MACBPQ
+#include </usr/local/Cellar/miniupnpc/2.2.5/include/miniupnpc/upnpcommands.h>
+#include </usr/local/Cellar/miniupnpc/2.2.5/include/miniupnpc/miniupnpc.h>
+#include </usr/local/Cellar/miniupnpc/2.2.5/include/miniupnpc/upnperrors.h>
+#include <stdio.h>
+#endif
+int AddMap(char * controlURL, char * eport, char * iport, char * proto);
+int DeleteMap(char * controlURL, char * eport, char * iport, char * proto);
+
+void Consoleprintf(const char * format, ...);
+
+struct UPNP 
+{
+	struct UPNP * Next;
+	char * Protocol;
+	char * LANport;
+	char * WANPort;
+};
+
+extern struct UPNP * UPNPConfig;
+
+char * controlURL = 0;
+char * servicetype = 0;
+char iaddr[] = "IP";
+char * inClient = NULL;
+#ifdef LINBPQ
+char desc[] = "LinBPQ ";
+#else
+char desc[] = "BPQ32 ";
+#endif
+char * remoteHost = NULL;
+char * leaseDuration = NULL;
+
+struct UPNPDev * devlist = 0;
+char lanaddr[64] = "unset";	/* my ip address on the LAN */
+char wanaddr[64] = "unset";	/* my ip address on the LAN */
+struct UPNPUrls urls;
+struct IGDdatas data;
+
+int i;
+const char * rootdescurl = 0;
+const char * multicastif = 0;
+const char * minissdpdpath = 0;
+#ifdef UPNP_LOCAL_PORT_ANY
+int localport = UPNP_LOCAL_PORT_ANY;
+#else
+int localport = 0;
+#endif
+int retcode = 0;
+int error = 0;
+int ipv6 = 0;
+int ignore = 0;
+unsigned char ttl = 2;
+
+
+int upnpInit()
+{
+	struct UPNP * Config = UPNPConfig;
+	int i;
+#ifdef WIN32
+	WSADATA wsaData;
+	int nResult = WSAStartup(MAKEWORD(2,2), &wsaData);
+	if(nResult != NO_ERROR)
+	{
+		fprintf(stderr, "WSAStartup() failed.\n");
+		return -1;
+	}
+#endif
+
+	while (Config)
+	{
+		if (devlist == NULL)
+		{
+#if MINIUPNPC_API_VERSION == 10
+			devlist = upnpDiscover(2000, multicastif, minissdpdpath, localport, ipv6, &error);
+#else
+			devlist = upnpDiscover(2000, multicastif, minissdpdpath, localport, ipv6, ttl, &error);
+#endif
+			if (devlist == NULL)
+			{
+				Consoleprintf("Failed to find a UPNP device");
+				return 0;
+			}
+
+#if MINIUPNPC_API_VERSION == 18
+			i = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr), wanaddr, sizeof(wanaddr));
+#else
+			i = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
+#endif
+		}
+		
+		AddMap(devlist->descURL, Config->LANport, Config->WANPort, Config->Protocol);		
+		Config = Config->Next;
+	}
+
+	return 0;
+}
+
+int upnpClose()
+{
+	struct UPNP * Config = UPNPConfig;
+	int i;
+
+	while (Config)
+	{
+		if (devlist == NULL)
+		{
+#if MINIUPNPC_API_VERSION == 10
+			devlist = upnpDiscover(2000, multicastif, minissdpdpath, localport, ipv6, &error);
+#else
+			devlist = upnpDiscover(2000, multicastif, minissdpdpath, localport, ipv6, ttl, &error);
+#endif
+			if (devlist == NULL)
+			{
+				Consoleprintf("Failed to find a UPNP device");
+				return 0;
+			}
+
+#if MINIUPNPC_API_VERSION == 18
+			i = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr), wanaddr, sizeof(wanaddr));
+#else
+			i = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
+#endif	
+		}
+		
+		DeleteMap(devlist->descURL, Config->LANport, Config->WANPort, Config->Protocol);		
+		Config = Config->Next;
+	}
+
+	return 0;
+}
+
+int AddMap(char * controlURL, char * eport, char * iport, char * proto)
+{
+	int r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
+					eport, iport, lanaddr, desc,
+					proto, remoteHost, leaseDuration);
+		
+	if (r != UPNPCOMMAND_SUCCESS)
+	{
+		Consoleprintf("UPNP AddPortMapping(%s, %s, %s) failed with code %d (%s)", eport, iport, lanaddr, r, strupnperror(r));
+		return -2;
+	}
+	Consoleprintf("UPNP AddPortMapping(%s, %s, %s) Succeeded", eport, iport, lanaddr, r);
+	return 0;
+}
+
+int DeleteMap(char * controlURL, char * eport, char * iport, char * proto)
+{
+	int r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, eport, proto, remoteHost);
+
+	if(r != UPNPCOMMAND_SUCCESS)
+	{
+		Consoleprintf("UPNP DeletePortMapping(%s, %s, %s) failed with code %d (%s)", eport, iport, lanaddr, r, strupnperror(r));
+		return -2;
+	}
+	Consoleprintf("UPNP DeletePortMapping(%s, %s, %s) Succeeded", eport, iport, lanaddr, r);
+
+	return 0;
+}
+
+
+
+

BBSUtilities.c

@@ -10586,7 +10586,7 @@ int Connected(int Stream)
 	char callsign[10];
 	int port, paclen, maxframe, l4window;
 	char ConnectedMsg[] = "*** CONNECTED    ";
-	char Msg[100];
+	char Msg[256];
 	char Title[100];
 	int64_t Freq = 0;
 	int Mode = 0;
@@ -10669,7 +10669,13 @@ int Connected(int Stream)
 					}
 				}
 			}
-	
+
+			if (Mode < 0 || Mode > 54)
+				Mode = 0;
+
+			if (Freq < 0 || Freq > 11000000000)
+				Freq = 0;
+
 			memset(conn, 0, sizeof(ConnectionInfo));		// Clear everything
 			conn->Active = TRUE;
 			conn->BPQStream = Stream;
@@ -10734,7 +10740,7 @@ int Connected(int Stream)
 							LongFreq = GetPortFrequency(port, FreqString);
 #endif
 					}
-					Length += sprintf(MailBuffer, "New User %s Connected to Mailbox on Port %d Freq %d Mode %ld\r\n", callsign, port, LongFreq, Mode);
+					Length += sprintf(MailBuffer, "New User %s Connected to Mailbox on Port %d Freq %lld Mode %d\r\n", callsign, port, LongFreq, Mode);
 
 					sprintf(Title, "New User %s", callsign);
 
@@ -10794,10 +10800,10 @@ int Connected(int Stream)
 			}
 
 			if (port)
-				n=sprintf_s(Msg, sizeof(Msg), "Incoming Connect from %s on Port %d Freq %d Mode %s",
+				n = sprintf_s(Msg, sizeof(Msg), "Incoming Connect from %s on Port %d Freq %lld Mode %s",
 					user->Call,  port, Freq, WL2KModes[Mode]);
 			else
-				n=sprintf_s(Msg, sizeof(Msg), "Incoming Connect from %s", user->Call);
+				n = sprintf_s(Msg, sizeof(Msg), "Incoming Connect from %s", user->Call);
 			
 			// Send SID and Prompt (Unless Sync)
 

BPQMail.c

@@ -1152,6 +1152,7 @@
 //	Fixes to using {FormFolder} in Webmail Templates (68)
 //	Save FBB transfer restart data over program restarts (69) 
 //	Add Send and Receive byte counts to status displays (69)
+//	Validate Mode and Frequency and fix formatting in Connected Message (71)
 
 #include "bpqmail.h"
 #include "winstdint.h"

Bpq32.c

@@ -1265,6 +1265,8 @@ along with LinBPQ/BPQ32.  If not, see http://www.gnu.org/licenses
 //	Improve handling of binary data in RHP interface (70)
 //	Fix sending KISS commands to multiport or multidropped TNCs (70)
 //	Add MHUV and MHLV commands (Verbose listing with timestamps in clock time) (70)
+//	Improvements to INP3 (71)
+//	Improvements to KAM driver including support for GTOR connects (71)
 
 #define CKernel
 
@@ -2386,6 +2388,8 @@ FirstInit()
 	}
 
 	timeLoadedMS = GetTickCount();
+
+	srand(time(NULL));
 	
 	INITIALISEPORTS();
 

Cmd.c

@@ -1229,38 +1229,81 @@ VOID CMDSTATS(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct
 	SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
 }
 
+#define	PFBIT 0x10		// POLL/FINAL BIT IN CONTROL BYTE
+
+VOID InformPartner(struct _LINKTABLE * LINK, int Reason);
+VOID L2SENDCOMMAND(struct _LINKTABLE * LINK, int CMD);
+BOOL FindLink(UCHAR * LinkCall, UCHAR * OurCall, int Port, struct _LINKTABLE ** REQLINK);
+
 VOID CMDL00(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CMDX * CMD)
 {
 	//	PROCESS 'LINKS' MESSAGE
 
 	struct _LINKTABLE * LINK = LINKS;
 	int n = MAXLINKS;
-	int len;
+	int len, Count;
 	char Normcall[11] = "";
+	UCHAR DEST[7];
+	UCHAR ORIGIN[7];
+	int Port = 0;
+	char * ptr = 0, * Context;
 
-	Bufferptr = Cmdprintf(Session, Bufferptr, "Links\r");
+	ptr = strtok_s(CmdTail, " ", &Context);
 
-	while (n--)
+	if (ptr && _stricmp(ptr, "reset") == 0)
 	{
-		if (LINK->LINKCALL[0])
-		{
-			len = ConvFromAX25(LINK->LINKCALL, Normcall);
+		ptr = strtok_s(NULL, " ", &Context);
+		if (ptr)
+			ConvToAX25(ptr, DEST);
 
-			Bufferptr = Cmdprintf(Session, Bufferptr, "%s", Normcall);
+		ptr = strtok_s(NULL, " ", &Context);
+		if (ptr)
+			ConvToAX25(ptr, ORIGIN);
+
+		ptr = strtok_s(NULL, " ", &Context);
+		if (ptr)
+			Port = atoi(ptr);
 
-			len = ConvFromAX25(LINK->OURCALL, Normcall);
-			Bufferptr = Cmdprintf(Session, Bufferptr, "%s", Normcall);
+		if (FindLink(DEST, ORIGIN, Port, &LINK))
+		{
+			InformPartner(LINK, NORMALCLOSE);	// TELL OTHER END ITS GONE
 
-			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->L2RETRIES -= 1;		// Just send one DISC
+			LINK->L2STATE = 4;			// CLOSING
+
+			L2SENDCOMMAND(LINK, DISC | PFBIT);
+			Bufferptr = Cmdprintf(Session, Bufferptr, "Link Reset\r");
 		}
-		LINK++;
+		else
+			Bufferptr = Cmdprintf(Session, Bufferptr, "Link Not Found\r");
+
 	}
+	else
+	{
+		Bufferptr = Cmdprintf(Session, Bufferptr, "Links\r");
 
+		while (n--)
+		{
+			if (LINK->LINKCALL[0])
+			{
+				len = ConvFromAX25(LINK->LINKCALL, Normcall);
+				Count = COUNT_AT_L2(LINK);
+
+				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 Q=%d\r",
+					LINK->L2STATE, LINK->LINKPORT->PORTNUMBER, LINK->LINKTYPE, Count);
+				else
+					Bufferptr = Cmdprintf(Session, Bufferptr, " S=%d P=%d T=%d V=%d Q=%d\r",
+					LINK->L2STATE, LINK->LINKPORT->PORTNUMBER, LINK->LINKTYPE, 2 - LINK->VER1FLAG, Count);
+			}
+			LINK++;
+		}
+	}
 	SendCommandReply(Session, REPLYBUFFER, (int)(Bufferptr - (char *)REPLYBUFFER));
 }
 
@@ -2845,7 +2888,7 @@ char * DoOneNode(TRANSPORTENTRY * Session, char * Bufferptr, struct DEST_LIST *
 	char Normcall[10];
 	char Alias[10];
 	struct NR_DEST_ROUTE_ENTRY * NRRoute;
-	struct DEST_ROUTE_ENTRY * Route;
+	struct INP3_DEST_ROUTE_ENTRY * Route;
 	struct ROUTE * Neighbour;
 	int i, Active, len;
 
@@ -2886,7 +2929,7 @@ char * DoOneNode(TRANSPORTENTRY * Session, char * Bufferptr, struct DEST_LIST *
 
 	//	DISPLAY  INP3 ROUTES
 
-	Route = &Dest->ROUTE[0];
+	Route = &Dest->INP3ROUTE[0];
 
 	Active = Dest->DEST_ROUTE;
 
@@ -2943,17 +2986,17 @@ int DoINP3ViaEntry(struct DEST_LIST * Dest, int n, char * line, int cursor)
 	int len;
 	double srtt;
 
-	if (Dest->ROUTE[n].ROUT_NEIGHBOUR != 0)
+	if (Dest->INP3ROUTE[n].ROUT_NEIGHBOUR != 0)
 	{
-		srtt = Dest->ROUTE[n].SRTT/1000.0;
+		srtt = Dest->INP3ROUTE[n].SRTT/1000.0;
 
-		len=ConvFromAX25(Dest->ROUTE[n].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Portcall);
+		len=ConvFromAX25(Dest->INP3ROUTE[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);
+			Dest->INP3ROUTE[n].ROUT_NEIGHBOUR->NEIGHBOUR_PORT,
+			Dest->INP3ROUTE[n].Hops, srtt);
 
 		cursor+=len;
 
@@ -3241,7 +3284,7 @@ NODE_VIA:
 	{
 		Dest+=1;
 
-		if (Dest->NRROUTE[0].ROUT_NEIGHBOUR == 0 && Dest->ROUTE[0].ROUT_NEIGHBOUR == 0)
+		if (Dest->NRROUTE[0].ROUT_NEIGHBOUR == 0 && Dest->INP3ROUTE[0].ROUT_NEIGHBOUR == 0)
 			continue;
 
 
@@ -3249,9 +3292,9 @@ NODE_VIA:
 			|| (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)))
+			|| (Dest->INP3ROUTE[0].ROUT_NEIGHBOUR && CompareCalls(Dest->INP3ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL))
+			|| (Dest->INP3ROUTE[1].ROUT_NEIGHBOUR && CompareCalls(Dest->INP3ROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL))
+			|| (Dest->INP3ROUTE[2].ROUT_NEIGHBOUR && CompareCalls(Dest->INP3ROUTE[2].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, AXCALL)))
 		{
 			len=ConvFromAX25(Dest->DEST_CALL,Normcall);
 

CommonCode.c

@@ -77,6 +77,8 @@ char * stristr (char *ch1, char *ch2);
 
 extern VOID * ENDBUFFERPOOL;
 
+extern int PoolBuilt;
+
 
 //	Read/Write length field in a buffer header
 
@@ -363,7 +365,7 @@ BOK1:
 
 		if (n > 1000)
 		{
-			Debugprintf("Loop searching free chain - pointer = %p %p", debug, pointer);
+			Debugprintf("Releasebuffer Loop searching free chain - pointer = %p %p from %s Line %d", debug, pointer, File, Line);
 			return 0;
 		}
 	}
@@ -376,6 +378,11 @@ BOK1:
 
 	QCOUNT++;
 
+	if (PoolBuilt && QCOUNT > MAXBUFFS)
+	{
+		Debugprintf("Releasebuffer QCOUNT > MAXBUFFS - pointer = %p from %s Line %d", pointer, File, Line);
+		return 0;
+	}
 	return 0;
 }
 
@@ -473,7 +480,7 @@ int C_Q_ADD_NP(VOID *PQ, VOID *PBUFF)
 	next = Q[0];
 
 	while (next[0] != 0)
-		next=next[0];				// Chain to end of queue
+		next = next[0];				// Chain to end of queue
 
 	next[0] = BUFF;					// New one on end
 

FBBRoutines.c

@@ -2065,7 +2065,7 @@ BOOL LookupRestart(CIRCUIT * conn, struct FBBHeaderLine * FBBHeader)
 
 			RestartRec->Count++;
 
-			if (RestartRec->Count > 3)
+			if (RestartRec->Count > 10)
 			{
 				len = sprintf_s(Msg, sizeof(Msg), "Too many restarts for %s - Requesting restart from beginning",
 					FBBHeader->BID);

FreeDATA.c

@@ -452,6 +452,11 @@ static size_t ExtProc(int fn, int port, PDATAMESSAGE buff)
 				TNC->lasttime = ltime;
 				ConnecttoFreeData(port);
 			}
+			while (TNC->PortRecord->UI_Q)
+			{
+				buffptr = Q_REM(&TNC->PortRecord->UI_Q);
+				ReleaseBuffer(buffptr);	
+			}
 		}
 
 

KAMPactor.c

@@ -70,6 +70,8 @@ static RECT Rect;
 
 int DoScanLine(struct TNCINFO * TNC, char * Buff, int Len);
 VOID WritetoTrace(struct TNCINFO * TNC, char * Msg, int Len);
+VOID SuspendOtherPorts(struct TNCINFO * ThisTNC);
+VOID ReleaseOtherPorts(struct TNCINFO * ThisTNC);
 
 static FILE * LogHandle[32] = {0};
 
@@ -517,6 +519,28 @@ ok:
 	return 0;
 }
 
+VOID KAMSuspendPort(struct TNCINFO * TNC, struct TNCINFO * ThisTNC)
+{
+	struct STREAMINFO * STREAM = &TNC->Streams[0];
+
+	strcpy(TNC->WEB_TNCSTATE, "Interlocked");
+	MySetWindowText(TNC->xIDC_TNCSTATE, TNC->WEB_TNCSTATE);
+
+//	STREAM->CmdSet = STREAM->CmdSave = zalloc(100);
+//	sprintf(STREAM->CmdSet, "I%s\r", "SCSPTC");		// Should prevent connects
+
+}
+
+VOID KAMReleasePort(struct TNCINFO * TNC)
+{
+	struct STREAMINFO * STREAM = &TNC->Streams[0];
+
+	strcpy(TNC->WEB_TNCSTATE, "Free");
+	MySetWindowText(TNC->xIDC_TNCSTATE, TNC->WEB_TNCSTATE);
+
+}
+
+
 static int WebProc(struct TNCINFO * TNC, char * Buff, BOOL LOCAL)
 {
 	int Len = sprintf(Buff, "<html><meta http-equiv=expires content=0><meta http-equiv=refresh content=15>"
@@ -595,6 +619,11 @@ void * KAMExtInit(EXTPORTDATA * PortEntry)
 	PortEntry->PORTCONTROL.PORTSTARTCODE = KAMStartPort;
 	PortEntry->PORTCONTROL.PORTSTOPCODE = KAMStopPort;
 
+//	TNC->SuspendPortProc = KAMSuspendPort;
+//	TNC->ReleasePortProc = KAMReleasePort;
+
+
+
 	ptr=strchr(TNC->NodeCall, ' ');
 	if (ptr) *(ptr) = 0;					// Null Terminate
 
@@ -1266,6 +1295,51 @@ VOID KAMPoll(int Port)
 					return;
 				}
 
+				if (memcmp(MsgPtr, "GTOR ", 5) == 0)	// GTOR Connect
+				{
+					memcpy(STREAM->RemoteCall, &MsgPtr[5], 9);
+					STREAM->Connecting = TRUE;
+
+					// If Stream 0, Convert C CALL to PACTOR CALL
+
+					if (Stream == 0)
+					{
+						datalen = sprintf(TXMsg, "C20GTOR %s", TNC->Streams[0].RemoteCall);
+						
+						// If Pactor, check busy detecters on any interlocked ports
+
+						if (TNC->HFPacket == 0 && InterlockedCheckBusy(TNC) && TNC->OverrideBusy == 0)
+						{
+							// Channel Busy. Wait
+
+							TNC->ConnectCmd = _strdup(TXMsg);
+
+							sprintf(TNC->WEB_TNCSTATE, "Waiting for clear channel");
+							SetWindowText(TNC->xIDC_TNCSTATE, TNC->WEB_TNCSTATE);
+
+							TNC->BusyDelay = TNC->BusyWait * 10;
+
+							return;
+						}
+
+						TNC->OverrideBusy = FALSE;
+
+						sprintf(TNC->WEB_TNCSTATE, "%s Connecting to %s",
+							TNC->Streams[0].MyCall, TNC->Streams[0].RemoteCall);
+						SetWindowText(TNC->xIDC_TNCSTATE, TNC->WEB_TNCSTATE);
+					}
+					else
+						datalen = sprintf(TXMsg, "C1%cC %s", Stream + '@', STREAM->RemoteCall);
+
+					EncodeAndSend(TNC, TXMsg, datalen);
+					TNC->Timeout = 50;
+					TNC->InternalCmd = 'C';			// So we dont send the reply to the user.
+					ReleaseBuffer(buffptr);
+					STREAM->Connecting = TRUE;
+
+					return;
+				}
+
 				if (memcmp(MsgPtr, "DISCONNECT", datalen) == 0)	// Disconnect
 				{
 					if (Stream == 0)
@@ -1644,6 +1718,10 @@ VOID ProcessKHOSTPacket(struct TNCINFO * TNC, UCHAR * Msg, int Len)
 			return;
 		}
 
+
+		WritetoTrace(TNC, Buffer, Len);
+
+
 		// Pass to Appl
 
 		Stream = TNC->CmdStream;
@@ -1790,6 +1868,10 @@ VOID ProcessKHOSTPacket(struct TNCINFO * TNC, UCHAR * Msg, int Len)
 				if (Msg[1] == '2' && Msg[2] == 'A')
 					TNC->HFPacket = TRUE;
 
+				// Stop other ports in same group
+
+				SuspendOtherPorts(TNC);
+
 				ProcessIncommingConnect(TNC, Call, Stream, TRUE);
 
 				SESS = TNC->PortRecord->ATTACHEDSESSIONS[Stream];
@@ -2047,7 +2129,11 @@ VOID ForcedClose(struct TNCINFO * TNC, int Stream)
 
 VOID CloseComplete(struct TNCINFO * TNC, int Stream)
 {
-		TNC->NeedPACTOR = 50;	
+	sprintf(TNC->WEB_TNCSTATE, "Free");
+	SetWindowText(TNC->xIDC_TNCSTATE, TNC->WEB_TNCSTATE);
+
+	ReleaseOtherPorts(TNC);
+	TNC->NeedPACTOR = 50;	
 }
 
 

L2Code.c

@@ -121,6 +121,7 @@ void hookL2SessionAccepted(int Port, char * fromCall, char * toCall, struct _LIN
 void hookL2SessionDeleted(struct _LINKTABLE * LINK);
 void hookL2SessionAttempt(int Port, char * fromCall, char * toCall, struct _LINKTABLE * LINK);
 int L2Compressit(unsigned char * Out, int OutSize, unsigned char * In, int Len);
+VOID DeleteINP3Routes(struct ROUTE * Route);
 
 extern int REALTIMETICKS;
 
@@ -1184,8 +1185,9 @@ VOID L2LINKACTIVE(struct _LINKTABLE * LINK, struct PORTCONTROL * PORT, MESSAGE *
 		//	2. OTHER END THINKS LINK HAS DIED
 		//	3. RECOVERY FROM FRMR CONDITION
 		//	4. REPEAT OF ORIGINAL SABM COS OTHER END MISSED UA
+		//	5. Other end has reloaded
 
-		//	FOR 1-3 IT IS REASONABLE TO FULLY RESET THE CIRCUIT, BUT IN 4
+		//	FOR 1-3 and 5 IT IS REASONABLE TO FULLY RESET THE CIRCUIT, BUT IN 4
 		//	SUCH ACTION WILL LOSE THE INITIAL SIGNON MSG IF CONNECTING TO A
 		//	BBS. THE PROBLEM IS TELLING THE DIFFERENCE. I'M GOING TO SET A FLAG 
 		//	WHEN FIRST INFO RECEIVED - IF SABM REPEATED BEFORE THIS, I'LL ASSUME
@@ -1198,7 +1200,7 @@ VOID L2LINKACTIVE(struct _LINKTABLE * LINK, struct PORTCONTROL * PORT, MESSAGE *
 			return;
 		}
 		
-		InformPartner(LINK, NORMALCLOSE);	// SEND DISC TO OTHER END
+		InformPartner(LINK, NORMALCLOSE);			// SEND DISC TO OTHER END
 		LINK->CIRCUITPOINTER = 0;
 
 		L2SABM(LINK, PORT, Buffer, ADJBUFFER, MSGFLAG);			// Process the SABM
@@ -1215,6 +1217,8 @@ VOID L2SABM(struct _LINKTABLE * LINK, struct PORTCONTROL * PORT, MESSAGE * Buffe
 
 	TRANSPORTENTRY * Session;
 	int CONERROR;
+	struct ROUTE * ROUTE = NULL;
+
 
 	char toCall[12], fromCall[12];
 
@@ -1272,6 +1276,18 @@ VOID L2SABM(struct _LINKTABLE * LINK, struct PORTCONTROL * PORT, MESSAGE * Buffe
 		if (PORT->TNC && PORT->TNC->Hardware == H_KISSHF)
 			AttachKISSHF(PORT, Buffer);
 
+		// if it is an INP3 connection tell INP3 it is up
+
+
+		if (FindNeighbour(LINK->LINKCALL, PORT->PORTNUMBER, &ROUTE))
+		{
+			if (ROUTE->INP3Node)
+			{
+				Debugprintf("INP3 Incoming connect from %s", fromCall);
+				DeleteINP3Routes(ROUTE);
+			}
+		}
+
 		if (NO_CTEXT == 1)
 			return;
 
@@ -1955,11 +1971,23 @@ VOID L2_PROCESS(struct _LINKTABLE * LINK, struct PORTCONTROL * PORT, MESSAGE * B
 			//	RESPONSE TO SABM - SET LINK  UP
 
 			char fromCall[12];
+			struct ROUTE * ROUTE;
 
 			fromCall[ConvFromAX25(Buffer->ORIGIN, fromCall)] = 0;
 
 			RESET2X(LINK);			// LEAVE QUEUED STUFF
 
+			// See if INP3 route setup
+			
+			if (FindNeighbour(Buffer->ORIGIN, PORT->PORTNUMBER, &ROUTE))
+			{
+				if (ROUTE->INP3Node)
+				{
+					Debugprintf("INP3 Route to %s connected", fromCall);
+				}
+			}
+
+
 			SendL2ToMonMap(PORT, fromCall, '+', 'O');		
 	
 			LINK->L2STATE = 5;
@@ -2792,7 +2820,7 @@ VOID RESETNS(struct _LINKTABLE * LINK, UCHAR NS)
 
 int COUNT_AT_L2(struct _LINKTABLE * LINK)
 {
-	//	COUNTS FRAMES QUEUED ON AN L2 SESSION (IN BX)
+	//	COUNTS FRAMES QUEUED ON AN L2 SESSION (IN LINK)
 
 	int count = 0, abovelink = 0;
 	int n = 0;
@@ -3976,6 +4004,8 @@ VOID CONNECTREFUSED(struct _LINKTABLE * LINK)
 }
 
 VOID L3CONNECTFAILED(struct _LINKTABLE * LINK);
+VOID L3LINKSETUPFAILED(struct _LINKTABLE * LINK);
+
 
 VOID ConnectFailedOrRefused(struct _LINKTABLE * LINK, char * Msg)
 {
@@ -3990,7 +4020,7 @@ VOID ConnectFailedOrRefused(struct _LINKTABLE * LINK, char * Msg)
 
 	if (LINK->LINKTYPE == 3)
 	{
-		L3CONNECTFAILED(LINK);		// REPORT TO LEVEL 3
+		L3LINKSETUPFAILED(LINK);		// REPORT TO LEVEL 3
 		return;
 	}
 	

L3Code.c

@@ -67,6 +67,8 @@ extern dest_list * CURRENTNODE;
 
 int L3_10SECS = 10;
 
+extern int PREFERINP3ROUTES;
+
 
 VOID L3BG()
 {
@@ -135,12 +137,14 @@ VOID L3BG()
 					// Drop through to Activate
 				}
 				
+				// No Active Route
+
 				if (ACTIVATE_DEST(DEST) == FALSE)
 				{
 					// Node has no routes - get rid of it
 
 					REMOVENODE(DEST);
-					return;					// Avoid riskof looking at lod entries
+					return;					// Avoid risk of looking at old entries
 				}
 			}
 		}
@@ -154,22 +158,32 @@ BOOL ACTIVATE_DEST(struct DEST_LIST * DEST)
 {
 	int n = MAXDESTS;
 	struct PORTCONTROL * PORT = PORTTABLE;
-	struct ROUTE * ROUTE;
+	struct ROUTE * ROUTE = NULL;
 	struct _LINKTABLE * LINK;
 	struct TNCINFO * TNC;
 
 	int ActiveRoute;
 
-	if (DEST->DEST_ROUTE == 0)		// ALREADY HAVE A SELECTED ROUTE?
-		DEST->DEST_ROUTE = 1;		// TRY TO ACTIVATE FIRST
+	if (DEST->DEST_ROUTE == 0)		// Don't ALREADY HAVE A SELECTED ROUTE?
+	{
+		DEST->DEST_ROUTE = 1;
+
+		if (PREFERINP3ROUTES)
+		{
+			// if we have any INP3 routes use the first. It will always be the fastest. The others are there for fallback if the first fails.
 
+			if (ROUTE = DEST->INP3ROUTE[0].ROUT_NEIGHBOUR)
+				DEST->DEST_ROUTE = 4;		// TRY TO ACTIVATE FIRST
+		}
+	}
+		
 	ActiveRoute = DEST->DEST_ROUTE - 1;
 
 	ROUTE = DEST->NRROUTE[ActiveRoute].ROUT_NEIGHBOUR;
 
 	if (ROUTE == 0)
 	{
-		//	Currnet Route not present
+		//	Current Route not present
 		//	If  current route is 1, then we must have INP3 routes (or entry is corrupt)
 
 		if (DEST->DEST_ROUTE != 1)
@@ -177,13 +191,17 @@ BOOL ACTIVATE_DEST(struct DEST_LIST * DEST)
 
 		// Current Route is 1
 
-		if (DEST->ROUTE[0].ROUT_NEIGHBOUR == 0)
+		if (DEST->INP3ROUTE[0].ROUT_NEIGHBOUR == 0)
 			return FALSE;					// No INP3 so No Routes
 
 		DEST->DEST_ROUTE = 4;			// First INP3
-		ROUTE = DEST->ROUTE[0].ROUT_NEIGHBOUR;
+		ROUTE = DEST->INP3ROUTE[0].ROUT_NEIGHBOUR;
 	}
 
+	if (ROUTE == 0)			// Shouldn't happen
+		return FALSE;
+
+
 	// if NetROM over VARA conection is made by the driver
 
 	TNC = TNCInfo[ROUTE->NEIGHBOUR_PORT];
@@ -204,7 +222,7 @@ BOOL ACTIVATE_DEST(struct DEST_LIST * DEST)
 		return L2SETUPCROSSLINK(ROUTE);
 	}
 	
-	// We mst be waiting for link to come up
+	// We umst be waiting for link to come up
 	
 	return TRUE;
 
@@ -707,11 +725,11 @@ int COUNTNODES(struct ROUTE * ROUTE)
 			count++;
 		else if (DEST->NRROUTE[2].ROUT_NEIGHBOUR == ROUTE)
 			count++;
-		else if (DEST->ROUTE[0].ROUT_NEIGHBOUR == ROUTE)
+		else if (DEST->INP3ROUTE[0].ROUT_NEIGHBOUR == ROUTE)
 			count++;
-		else if (DEST->ROUTE[1].ROUT_NEIGHBOUR == ROUTE)
+		else if (DEST->INP3ROUTE[1].ROUT_NEIGHBOUR == ROUTE)
 			count++;
-		else if (DEST->ROUTE[2].ROUT_NEIGHBOUR == ROUTE)
+		else if (DEST->INP3ROUTE[2].ROUT_NEIGHBOUR == ROUTE)
 			count++;
 
 		DEST++;
@@ -845,7 +863,7 @@ VOID SENDNEXTNODESFRAGMENT()
 
 		if (DEST->DEST_CALL[0] != 0x40 && DEST->NRROUTE[0].ROUT_QUALITY >= TXMINQUAL &&
 			DEST->NRROUTE[0].ROUT_OBSCOUNT >= OBSMIN &&
-			(NODE == 1 || DEST->DEST_STATE & 0x80))			// Only send appl nodes if DEST = 0;
+			(NODE == 1 || DEST->DEST_STATE & 0x80))			// Only send appl nodes if NODE = 0;
 		{		
 			// Send it
 			
@@ -878,6 +896,9 @@ VOID SENDNEXTNODESFRAGMENT()
 
 			*(ptr1++) = (UCHAR)Qual;
 
+			if (Qual == 0)
+				continue;
+
 			Count--;
 		}
 		DEST++;
@@ -924,7 +945,7 @@ VOID L3LINKCLOSED(struct _LINKTABLE * LINK, int Reason)
 
 VOID CLEARACTIVEROUTE(struct ROUTE * ROUTE, int Reason)
 {
-	//	FIND ANY DESINATIONS WITH [ESI] AS ACTIVE NEIGHBOUR, AND
+	//	FIND ANY DESINATIONS WITH ROUTE AS ACTIVE NEIGHBOUR, AND
 	//	SET INACTIVE
 
 	dest_list * DEST;
@@ -945,7 +966,7 @@ VOID CLEARACTIVEROUTE(struct ROUTE * ROUTE, int Reason)
 		if (DEST->DEST_ROUTE == 0)
 			continue;
 
-		if (DEST->ROUTE[DEST->DEST_ROUTE].ROUT_NEIGHBOUR == ROUTE)   // Is this the active route
+		if (DEST->INP3ROUTE[DEST->DEST_ROUTE].ROUT_NEIGHBOUR == ROUTE)   // Is this the active route
 		{
 			// Yes, so clear
 
@@ -1120,7 +1141,7 @@ UPDEST000:
 		{
 			//	 Any INP3 Routes?
 
-			if (DEST->ROUTE[0].ROUT_NEIGHBOUR == 0)
+			if (DEST->INP3ROUTE[0].ROUT_NEIGHBOUR == 0)
 			{
 				//	NO ROUTES LEFT TO DEST - REMOVE IT
 
@@ -1292,6 +1313,32 @@ VOID REMOVENODE(dest_list * DEST)
 	NUMBEROFNODES--;
 }
 
+VOID L3LINKSETUPFAILED(struct _LINKTABLE * LINK)
+{
+	//	L2 LINK SETUP HAS FAILED - SEE IF ANOTHER NEIGHBOUR CAN BE USED
+
+	struct PORTCONTROL * PORT = PORTTABLE;
+	struct ROUTE * ROUTE;
+
+	ROUTE = LINK->NEIGHBOUR;		// TO NEIGHBOUR
+	
+	if (ROUTE == NULL)
+		return;						// NOTHING ???
+
+	if (ROUTE->INP3Node)
+	{
+		char Normcall[10];
+		Normcall[ConvFromAX25(ROUTE->NEIGHBOUR_CALL, Normcall)] = 0;
+		Debugprintf("INP3 Route to %s connect failed", Normcall);
+	}
+
+	
+	ROUTE->NEIGHBOUR_LINK = 0;		// CLEAR IT
+
+	L3TRYNEXTDEST(ROUTE);			// RESET ASSOCIATED DEST ENTRIES
+}
+
+
 VOID L3CONNECTFAILED(struct _LINKTABLE * LINK)
 {
 	//	L2 LINK SETUP HAS FAILED - SEE IF ANOTHER NEIGHBOUR CAN BE USED
@@ -1304,6 +1351,14 @@ VOID L3CONNECTFAILED(struct _LINKTABLE * LINK)
 	
 	if (ROUTE == NULL)
 		return;						// NOTHING ???
+
+	if (ROUTE->INP3Node)
+	{
+		char Normcall[10];
+		Normcall[ConvFromAX25(ROUTE->NEIGHBOUR_CALL, Normcall)] = 0;
+		Debugprintf("INP3 Route to %s connect failed or refused", Normcall);
+	}
+
 	
 	TellINP3LinkSetupFailed(ROUTE);
 
@@ -1315,7 +1370,7 @@ VOID L3CONNECTFAILED(struct _LINKTABLE * LINK)
 
 VOID L3TRYNEXTDEST(struct ROUTE * ROUTE)
 {
-	//	FIND ANY DESINATIONS WITH [ESI] AS ACTIVE NEIGHBOUR, AND
+	//	FIND ANY DESINATIONS WITH ROUTE AS ACTIVE NEIGHBOUR, AND
 	//	SET NEXT BEST NEIGHBOUR (IF ANY) ACTIVE
 
 	int n = MAXDESTS;
@@ -1328,7 +1383,7 @@ VOID L3TRYNEXTDEST(struct ROUTE * ROUTE)
 		
 		if (ActiveRoute)
 		{
-			ActiveRoute --;			// Routes numbered 1 - 6, idex from 0
+			ActiveRoute --;			// Routes numbered 1 - 6, index from 0
 			
 			if (DEST->NRROUTE[ActiveRoute].ROUT_NEIGHBOUR == ROUTE)
 			{

L4Code.c

@@ -304,6 +304,7 @@ VOID SENDL4MESSAGE(TRANSPORTENTRY * L4, struct DATAMESSAGE * Msg)
 		return;
 	}
 
+	
 	L3MSG = GetBuff();
 
 	if (L3MSG == 0)

LinBPQ.c

@@ -854,6 +854,8 @@ int main(int argc, char * argv[])
 	 printf("G8BPQ AX25 Packet Switch System Version %s %s\n", TextVerstring, Datestring);
 	 printf("%s\n", VerCopyright);
 
+	 srand(time(NULL));
+
 
 	 // look for optarg format parameters
 

TNCCode.c

@@ -322,7 +322,10 @@ Dll VOID APIENTRY Send_AX(UCHAR * Block, DWORD Len, UCHAR Port)
 
 		EXTPORTDATA * EXTPORT = (EXTPORTDATA *) PORT;
 
-		C_Q_ADD(&EXTPORT->UI_Q, Copy);
+		if (EXTPORT->UI_Q)
+			C_Q_ADD(&EXTPORT->UI_Q, Copy);
+		else
+			C_Q_ADD(&EXTPORT->UI_Q, Copy);
 		return;
 	}
 

UZ7HODrv.c

@@ -685,6 +685,11 @@ static size_t ExtProc(int fn, int port, PDATAMESSAGE buff)
 					ConnecttoUZ7HO(port);
 					lasttime[port] = ltime;
 				}
+				while (TNC->PortRecord->UI_Q)
+				{
+					buffptr = Q_REM(&TNC->PortRecord->UI_Q);
+					ReleaseBuffer(buffptr);	
+				}
 			}
 			else
 			{

Versions.h

@@ -10,8 +10,8 @@
 
 #endif
 
-#define KVers 6,0,24,70
-#define KVerstring "6.0.24.70\0"
+#define KVers 6,0,24,71
+#define KVerstring "6.0.24.71\0"
 
 
 #ifdef CKernel

WebMail.c

@@ -3073,6 +3073,13 @@ VOID GetPage(struct HTTPConnectionInfo * Session, char * NodeURL)
 	ptr = strchr(&NodeURL[17], ',');
 	Dir = HtmlFormDirs[DirNo];
 
+
+	if (DirNo == -1)
+	{
+		*WebMail->RLen = sprintf(WebMail->Reply, "<html><script>alert(\"No Page Selected. \");window.location.href = '/Webmail/NewMsg?%s';</script></html>", Session->Key);
+		return;
+	}
+
 	SubDir = strlop(&NodeURL[17], ':');
 	if (SubDir)
 	{

asmstrucs.h

@@ -253,6 +253,7 @@ typedef struct ROUTE
 #define GotRTTResponse 2	// Other end has sent us a RTT Response
 #define GotRIF 4			// Other end has sent RIF, so is probably an INP3 Node
 							//	(could just be monitoring RTT for some reason
+#define SentRTTRequest 8
 #define SentOurRIF 16		// Set when we have sent a rif for our Call and any ApplCalls
 							//  (only sent when we have seen both a request and response)
 
@@ -460,16 +461,18 @@ typedef struct _APPLCALLS
 //  This way our times adjust to changes of neighbour SRTT. We can't cater for changes to other hop RTTs,
 //	But if these are significant (say 25% or 100 ms) they will be retransmitted
 
+// We treat the Routes as an array of 6. First 3 are NODES routes, next 3 are INP3 Routes. This works, but maybe is not ideal
+
 typedef struct NR_DEST_ROUTE_ENTRY
 {
 	struct ROUTE * ROUT_NEIGHBOUR;	// POINTER TO NEXT NODE IN PATH
 	UCHAR ROUT_QUALITY;		// QUALITY
 	UCHAR ROUT_OBSCOUNT;
 	UCHAR ROUT_LOCKED;
-	UCHAR Padding[4];		// SO Entries are the same length
+	UCHAR Padding[4];		// So Entries are the same length
 } *PNR_DEST_ROUTE_ENTRY;
 
-typedef struct DEST_ROUTE_ENTRY
+typedef struct INP3_DEST_ROUTE_ENTRY
 {
 	struct ROUTE * ROUT_NEIGHBOUR;	// POINTER TO NEXT NODE IN PATH
 	USHORT LastRTT;					// Last Value Reported
@@ -493,8 +496,8 @@ typedef struct DEST_LIST
 	UCHAR DEST_ROUTE;			// CURRENTY ACTIVE DESTINATION
 	UCHAR INP3FLAGS;
 
-	struct NR_DEST_ROUTE_ENTRY NRROUTE[3];// Best 3 NR neighbours for this dest
-	struct DEST_ROUTE_ENTRY ROUTE[3];	// Best 3 INP neighbours for this dest
+	struct NR_DEST_ROUTE_ENTRY NRROUTE[3];	// Best 3 NR neighbours for this dest
+	struct INP3_DEST_ROUTE_ENTRY INP3ROUTE[3];	// Best 3 INP neighbours for this dest
 
 	void * DEST_Q;				// QUEUE OF FRAMES FOR THIS DESTINATION
 
@@ -698,6 +701,7 @@ typedef struct PORTCONTROL
 	BOOL NormalizeQuality;		// Normalise Node Qualities
 	BOOL IgnoreUnlocked;		// Ignore Unlocked routes
 	BOOL INP3ONLY;				// Default to INP3 and disallow NODES
+	BOOL ALLOWINP3;
 
 	void (* UIHook)(struct _LINKTABLE * LINK, struct PORTCONTROL * PORT, MESSAGE * Buffer, MESSAGE * ADJBUFFER, UCHAR CTL, UCHAR MSGFLAG);			// Used for KISSARQ
 	struct PORTCONTROL * HookPort;

bpqaxip.c

@@ -733,7 +733,7 @@ VOID SendFrame(struct AXIPPORTINFO * PORT, struct arp_table_entry * arp_table, U
 		return;
 	}
 
-	// Seelcte source port by choosing right socket
+	// Select source port by choosing right socket
 
 	// First Set Default for Protocol
 

cMain.c

@@ -148,6 +148,8 @@ int L2Compress = 0;
 int L2CompMaxframe = 3;
 int L2CompPaclen = 236;
 
+int PREFERINP3ROUTES = 0;
+
 BOOL LogL4Connects = FALSE;
 BOOL LogAllConnects = FALSE;
 BOOL AUTOSAVEMH = TRUE;
@@ -165,6 +167,8 @@ char MQTT_PASS[80] = "";
 int MQTT_Connecting = 0;
 int MQTT_Connected = 0;
 
+int PoolBuilt = 0;
+
 
 //TNCTABLE	DD	0
 //NUMBEROFSTREAMS	DD	0
@@ -851,6 +855,9 @@ BOOL Start()
 	if (L2CompPaclen < 64 || L2CompPaclen > 236)
 		L2CompPaclen = 236;
 
+
+	PREFERINP3ROUTES = cfg->C_PREFERINP3ROUTES;
+
  
 	// Get pointers to PASSWORD and APPL1 commands
 
@@ -977,6 +984,7 @@ BOOL Start()
 		PORT->NormalizeQuality = !PortRec->NoNormalize;
 		PORT->IgnoreUnlocked = PortRec->IGNOREUNLOCKED;
 		PORT->INP3ONLY = PortRec->INP3ONLY;
+		PORT->ALLOWINP3 = PortRec->AllowINP3;
 
 		PORT->PORTWINDOW = (UCHAR)PortRec->MAXFRAME;
 
@@ -1001,6 +1009,9 @@ BOOL Start()
 		PORT->PORTPACLEN = (UCHAR)PortRec->PACLEN;
 		PORT->QUAL_ADJUST = (UCHAR)PortRec->QUALADJUST;
 	
+		if (PORT->QUAL_ADJUST < 0 || PORT->QUAL_ADJUST > 100)
+			PORT->QUAL_ADJUST = 100;
+
 		PORT->DIGIFLAG = PortRec->DIGIFLAG;
 		if (PortRec->DIGIPORT && CanPortDigi(PortRec->DIGIPORT))
 			PORT->DIGIPORT = PortRec->DIGIPORT;
@@ -1458,6 +1469,8 @@ BOOL Start()
 
 	ENDBUFFERPOOL = NEXTFREEDATA;
 
+	PoolBuilt = 1;
+
 
 	//	Copy Bridge Map
 
@@ -1575,6 +1588,7 @@ BOOL FindNeighbour(UCHAR * Call, int Port, struct ROUTE ** REQROUTE)
 	struct ROUTE * ROUTE = NEIGHBOURS;
 	struct ROUTE * FIRSTSPARE = NULL;
 	int n = MAXNEIGHBOURS;
+	char Normcall[10];
 
 	while (n--)
 	{
@@ -1587,6 +1601,10 @@ BOOL FindNeighbour(UCHAR * Call, int Port, struct ROUTE ** REQROUTE)
 			ROUTE++;
 			continue;
 		}
+
+			
+		Normcall[ConvFromAX25(ROUTE->NEIGHBOUR_CALL, Normcall)] = 0;
+
 		if (CompareCalls(ROUTE->NEIGHBOUR_CALL, Call))
 		{
 			*REQROUTE = ROUTE;

config.c

@@ -308,7 +308,7 @@ static char *keywords[] =
 "BTEXT:", "NETROMCALL", "C_IS_CHAT", "MAXRTT", "MAXHOPS",		// IPGATEWAY= no longer allowed
 "LogL4Connects", "LogAllConnects", "SAVEMH", "ENABLEADIFLOG", "ENABLEEVENTS", "SAVEAPRSMSGS", 
 "EnableM0LTEMap", "MQTT", "MQTT_HOST", "MQTT_PORT", "MQTT_USER", "MQTT_PASS",
-"L4Compress", "L4CompMaxframe", "L4CompPaclen", "L2Compress", "L2CompMaxframe", "L2CompPaclen"
+"L4Compress", "L4CompMaxframe", "L4CompPaclen", "L2Compress", "L2CompMaxframe", "L2CompPaclen", "PREFERINP3ROUTES"
 };           /* parameter keywords */
 
 static void * offset[] =
@@ -330,7 +330,8 @@ static void * offset[] =
 &xxcfg.C_BTEXT, &xxcfg.C_NETROMCALL, &xxcfg.C_C, &xxcfg.C_MAXRTT, &xxcfg.C_MAXHOPS,		// IPGATEWAY= no longer allowed
 &xxcfg.C_LogL4Connects, &xxcfg.C_LogAllConnects, &xxcfg.C_SaveMH, &xxcfg.C_ADIF, &xxcfg.C_EVENTS, &xxcfg.C_SaveAPRSMsgs,
 &xxcfg.C_M0LTEMap, &xxcfg.C_MQTT, &xxcfg.C_MQTT_HOST, &xxcfg.C_MQTT_PORT, &xxcfg.C_MQTT_USER, &xxcfg.C_MQTT_PASS,
-&xxcfg.C_L4Compress, &xxcfg.C_L4CompMaxframe, &xxcfg.C_L4CompPaclen, &xxcfg.C_L2Compress, &xxcfg.C_L2CompMaxframe, &xxcfg.C_L2CompPaclen};		/* offset for corresponding data in config file */
+&xxcfg.C_L4Compress, &xxcfg.C_L4CompMaxframe, &xxcfg.C_L4CompPaclen, &xxcfg.C_L2Compress, &xxcfg.C_L2CompMaxframe, 
+&xxcfg.C_L2CompPaclen, &xxcfg.C_PREFERINP3ROUTES};		/* offset for corresponding data in config file */
 
 static int routine[] = 
 {
@@ -351,7 +352,8 @@ static int routine[] =
 15, 0, 2, 9, 9,
 2, 2, 1, 2, 2, 2,
 2, 2, 0, 1, 20, 20,
-1, 1, 1, 1, 1, 1} ;			// Routine to process param
+1, 1, 1, 1, 1, 
+1, 1} ;			// Routine to process param
 
 int PARAMLIM = sizeof(routine)/sizeof(int);
 //int NUMBEROFKEYWORDS = sizeof(routine)/sizeof(int);
@@ -373,7 +375,7 @@ static char *pkeywords[] =
 "BCALL", "DIGIMASK", "NOKEEPALIVES", "COMPORT", "DRIVER", "WL2KREPORT", "UIONLY",
 "UDPPORT", "IPADDR", "I2CBUS", "I2CDEVICE", "UDPTXPORT", "UDPRXPORT", "NONORMALIZE",
 "IGNOREUNLOCKEDROUTES", "INP3ONLY", "TCPPORT", "RIGPORT", "PERMITTEDAPPLS", "HIDE",
-"SMARTID", "KISSCOMMAND", "SendtoM0LTEMap", "PortFreq", "M0LTEMapInfo", "QTSMPort"};         /* parameter keywords */
+"SMARTID", "KISSCOMMAND", "SendtoM0LTEMap", "PortFreq", "M0LTEMapInfo", "QTSMPort", "ALLOWINP3"};         /* parameter keywords */
 
 static void * poffset[] =
 {
@@ -387,7 +389,7 @@ static void * poffset[] =
 &xxp.BCALL, &xxp.DIGIMASK, &xxp.DefaultNoKeepAlives, &xxp.IOADDR, &xxp.DLLNAME, &xxp.WL2K, &xxp.UIONLY,
 &xxp.IOADDR, &xxp.IPADDR, &xxp.INTLEVEL, &xxp.IOADDR, &xxp.IOADDR, &xxp.ListenPort, &xxp.NoNormalize,
 &xxp.IGNOREUNLOCKED, &xxp.INP3ONLY, &xxp.TCPPORT, &xxp.RIGPORT, &xxp.PERMITTEDAPPLS, &xxp.Hide,
-&xxp.SmartID, &xxp.KissParams, &xxp.SendtoM0LTEMap, &xxp.PortFreq, &xxp.M0LTEMapInfo, &xxp.QtSMPort};	/* offset for corresponding data in config file */
+&xxp.SmartID, &xxp.KissParams, &xxp.SendtoM0LTEMap, &xxp.PortFreq, &xxp.M0LTEMapInfo, &xxp.QtSMPort, &xxp.AllowINP3};	/* offset for corresponding data in config file */
 
 static int proutine[] = 
 {
@@ -401,7 +403,7 @@ static int proutine[] =
 0, 1, 2, 18, 15, 16, 2,
 1, 17, 1, 1, 1, 1, 2,
 2, 2, 1, 1, 19, 2,
-1, 20, 1, 21, 22, 1};							/* routine to process parameter */
+1, 20, 1, 21, 22, 1, 1};							/* routine to process parameter */
 
 int PPARAMLIM = sizeof(proutine)/sizeof(int);
 
@@ -535,6 +537,8 @@ BOOL ProcessConfig()
 
 //	xxcfg.SaveMH = TRUE;		// Default to save
 
+	xxcfg.C_PREFERINP3ROUTES = 0;	// Default to false
+
 	GetNextLine(rec);
 
 	while (rec[0])
@@ -624,6 +628,7 @@ BOOL ProcessConfig()
 	paramok[89]=1;			// L2Compress
 	paramok[90]=1;			// L2Compress Maxframe
 	paramok[91]=1;			// L2Compress Paclen
+	paramok[92]=1;			// PREFERINP3ROUTES
 
 
 	for (i=0; i < PARAMLIM; i++)

configstructs.h

@@ -81,6 +81,7 @@ struct PORTCONFIG
 	uint64_t PortFreq;
 	char * M0LTEMapInfo;
 	int QtSMPort;
+	int AllowINP3;
 };
 
 struct ROUTECONFIG
@@ -176,6 +177,7 @@ struct CONFIGTABLE
 	int C_L2Compress;
 	int C_L2CompMaxframe;
 	int C_L2CompPaclen;
+	int C_PREFERINP3ROUTES;
 
 
 //#define ApplOffset 80000			// Applications offset in config buffer

kiss.c

@@ -2294,7 +2294,7 @@ VOID QtSMThread(struct PORTCONTROL * PORT)
 						char Msg[64];
 						int Len;
 
-						// We need tp send a QtSMPort message for each Channel sharing thia connection
+						// We need to send a QtSMPort message for each Channel sharing this connection
 						// Note struct KISSINFO and struct PORTCONTROL are different mappings of the same data
 
 						struct KISSINFO * KISS = (struct KISSINFO *)PORT;

mqtt.c

@@ -429,7 +429,6 @@ void MQTTKISSRX(void *message) {};
 void MQTTKISSRX_RAW(char* buffer, int bufferLength, void* PORT) {};
 void MQTTTimer() {};
 void MQTTReportSession(char * Msg) {};
-void MQTTMessageEvent(void* message);
+void MQTTMessageEvent(void* message) {};
 
 #endif
-

upnp.c

@@ -96,7 +96,6 @@ const char * minissdpdpath = 0;
 #ifdef UPNP_LOCAL_PORT_ANY
 int localport = UPNP_LOCAL_PORT_ANY;
 #else
-#pragma message "API 10"
 int localport = 0;
 #endif
 int retcode = 0;