diff --git a/ARDOP.c b/ARDOP.c
index a46fe3e..8230039 100644
--- a/ARDOP.c
+++ b/ARDOP.c
@@ -888,6 +888,7 @@ static size_t ExtProc(int fn, int port, PDATAMESSAGE buff)
 		{
 			if (TNC->SessionTimeLimit && STREAM->ConnectTime && time(NULL) > (TNC->SessionTimeLimit + STREAM->ConnectTime))
 			{
+				Debugprintf("ARDOP closing session on SessionTimelimit");
 				ARDOPSendCommand(TNC, "DISCONNECT", TRUE);
 				STREAM->ReportDISC = 1;
 				STREAM->AttachTime = 0;
@@ -900,6 +901,7 @@ static size_t ExtProc(int fn, int port, PDATAMESSAGE buff)
 		{
 			if (STREAM->AttachTime && TNC->AttachTimeLimit && time(NULL) > (TNC->AttachTimeLimit + STREAM->AttachTime))
 			{
+				Debugprintf("ARDOP closing session on AttachTimelimit");
 				STREAM->ReportDISC = 1;
 				STREAM->AttachTime = 0;
 			}
@@ -3141,6 +3143,7 @@ VOID ARDOPProcessResponse(struct TNCINFO * TNC, UCHAR * Buffer, int MsgLen)
 			// Incoming Connect
 
 			TNC->SessionTimeLimit = TNC->DefaultSessionTimeLimit;		// Reset Limit
+			STREAM->AttachTime = time(NULL);
 
 			// Stop other ports in same group
 
diff --git a/BBSUtilities.c b/BBSUtilities.c
index efba62a..d7291d0 100644
--- a/BBSUtilities.c
+++ b/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)
 
diff --git a/BPQINP3.c b/BPQINP3.c
index dcc17c6..2b1e3ae 100644
--- a/BPQINP3.c
+++ b/BPQINP3.c
@@ -37,6 +37,9 @@ along with LinBPQ/BPQ32.  If not, see http://www.gnu.org/licenses
 
 uint64_t timeLoadedMS = 0;
 
+VOID SendNegativeInfo();
+VOID SortRoutes(struct DEST_LIST * Dest);
+VOID SendRTTMsg(struct ROUTE * Route);
 
 static VOID SendNetFrame(struct ROUTE * Route, struct _L3MESSAGEBUFFER * Frame)
 {
@@ -71,9 +74,9 @@ VOID __cdecl Debugprintf(const char * format, ...);
 VOID SendINP3RIF(struct ROUTE * Route, UCHAR * Call, UCHAR * Alias, int Hops, int RTT);
 VOID SendOurRIF(struct ROUTE * Route);
 VOID UpdateNode(struct ROUTE * Route, UCHAR * axcall, UCHAR * alias, int  hops, int rtt);
-VOID UpdateRoute(struct DEST_LIST * Dest, struct DEST_ROUTE_ENTRY * ROUTEPTR, int  hops, int rtt);
-VOID KillRoute(struct DEST_ROUTE_ENTRY * ROUTEPTR);
-VOID AddHere(struct DEST_ROUTE_ENTRY * ROUTEPTR,struct ROUTE * Route , int  hops, int rtt);
+VOID UpdateRoute(struct DEST_LIST * Dest, struct INP3_DEST_ROUTE_ENTRY * ROUTEPTR, int  hops, int rtt);
+VOID KillRoute(struct INP3_DEST_ROUTE_ENTRY * ROUTEPTR);
+VOID AddHere(struct INP3_DEST_ROUTE_ENTRY * ROUTEPTR,struct ROUTE * Route , int  hops, int rtt);
 VOID SendRIPToNeighbour(struct ROUTE * Route);
 VOID DecayNETROMRoutes(struct ROUTE * Route);
 VOID DeleteINP3Routes(struct ROUTE * Route);
@@ -133,8 +136,14 @@ VOID DeleteINP3Routes(struct ROUTE * Route)
 {
 	int i;
 	struct DEST_LIST * Dest =  DESTS;
+	char Call1[10];
+	char Call2[10];
 
-	// Delete any NETROM Dest entries via this Route
+	Call1[ConvFromAX25(Route->NEIGHBOUR_CALL, Call1)] = 0;
+
+	Debugprintf("Deleting INP3 routes via %s", Call1);
+
+	// Delete any INP3 Dest entries via this Route
 
 	Route->SRTT = 0;
 	Route->RTT = 0;
@@ -156,48 +165,65 @@ VOID DeleteINP3Routes(struct ROUTE * Route)
 		if (Dest->NRROUTE[0].ROUT_OBSCOUNT >= 128)	 // Not if locked
 			continue;
 
-		if (Dest->ROUTE[0].ROUT_NEIGHBOUR == Route)
+		Call2[ConvFromAX25(Dest->DEST_CALL, Call2)] = 0;
+
+		if (Dest->INP3ROUTE[0].ROUT_NEIGHBOUR == Route)
 		{
-			//	We are deleting the best route, so need to tell other nodes
+			//	We are deleting the best INP3 route, so need to tell other nodes
 			//	If this is the only one, we need to keep the entry with at 60000 rtt so
 			//	we can send it. Remove when all gone
 
 			//	How do we indicate is is dead - Maybe the 60000 is enough!
-			if (Dest->ROUTE[1].ROUT_NEIGHBOUR == 0)
+
+			// If we are cleaning up after a sabm on an existing link (frmr or other end reloaded) then we don't need to tell anyone - the routes should be reestablished very quickly
+
+			Debugprintf("Deleting First INP3 Route to %s", Call2);
+
+			if (Dest->INP3ROUTE[1].ROUT_NEIGHBOUR == 0)
 			{
+
 				// Only entry
-				Dest->ROUTE[0].SRTT = 60000;
-				Dest->ROUTE[0].Hops = 255;
+				Dest->INP3ROUTE[0].SRTT = 60000;
+				Dest->INP3ROUTE[0].Hops = 255;
+
+				Debugprintf("Was the only INP3 route");
+
+				if (Dest->DEST_ROUTE == 4)			// we were using it
+					Dest->DEST_ROUTE = 0;
 
 				continue;
 			}
 
-			Dest->ROUTE[1].LastRTT  = Dest->ROUTE[0].SRTT;		// So next scan will check if rtt has increaced
-															// enough to need a RIF
-				
-			memcpy(&Dest->ROUTE[0], &Dest->ROUTE[1], sizeof(struct DEST_ROUTE_ENTRY));
-			memcpy(&Dest->ROUTE[1], &Dest->ROUTE[2], sizeof(struct DEST_ROUTE_ENTRY));
-			memset(&Dest->ROUTE[2], 0, sizeof(struct DEST_ROUTE_ENTRY));
+			Dest->INP3ROUTE[1].LastRTT = Dest->INP3ROUTE[0].SRTT;		// So next scan will check if rtt has increaced enough to need a RIF
+			memcpy(&Dest->INP3ROUTE[0], &Dest->INP3ROUTE[1], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+			memcpy(&Dest->INP3ROUTE[1], &Dest->INP3ROUTE[2], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+			memset(&Dest->INP3ROUTE[2], 0, sizeof(struct INP3_DEST_ROUTE_ENTRY));
 
 			continue;
 		}
 
 		// If we aren't removing the best, we don't need to tell anyone.
 		
-		if (Dest->ROUTE[1].ROUT_NEIGHBOUR == Route)
+		if (Dest->INP3ROUTE[1].ROUT_NEIGHBOUR == Route)
 		{
-			memcpy(&Dest->ROUTE[1], &Dest->ROUTE[2], sizeof(struct DEST_ROUTE_ENTRY));
-			memset(&Dest->ROUTE[2], 0, sizeof(struct DEST_ROUTE_ENTRY));
+			Debugprintf("Deleting 2nd INP3 Route to %s", Call2);
+			memcpy(&Dest->INP3ROUTE[1], &Dest->INP3ROUTE[2], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+			memset(&Dest->INP3ROUTE[2], 0, sizeof(struct INP3_DEST_ROUTE_ENTRY));
 
 			continue;
 		}
 
-		if (Dest->ROUTE[2].ROUT_NEIGHBOUR == Route)
+		if (Dest->INP3ROUTE[2].ROUT_NEIGHBOUR == Route)
 		{
-			memset(&Dest->ROUTE[2], 0, sizeof(struct DEST_ROUTE_ENTRY));
+			Debugprintf("Deleting 3rd INP3 Route to %s", Call2);
+			memset(&Dest->INP3ROUTE[2], 0, sizeof(struct INP3_DEST_ROUTE_ENTRY));
 			continue;
 		}
 	}
+
+	// I think we should send Negative info immediately
+
+	SendNegativeInfo();
 }
 
 VOID DecayNETROMRoutes(struct ROUTE * Route)
@@ -233,7 +259,7 @@ VOID DecayNETROMRoutes(struct ROUTE * Route)
 
 				if (Dest->NRROUTE[1].ROUT_NEIGHBOUR == 0)			// No more Netrom Routes
 				{
-					if (Dest->ROUTE[0].ROUT_NEIGHBOUR == 0)		// Any INP3 ROutes?
+					if (Dest->INP3ROUTE[0].ROUT_NEIGHBOUR == 0)			// Any INP3 ROutes?
 					{
 						// No More Routes - ZAP Dest
 
@@ -306,19 +332,9 @@ VOID ProcessRTTReply(struct ROUTE * Route, struct _L3MESSAGEBUFFER * Buff)
 	int RTT;
 	unsigned int OrigTime;
 
-	if ((Route->Status & GotRTTResponse) == 0)
-	{
-		// Link is just starting
+	char Normcall[10];
 
-		Route->Status |= GotRTTResponse;
-
-		if (Route->Status & GotRTTRequest)
-		{
-			Route->Status |= SentOurRIF;	
-			SendOurRIF(Route);
-			SendRIPToNeighbour(Route);
-		}
-	}
+	Normcall[ConvFromAX25(Route->NEIGHBOUR_CALL, Normcall)] = 0;
 
 	Route->Timeout = 0;			// Got Response
 	
@@ -334,6 +350,16 @@ VOID ProcessRTTReply(struct ROUTE * Route, struct _L3MESSAGEBUFFER * Buff)
 		Route->SRTT = RTT;
 	else
 		Route->SRTT = ((Route->SRTT * 80)/100) + ((RTT * 20)/100);
+
+	if ((Route->Status & GotRTTResponse) == 0)
+	{
+		// Link is just starting
+
+		Debugprintf("INP3 got first RTT reply from %s - Link is (Re)staring", Normcall);
+
+		Route->Status |= GotRTTResponse;
+	}
+
 }
 
 VOID ProcessINP3RIF(struct ROUTE * Route, UCHAR * ptr1, int msglen, int Port)
@@ -345,6 +371,13 @@ VOID ProcessINP3RIF(struct ROUTE * Route, UCHAR * ptr1, int msglen, int Port)
 	int opcode;
 	char alias[6];
 	UINT Stamp, HH, MM;
+	char Normcall[10];
+
+	Normcall[ConvFromAX25(Route->NEIGHBOUR_LINK->LINKCALL, Normcall)] = 0;
+	Debugprintf("Processing RIF from %s INP3Node %d Route SRTT %d", Normcall, Route->INP3Node, Route->SRTT);
+
+	if (Route->SRTT == 0)
+		Debugprintf("INP3 Zero SRTT");
 
 
 #ifdef NOINP3
@@ -386,10 +419,9 @@ VOID ProcessINP3RIF(struct ROUTE * Route, UCHAR * ptr1, int msglen, int Port)
 		rtt = (*ptr1++ << 8);
 		rtt += *ptr1++;
 
-		// rtt is value from remote node. Add our RTT to that node and update hops
+		// rtt is value from remote node. Add our RTT to that node
 
 		rtt += Route->SRTT;
-		hops++;
 
 		msglen -= 10;
 
@@ -424,7 +456,7 @@ VOID ProcessINP3RIF(struct ROUTE * Route, UCHAR * ptr1, int msglen, int Port)
 	return;
 }
 
-VOID KillRoute(struct DEST_ROUTE_ENTRY * ROUTEPTR)
+VOID KillRoute(struct INP3_DEST_ROUTE_ENTRY * ROUTEPTR)
 {
 }
 
@@ -432,32 +464,71 @@ VOID KillRoute(struct DEST_ROUTE_ENTRY * ROUTEPTR)
 VOID UpdateNode(struct ROUTE * Route, UCHAR * axcall, UCHAR * alias, int  hops, int rtt)
 {
 	struct DEST_LIST * Dest;
-	struct DEST_ROUTE_ENTRY * ROUTEPTR;
+	struct INP3_DEST_ROUTE_ENTRY * ROUTEPTR;
 	int i;
 	char call[11]="";
+	APPLCALLS * APPL;
+	int App;
+	char Normcall[10];
+	Normcall[ConvFromAX25(axcall, Normcall)] = 0;
+
+
+//	SEE IF any of OUR CALLs - DONT WANT TO PUT IT IN LIST!
+
+	if (CompareCalls(axcall, NETROMCALL))
+	{
+		Debugprintf("INP3 for our Nodecall - discarding");
+		return;
+	}
+
+	if (CheckExcludeList(axcall) == 0)
+	{
+		Debugprintf("INP3 excluded - discarding");
+		return;
+	}
+	
+	for (App = 0; App < NumberofAppls; App++)
+	{
+		APPL=&APPLCALLTABLE[App];
+
+		if (APPL->APPLHASALIAS == 0 && CompareCalls(axcall, APPL->APPLCALL))
+		{
+			Debugprintf("INP3 for an APPLCALL - discarding");
+			return;
+		}
+	}
+
 
 	if (hops > MaxHops && hops < 255)
 	{
-//		ConvFromAX25(axcall, call);
-//		Debugprintf("Node %s Hops %d RTT %d Ignored - Hop Count too high", call, hops, rtt);
+		ConvFromAX25(axcall, call);
+		Debugprintf("INP3 Node %s Hops %d RTT %d Ignored - Hop Count too high", call, hops, rtt);
 		return;
 	}
 
 	if (rtt > MAXRTT  && rtt < 60000)
 	{
-//		ConvFromAX25(axcall, call);
-//		Debugprintf("Node %s Hops %d RTT %d Ignored - rtt too high", call, hops, rtt);
+		ConvFromAX25(axcall, call);
+		Debugprintf("INP3 Node %s Hops %d RTT %d Ignored - rtt too high", call, hops, rtt);
 		return;
 	}
 
+	if (rtt >= 60000)
+	{
+		Debugprintf("INP3 RTT > 60000 - discarding");
+		return;	
+	}
+
 	if (FindDestination(axcall, &Dest))
 		goto Found;
 
 	if (Dest == NULL)
-		return;			// Tsble Full
-
-	if (rtt >= 60000)
-		return;				// No Point addind a new dead route
+	{
+		Debugprintf("INP3 Table Full - discarding");
+		return;	// Table Full
+	}
+	
+	
 
 	memset(Dest, 0, sizeof(struct DEST_LIST));
 
@@ -466,58 +537,63 @@ VOID UpdateNode(struct ROUTE * Route, UCHAR * axcall, UCHAR * alias, int  hops,
 
 //	Set up First Route
 
-	Dest->ROUTE[0].Hops = hops;
-	Dest->ROUTE[0].SRTT = rtt;
-	Dest->ROUTE[0].LastRTT = 0;
+	Dest->INP3ROUTE[0].Hops = hops;
+	Dest->INP3ROUTE[0].SRTT = rtt;
+	Dest->INP3ROUTE[0].LastRTT = 0;
 
 	Dest->INP3FLAGS = NewNode;
 
-	Dest->ROUTE[0].ROUT_NEIGHBOUR = Route;
+	Dest->INP3ROUTE[0].ROUT_NEIGHBOUR = Route;
 
 	NUMBEROFNODES++;
 
 	ConvFromAX25(Dest->DEST_CALL, call);
-	Debugprintf("Adding  Node %s Hops %d RTT %d", call, hops, rtt);
+	Debugprintf("INP3 Adding New Node %s Hops %d RTT %d", call, hops, rtt);
 
 	return;
 
 Found:
 
 	if (Dest->DEST_STATE & 0x80)	// Application Entry
-		return;
+	{
+		Debugprintf("INP3 Application Entry - discarding");
+		return;	// Tsble Full
+	}
 
 	// Update ALIAS
 
+	ConvFromAX25(Dest->DEST_CALL, call);
+	Debugprintf("INP3 Updating Node %s Hops %d RTT %d", call, hops, rtt);
+
+
 	if (alias[0] > ' ')
 		memcpy(Dest->DEST_ALIAS, alias, 6);
 
 	// See if we are known to it, it not add
 
-	ROUTEPTR = &Dest->ROUTE[0];
-
-	if (rtt >= 60000)
-	{
-		i=rtt+1;
-	}
+	ROUTEPTR = &Dest->INP3ROUTE[0];
 
 	if (ROUTEPTR->ROUT_NEIGHBOUR == Route)
 	{
+		Debugprintf("INP3 Already have as route[0] - updating");
 		UpdateRoute(Dest, ROUTEPTR, hops, rtt);
 		return;
 	}
 
-	ROUTEPTR = &Dest->ROUTE[1];
+	ROUTEPTR = &Dest->INP3ROUTE[1];
 
 	if (ROUTEPTR->ROUT_NEIGHBOUR == Route)
 	{
+		Debugprintf("INP3 Already have as route[1] - updating");
 		UpdateRoute(Dest, ROUTEPTR, hops, rtt);
 		return;
 	}
 
-	ROUTEPTR = &Dest->ROUTE[2];
+	ROUTEPTR = &Dest->INP3ROUTE[2];
 
 	if (ROUTEPTR->ROUT_NEIGHBOUR == Route)
 	{
+		Debugprintf("INP3 Already have as route[2] - updating");
 		UpdateRoute(Dest, ROUTEPTR, hops, rtt);
 		return;
 	}
@@ -525,64 +601,68 @@ Found:
 	// Not in list. If any spare, add.
 	// If full, see if this is better
 
-	if (rtt >= 60000)
-		return;				// No Point addind a new dead route
-
-	ROUTEPTR = &Dest->ROUTE[0];
-
-	for (i = 1; i < 4; i++)
+	for (i = 0; i < 3; i++)
 	{
+		ROUTEPTR = &Dest->INP3ROUTE[i];
+		
 		if (ROUTEPTR->ROUT_NEIGHBOUR == NULL)
 		{
 			// Add here
 
-			Dest->ROUTE[0].Hops = hops;
-			Dest->ROUTE[0].SRTT = rtt;
-			Dest->ROUTE[0].ROUT_NEIGHBOUR = Route;
-
+			Debugprintf("INP3 adding as route[%d]", i);
+			AddHere(ROUTEPTR, Route, hops, rtt);
+			SortRoutes(Dest);
 			return;
 		}
 		ROUTEPTR++;
 	}
 
+	Debugprintf("INP3 All entries in use - see if this is better than existing");
+
 	// Full, see if this is better
 
 	// Note that wont replace any netrom routes with INP3 ones unless we add pseudo rtt values to netrom entries
 
-	if (Dest->ROUTE[0].SRTT > rtt)
+	if (Dest->INP3ROUTE[0].SRTT > rtt)
 	{
 		// We are better. Move others down and add on front
 
-		memcpy(&Dest->ROUTE[2], &Dest->ROUTE[1], sizeof(struct DEST_ROUTE_ENTRY));
-		memcpy(&Dest->ROUTE[1], &Dest->ROUTE[0], sizeof(struct DEST_ROUTE_ENTRY));
+		Debugprintf("INP3 Replacing route 0");
 
-		AddHere(&Dest->ROUTE[0], Route, hops, rtt);
+		memcpy(&Dest->INP3ROUTE[2], &Dest->INP3ROUTE[1], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[1], &Dest->INP3ROUTE[0], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		AddHere(&Dest->INP3ROUTE[0], Route, hops, rtt);
 		return;
 	}
 
-	if (Dest->ROUTE[1].SRTT > rtt)
+	if (Dest->INP3ROUTE[1].SRTT > rtt)
 	{
 		// We are better. Move  2nd down and add
 
-		memcpy(&Dest->ROUTE[2], &Dest->ROUTE[1], sizeof(struct DEST_ROUTE_ENTRY));
-
-		AddHere(&Dest->ROUTE[1], Route, hops, rtt);
+		Debugprintf("INP3 Replacing route 1");
+		memcpy(&Dest->INP3ROUTE[2], &Dest->INP3ROUTE[1], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		AddHere(&Dest->INP3ROUTE[1], Route, hops, rtt);
 		return;
 	}
 
-	if (Dest->ROUTE[2].SRTT > rtt)
+	if (Dest->INP3ROUTE[2].SRTT > rtt)
 	{
 		// We are better. Add here
 
-		AddHere(&Dest->ROUTE[2], Route, hops, rtt);
+		Debugprintf("INP3 Replacing route 2");
+		AddHere(&Dest->INP3ROUTE[2], Route, hops, rtt);
 		return;
 	}
 
-	// Worse than any - ignoee
+
+	Debugprintf("INP3 Worse that any existing route");
+
+
+	// Worse than any - ignore
 
 }
 
-VOID AddHere(struct DEST_ROUTE_ENTRY * ROUTEPTR,struct ROUTE * Route , int  hops, int rtt)
+VOID AddHere(struct INP3_DEST_ROUTE_ENTRY * ROUTEPTR,struct ROUTE * Route , int  hops, int rtt)
 {
 	ROUTEPTR->Hops = hops;
 	ROUTEPTR->SRTT = rtt;
@@ -642,39 +722,123 @@ NOTBADROUTE:
 
 	JMP	SENDOK
 */
+	
+struct INP3_DEST_ROUTE_ENTRY Temp;
 
 
 VOID SortRoutes(struct DEST_LIST * Dest)
 {
-	 struct DEST_ROUTE_ENTRY Temp;
+	 char Call1[10], Call2[10], Call3[10];
+
 
 	// May now be out of order
 
-	if (Dest->ROUTE[1].ROUT_NEIGHBOUR == 0)
+	if (Dest->INP3ROUTE[1].ROUT_NEIGHBOUR == 0)
+	{
+		Call1[ConvFromAX25(Dest->INP3ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call1)] = 0;
+		Debugprintf("INP3 1 route %d %s",  Dest->INP3ROUTE[0].SRTT, Call1);
 		return;						// Only One, so cant be out of order
-	
-	if (Dest->ROUTE[2].ROUT_NEIGHBOUR == 0)
+	}
+	if (Dest->INP3ROUTE[2].ROUT_NEIGHBOUR == 0)
 	{
 		// Only 2
 
-		if (Dest->ROUTE[0].SRTT <= Dest->ROUTE[1].SRTT)
+		Call1[ConvFromAX25(Dest->INP3ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call1)] = 0;
+		Call2[ConvFromAX25(Dest->INP3ROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call2)] = 0;
+	
+		Debugprintf("INP3 2 routes %d %s %d %s",  Dest->INP3ROUTE[0].SRTT, Call1, Dest->INP3ROUTE[1].SRTT, Call2);
+
+		if (Dest->INP3ROUTE[0].SRTT <= Dest->INP3ROUTE[1].SRTT)
 			return;
 
 		// Swap one and two
 
-		memcpy(&Temp, &Dest->ROUTE[0], sizeof(struct DEST_ROUTE_ENTRY));
-		memcpy(&Dest->ROUTE[0], &Dest->ROUTE[1], sizeof(struct DEST_ROUTE_ENTRY));
-		memcpy(&Dest->ROUTE[1], &Temp, sizeof(struct DEST_ROUTE_ENTRY));
+		memcpy(&Temp, &Dest->INP3ROUTE[0], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[0], &Dest->INP3ROUTE[1], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[1], &Temp, sizeof(struct INP3_DEST_ROUTE_ENTRY));
 
+		Call1[ConvFromAX25(Dest->INP3ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call1)] = 0;
+		Call2[ConvFromAX25(Dest->INP3ROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call2)] = 0;
+	
+		Debugprintf("INP3 2 routes %d %s %d %s",  Dest->INP3ROUTE[0].SRTT, Call1, Dest->INP3ROUTE[1].SRTT, Call2);
 		return;
 	}
 
 	// Have 3 Entries
+
+
+	Call1[ConvFromAX25(Dest->INP3ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call1)] = 0;
+	Call2[ConvFromAX25(Dest->INP3ROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call2)] = 0;
+	Call3[ConvFromAX25(Dest->INP3ROUTE[2].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call3)] = 0;
+
+	Debugprintf("INP3 3 routes %d %s %d %s %d %s",  Dest->INP3ROUTE[0].SRTT, Call1, Dest->INP3ROUTE[1].SRTT, Call2, Dest->INP3ROUTE[2].SRTT, Call3);
+		
+	// In order?
+
+	if (Dest->INP3ROUTE[0].SRTT <= Dest->INP3ROUTE[1].SRTT && Dest->INP3ROUTE[1].SRTT <= Dest->INP3ROUTE[2].SRTT)// In order?
+		return;
+
+	// If second is better that first swap
+
+	if (Dest->INP3ROUTE[0].SRTT > Dest->INP3ROUTE[1].SRTT)
+	{
+		memcpy(&Temp, &Dest->INP3ROUTE[0], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[0], &Dest->INP3ROUTE[1], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[1], &Temp, sizeof(struct INP3_DEST_ROUTE_ENTRY));
+	}
+
+
+	Call1[ConvFromAX25(Dest->INP3ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call1)] = 0;
+	Call2[ConvFromAX25(Dest->INP3ROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call2)] = 0;
+	Call3[ConvFromAX25(Dest->INP3ROUTE[2].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call3)] = 0;
+
+	Debugprintf("INP3 3 routes %d %s %d %s %d %s",  Dest->INP3ROUTE[0].SRTT, Call1, Dest->INP3ROUTE[1].SRTT, Call2, Dest->INP3ROUTE[2].SRTT, Call3);
+
+	// if 3 is better than 2 swap them. As two is worse than one. three will then be worst
+
+	if (Dest->INP3ROUTE[1].SRTT > Dest->INP3ROUTE[2].SRTT)
+	{
+		memcpy(&Temp, &Dest->INP3ROUTE[1], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[1], &Dest->INP3ROUTE[2], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[2], &Temp, sizeof(struct INP3_DEST_ROUTE_ENTRY));
+	}
+
+
+	Call1[ConvFromAX25(Dest->INP3ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call1)] = 0;
+	Call2[ConvFromAX25(Dest->INP3ROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call2)] = 0;
+	Call3[ConvFromAX25(Dest->INP3ROUTE[2].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call3)] = 0;
+
+	Debugprintf("INP3 3 routes %d %s %d %s %d %s",  Dest->INP3ROUTE[0].SRTT, Call1, Dest->INP3ROUTE[1].SRTT, Call2, Dest->INP3ROUTE[2].SRTT, Call3);
+
+	// 3 is now slowest. 2 could still be better than 1
+
+
+	if (Dest->INP3ROUTE[0].SRTT > Dest->INP3ROUTE[1].SRTT)
+	{
+		memcpy(&Temp, &Dest->INP3ROUTE[0], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[0], &Dest->INP3ROUTE[1], sizeof(struct INP3_DEST_ROUTE_ENTRY));
+		memcpy(&Dest->INP3ROUTE[1], &Temp, sizeof(struct INP3_DEST_ROUTE_ENTRY));
+	}
+
+
+	Call1[ConvFromAX25(Dest->INP3ROUTE[0].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call1)] = 0;
+	Call2[ConvFromAX25(Dest->INP3ROUTE[1].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call2)] = 0;
+	Call3[ConvFromAX25(Dest->INP3ROUTE[2].ROUT_NEIGHBOUR->NEIGHBOUR_CALL, Call3)] = 0;
+
+	Debugprintf("INP3 3 routes %d %s %d %s %d %s",  Dest->INP3ROUTE[0].SRTT, Call1, Dest->INP3ROUTE[1].SRTT, Call2, Dest->INP3ROUTE[2].SRTT, Call3);
+
+	if (Dest->INP3ROUTE[0].SRTT <= Dest->INP3ROUTE[1].SRTT && Dest->INP3ROUTE[1].SRTT <= Dest->INP3ROUTE[2].SRTT)// In order?
+		return;
+
+	// Something went wrong
+
+	Debugprintf("INP3 Sort Failed");
+
 }
 
 
 
-VOID UpdateRoute(struct DEST_LIST * Dest, struct DEST_ROUTE_ENTRY * ROUTEPTR, int  hops, int rtt)
+VOID UpdateRoute(struct DEST_LIST * Dest, struct INP3_DEST_ROUTE_ENTRY * ROUTEPTR, int  hops, int rtt)
 {
 	if (ROUTEPTR->Hops == 0)
 	{
@@ -706,60 +870,70 @@ VOID UpdateRoute(struct DEST_LIST * Dest, struct DEST_ROUTE_ENTRY * ROUTEPTR, in
 
 VOID ProcessRTTMsg(struct ROUTE * Route, struct _L3MESSAGEBUFFER * Buff, int Len, int Port)
 {
+	int OtherRTT;
+	int Dummy;
+
+	char Normcall[10];
+
+	Normcall[ConvFromAX25(Route->NEIGHBOUR_LINK->LINKCALL, Normcall)] = 0;
+
 	// See if a reply to our message, or a new request
 
 	if (memcmp(Buff->L3SRCE, MYCALL,7) == 0)
 	{
 		ProcessRTTReply(Route, Buff);
 		ReleaseBuffer(Buff);
+		return;
 	}
-	else
+
+	if (Route->NEIGHBOUR_LINK->LINKPORT->ALLOWINP3)
+		Route->INP3Node = 1;
+
+	if (Route->INP3Node == 0)
 	{
-		int OtherRTT;
-		int Dummy;
-		
-		if (Route->INP3Node == 0)
-		{
-			ReleaseBuffer(Buff);
-			return;						// We don't want to use INP3
-		}
+		Debugprintf("Ignoring RTT Msg from %s - not using INP3", Normcall);
+		ReleaseBuffer(Buff);
+		return;						// We don't want to use INP3
+	}
 
-		// Extract other end's SRTT
+	// Extract other end's SRTT
 
-		sscanf(&Buff->L4DATA[6], "%d %d", &Dummy, &OtherRTT);
-		Route->NeighbourSRTT = OtherRTT * 10;  // We store in mS
+	sscanf(&Buff->L4DATA[6], "%d %d", &Dummy, &OtherRTT);
+	Route->NeighbourSRTT = OtherRTT * 10;  // We store in mS
 
-		// Echo Back to sender
-	
-		SendNetFrame(Route, Buff);
+	// Echo Back to sender
 
-		if ((Route->Status & GotRTTRequest) == 0)
-		{
-			// Link is just starting
+	SendNetFrame(Route, Buff);
 
-			Route->Status |= GotRTTRequest;
-			
-			if (Route->Status & GotRTTResponse)
-			{
-				Route->Status |= SentOurRIF;	
-				SendOurRIF(Route);
-				SendRIPToNeighbour(Route);
+	if ((Route->Status & GotRTTRequest) == 0)
+	{
+		// Link is just starting
 
-			}
-			else
-			{
-				// We have not yet seen a response (and maybe haven't sent one
+		Debugprintf("INP3 Processing first RTT frame from %s - link is (re)starting", Normcall);
+		Route->Status |= GotRTTRequest;
+
+		// I don't think we should send RIF until we get an RTT response.
+
+		if ((Route->Status & SentRTTRequest) == 0)			// Not sent one yet so send it
+			SendRTTMsg(Route);
+
+		// No, it's the other end that must have an rrt response and we've just sent it
+
+		Route->Status |= SentOurRIF;	
+		SendOurRIF(Route);
+		SendRIPToNeighbour(Route);
 
-				Route->BCTimer = 0;		// So send one
-			}
-		}
 	}
 }
 
+
 VOID SendRTTMsg(struct ROUTE * Route)
 {
 	struct _L3MESSAGEBUFFER * Msg;
 	char Stamp[50];
+	char Normcall[10];
+
+	Normcall[ConvFromAX25(Route->NEIGHBOUR_CALL, Normcall)] = 0;
 
 	Msg = GetBuff();
 	if (Msg == 0)
@@ -788,6 +962,14 @@ VOID SendRTTMsg(struct ROUTE * Route)
 	Route->Timeout = RTTTimeout;
 
 	SendNetFrame(Route, Msg);
+
+	if (Route->Status & SentRTTRequest)
+		return;	
+
+	Route->Status |= SentRTTRequest;	
+
+	Debugprintf("INP3 Sending first RTT Msg to %s", Normcall);
+
 }
 
 VOID SendKeepAlive(struct ROUTE * Route)
@@ -821,7 +1003,9 @@ int BuildRIF(UCHAR * RIF, UCHAR * Call, UCHAR * Alias, int Hops, int RTT)
 	int RIFLen;
 	UCHAR AliasCopy[10] = "";
 	UCHAR * ptr;
+	char Normcall[10];
 
+	Normcall[ConvFromAX25(Call, Normcall)] = 0;
 
 	if (RTT > 60000) RTT = 60000;	// Dont send more than 60000
 
@@ -848,9 +1032,12 @@ int BuildRIF(UCHAR * RIF, UCHAR * Call, UCHAR * Alias, int Hops, int RTT)
 		RIF[12+AliasLen] = 0;
 
 		RIFLen = 13 + AliasLen;
+		Debugprintf("INP3 sending RIF Entry %s:%s %d %d", AliasCopy, Normcall, Hops, RTT);
 		return RIFLen;
 	}
 	RIF[10] = 0;
+
+	Debugprintf("INP3 sending RIF Entry %s %d %d", Normcall, Hops, RTT);
 	
 	return (11);
 }
@@ -863,11 +1050,17 @@ VOID SendOurRIF(struct ROUTE * Route)
 	int totLen = 1;
 	int App;
 	APPLCALLS * APPL;
+	char Normcall[10];
 
 	Msg = GetBuff();
 	if (Msg == 0)
 		return;
 
+
+	Normcall[ConvFromAX25(Route->NEIGHBOUR_LINK->LINKCALL, Normcall)] = 0;
+	Debugprintf("INP3 Sending Initial RIF to %s ", Normcall);
+
+
 	Msg->L3SRCE[0] = 0xff;
 
 	// send a RIF for our Node and all our APPLCalls
@@ -898,6 +1091,8 @@ int SendRIPTimer()
 	struct ROUTE * Route = NEIGHBOURS;
 	int MaxRoutes = MAXNEIGHBOURS;
 	int INP3Delay;
+	char Normcall[10];
+
 
 	for (count=0; count<MaxRoutes; count++)
 	{
@@ -946,6 +1141,12 @@ int SendRIPTimer()
 
 				// Try to activate link
 
+				if (Route->INP3Node)
+				{
+					Normcall[ConvFromAX25(Route->NEIGHBOUR_CALL, Normcall)] = 0;
+					Debugprintf("INP3 Activating link to %s", Normcall);
+				}
+
 				L2SETUPCROSSLINKEX(Route, 2);		// Only try SABM twice
 
 				Route->LastConnectAttempt = REALTIMETICKS;
@@ -1007,7 +1208,7 @@ int SendRIPTimer()
 							char Call [11] = "";
 
 							ConvFromAX25(Route->NEIGHBOUR_CALL, Call);
-							Debugprintf("BPQ32 INP Neighbour %s Lost", Call);
+							Debugprintf("BPQ32 INP3 Neighbour %s Lost", Call);
 
 							Route->Status = 0;	// Down
 						}
@@ -1042,27 +1243,39 @@ struct _L3MESSAGEBUFFER * CreateRIFHeader(struct ROUTE * Route)
 	struct _L3MESSAGEBUFFER * Msg = GetBuff();
 	UCHAR AliasCopy[10] = "";
 
-	Msg->LENGTH = 1;
-	Msg->L3SRCE[0] = 0xff;
-
-	Msg->L3PID = NRPID;
+	if (Msg)
+	{
+		Msg->LENGTH = 1;
+		Msg->L3SRCE[0] = 0xff;
 
+		Msg->L3PID = NRPID;
+	}
 	return Msg;
 
 }
 
 VOID SendRIF(struct ROUTE * Route, struct _L3MESSAGEBUFFER * Msg)
 {
+	char Normcall[10];
+
+	Normcall[ConvFromAX25(Route->NEIGHBOUR_CALL, Normcall)] = 0;
+
 	Msg->LENGTH += MSGHDDRLEN + 1;		// PID
 
+	Debugprintf("Sending INP3 RIF length %d to %s", Msg->LENGTH, Normcall);
 	SendNetFrame(Route, Msg);
 }
 
-VOID SendRIPToOtherNeighbours(UCHAR * axcall, UCHAR * alias, struct DEST_ROUTE_ENTRY * Entry)
+VOID SendRIPToOtherNeighbours(UCHAR * axcall, UCHAR * alias, struct INP3_DEST_ROUTE_ENTRY * Entry)
 {
 	struct ROUTE * Routes = NEIGHBOURS;
 	struct _L3MESSAGEBUFFER * Msg;
 	int count, MaxRoutes = MAXNEIGHBOURS;
+	char Normcall[10];
+
+	Normcall[ConvFromAX25(axcall, Normcall)] = 0;
+
+	Debugprintf("INP3 SendRIPToOtherNeighbours for %s", Normcall);
 
 	for (count=0; count<MaxRoutes; count++)
 	{
@@ -1073,16 +1286,24 @@ VOID SendRIPToOtherNeighbours(UCHAR * axcall, UCHAR * alias, struct DEST_ROUTE_E
 			Msg = Routes->Msg;
 			
 			if (Msg == NULL) 
-				Msg = Routes->Msg = CreateRIFHeader(Routes);
-			
-			Msg->LENGTH += BuildRIF(&Msg->L3SRCE[Msg->LENGTH],
-				axcall, alias, Entry->Hops + 1, Entry->SRTT + Entry->ROUT_NEIGHBOUR->SRTT/10);
-
-			if (Msg->LENGTH > 250 - 15)
-//			if (Msg->LENGTH > Routes->NBOUR_PACLEN - 11)
 			{
-				SendRIF(Routes, Msg);
-				Routes->Msg = NULL;
+				Normcall[ConvFromAX25(Routes->NEIGHBOUR_CALL, Normcall)] = 0;
+				Debugprintf("INP3 Building RIF to send to %s", Normcall);
+				Msg = Routes->Msg = CreateRIFHeader(Routes);
+			}
+
+			if (Msg)
+			{
+
+				Msg->LENGTH += BuildRIF(&Msg->L3SRCE[Msg->LENGTH],
+					axcall, alias, Entry->Hops + 1, Entry->SRTT + Entry->ROUT_NEIGHBOUR->SRTT/10);
+
+				if (Msg->LENGTH > 250 - 15)
+//				if (Msg->LENGTH > Routes->NBOUR_PACLEN - 11)
+				{
+					SendRIF(Routes, Msg);
+					Routes->Msg = NULL;
+				}
 			}
 		}
 		Routes+=1;
@@ -1093,9 +1314,14 @@ VOID SendRIPToNeighbour(struct ROUTE * Route)
 {
 	int i;
 	struct DEST_LIST * Dest =  DESTS;
-	struct DEST_ROUTE_ENTRY * Entry;
+	struct INP3_DEST_ROUTE_ENTRY * Entry;
 	struct _L3MESSAGEBUFFER * Msg;
 
+	char Normcall[10];
+
+	Normcall[ConvFromAX25(Route->NEIGHBOUR_LINK->LINKCALL, Normcall)] = 0;
+	Debugprintf("INP3 Sending Our Table to %s ", Normcall);
+
 	Dest--;
 
 	// Send all entries not via this Neighbour - used when link starts
@@ -1104,7 +1330,7 @@ VOID SendRIPToNeighbour(struct ROUTE * Route)
 	{
 		Dest++;
 
-		Entry = &Dest->ROUTE[0];
+		Entry = &Dest->INP3ROUTE[0];
 
 		if (Entry->ROUT_NEIGHBOUR && Entry->Hops && Route != Entry->ROUT_NEIGHBOUR)	
 		{
@@ -1142,8 +1368,12 @@ VOID FlushRIFs()
 	{
 		if (Routes->Msg)
 		{
+			char Normcall[10];
+
+			Normcall[ConvFromAX25(Routes->NEIGHBOUR_CALL, Normcall)] = 0;
 			SendRIF(Routes, Routes->Msg);
 			Routes->Msg = NULL;
+			Debugprintf("INP3 Flushing RIF to  %s", Normcall); 
 		}
 		Routes+=1;
 	}
@@ -1153,7 +1383,7 @@ VOID SendNegativeInfo()
 {
 	int i, Preload;
 	struct DEST_LIST * Dest =  DESTS;
-	struct DEST_ROUTE_ENTRY * Entry;
+	struct INP3_DEST_ROUTE_ENTRY * Entry;
 
 	Dest--;
 
@@ -1169,7 +1399,7 @@ VOID SendNegativeInfo()
 	{
 		Dest++;
 
-		Entry = &Dest->ROUTE[0];
+		Entry = &Dest->INP3ROUTE[0];
 
 		if (Entry->SRTT > Entry->LastRTT)
 		{
@@ -1194,15 +1424,19 @@ VOID SendNegativeInfo()
 			{
 				char call[11]="";
 				ConvFromAX25(Dest->DEST_CALL, call);
-				Debugprintf("Deleting Node %s", call);
+				Debugprintf("INP3 Deleting Node %s", call);
 				REMOVENODE(Dest);			// Clear buffers, Remove from Sorted Nodes chain, and zap entry	
 			}
 			else
 			{
 				// Have a NETROM route, so zap the INP3 one
 
-				memset(Entry, 0, sizeof(struct DEST_ROUTE_ENTRY));
+				memset(Entry, 0, sizeof(struct INP3_DEST_ROUTE_ENTRY));
 			}
+
+			if (Dest->DEST_ROUTE == 4)			// we were using it
+					Dest->DEST_ROUTE = 0;
+
 		}
 	}
 }
@@ -1211,7 +1445,7 @@ VOID SendPositiveInfo()
 {
 	int i;
 	struct DEST_LIST * Dest =  DESTS;
-	struct DEST_ROUTE_ENTRY * Entry;
+	struct INP3_DEST_ROUTE_ENTRY * Entry;
 
 	Dest--;
 
@@ -1221,14 +1455,14 @@ VOID SendPositiveInfo()
 	{
 		Dest++;
 
-		Entry = &Dest->ROUTE[0];
+		Entry = &Dest->INP3ROUTE[0];
 
 		if (( (Entry->SRTT) && (Entry->LastRTT == 0) )|| 		// if zero haven't yet reported +ve info
 			((((Entry->SRTT * 125) /100) < Entry->LastRTT) && // Better by 25%
 			((Entry->LastRTT - Entry->SRTT) > 10)))			  // and 100ms
 		{
 			SendRIPToOtherNeighbours(Dest->DEST_CALL, 0, Entry);
-			Dest->ROUTE[0].LastRTT = (Dest->ROUTE[0].SRTT * 11) / 10;	//10% Negative Preload
+			Dest->INP3ROUTE[0].LastRTT = (Dest->INP3ROUTE[0].SRTT * 11) / 10;	//10% Negative Preload
 		}
 	}
 }
@@ -1238,7 +1472,7 @@ VOID SendNewInfo()
 	int i;
 	unsigned int NewRTT;
 	struct DEST_LIST * Dest =  DESTS;
-	struct DEST_ROUTE_ENTRY * Entry;
+	struct INP3_DEST_ROUTE_ENTRY * Entry;
 
 	Dest--;
 
@@ -1252,7 +1486,7 @@ VOID SendNewInfo()
 		{
 			Dest->INP3FLAGS &= ~NewNode;
 			
-			Entry = &Dest->ROUTE[0];
+			Entry = &Dest->INP3ROUTE[0];
 
 			SendRIPToOtherNeighbours(Dest->DEST_CALL, Dest->DEST_ALIAS, Entry);
 
@@ -1337,7 +1571,7 @@ UCHAR * DisplayINP3RIF(UCHAR * ptr1, UCHAR * ptr2, unsigned int msglen)
 				return ptr2;
 			}
 		}
-				
+
 		ptr1+=7;
 
 		hops = *ptr1++;
@@ -1364,24 +1598,38 @@ UCHAR * DisplayINP3RIF(UCHAR * ptr1, UCHAR * ptr2, unsigned int msglen)
 				memcpy(&alias[6 - (len - 2)], ptr1+2, len-2);		// Right Justiify
 			}
 			else
-			if (opcode == 1 && len < 8)
-			{
-				memcpy(IP, ptr1+2, len-2);
-			}
+				if (opcode == 1 && len < 8)
+				{
+					memcpy(IP, ptr1+2, len-2);
+				}
+				ptr2+=sprintf(ptr2, " %s:%s %d %4.2d\r", alias, call, hops, rtt);
 
-			ptr1+=len;
-			msglen -=len;
+				ptr1++;
+				msglen--;		// EOP
 		}
 
-		if (IP[0])
-			ptr2+=sprintf(ptr2, " %s:%s %d %4.2d %d.%d.%d.%d\r", alias, call, hops, rtt, IP[0], IP[1], IP[2], IP[3]);
-		else
-			ptr2+=sprintf(ptr2, " %s:%s %d %4.2d\r", alias, call, hops, rtt);
-
-		ptr1++;
-		msglen--;		// EOP
+		return ptr2;
 	}
-	
 	return ptr2;
 }
 
+// Paula's conversion of rtt to Quality
+
+int inp3_tt2qual (int tt, int hops) 
+{
+	int qual;
+
+	if (tt >= 60000 || hops > 30) 
+		return(0);
+	
+	qual = 254 - (tt/20);
+	
+	if (qual > 254 - hops)
+		qual = 254 - hops;
+	
+	if (qual < 0) 
+		qual=0;
+	
+	return(qual); 
+} 
+
diff --git a/BPQMail.c b/BPQMail.c
index 81700dd..0ac9f1c 100644
--- a/BPQMail.c
+++ b/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"
diff --git a/Bpq32.c b/Bpq32.c
index 36b5786..fc36356 100644
--- a/Bpq32.c
+++ b/Bpq32.c
@@ -1257,8 +1257,16 @@ along with LinBPQ/BPQ32.  If not, see http://www.gnu.org/licenses
 //	Fix RigConrol with Chanxx but no other settings (66)
 //	Add option to compress L2 frames (67)
 //	Sort Routes displays (67)
-
-
+//	Fix Ardop session premature close (70)
+//	Add timestamps to log entries in Web Driver windows (70)
+//	Generate stack backtrace if SIGSEGV or SIGABRT occur (Linux) (70)
+//	Remove some debug logging from L2 code (70)
+//	Fix compiling LinBPQ with nomqtt option (70)
+//	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
 
@@ -2380,6 +2388,8 @@ FirstInit()
 	}
 
 	timeLoadedMS = GetTickCount();
+
+	srand(time(NULL));
 	
 	INITIALISEPORTS();
 
diff --git a/Cmd.c b/Cmd.c
index 3ba2a55..70a061e 100644
--- a/Cmd.c
+++ b/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])
+		ptr = strtok_s(NULL, " ", &Context);
+		if (ptr)
+			ConvToAX25(ptr, DEST);
+
+		ptr = strtok_s(NULL, " ", &Context);
+		if (ptr)
+			ConvToAX25(ptr, ORIGIN);
+
+		ptr = strtok_s(NULL, " ", &Context);
+		if (ptr)
+			Port = atoi(ptr);
+
+		if (FindLink(DEST, ORIGIN, Port, &LINK))
 		{
-			len = ConvFromAX25(LINK->LINKCALL, Normcall);
+			InformPartner(LINK, NORMALCLOSE);	// TELL OTHER END ITS GONE
 
-			Bufferptr = Cmdprintf(Session, Bufferptr, "%s", Normcall);
+			LINK->L2RETRIES -= 1;		// Just send one DISC
+			LINK->L2STATE = 4;			// CLOSING
 
-			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);
+			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);
 
@@ -3622,7 +3665,7 @@ VOID MHCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct CM
 	}
 	else
 	{
-		if (CMD->String[2] == 'V')		// MHV
+		if (CMD->String[2] == 'V' || CMD->String[3] == '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");
@@ -4326,6 +4369,8 @@ struct CMDX COMMANDS[] =
 	"MHU         ",3,MHCMD,0,		// UTC Times
 	"MHL         ",3,MHCMD,0,		// Local Times
 	"MHV         ",3,MHCMD,0,
+	"MHUV        ",3,MHCMD,0,		// UTC Times
+	"MHLV        ",3,MHCMD,0,		// Local Times
 	"MHEARD      ",1,MHCMD,0,
 	"APRS        ",2,APRSCMD,0,
 	"ATTACH      ",1,ATTACHCMD,0,
@@ -5543,22 +5588,14 @@ VOID KISSCMD(TRANSPORTENTRY * Session, char * Bufferptr, char * CmdTail, struct
 
 			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);
 
+			PORT = (struct PORTCONTROL *)KISS->FIRSTPORT;			// ALL FRAMES GO ON SAME Q
 			ASYSEND(PORT, ENCBUFF, KissLen);
 
 			Bufferptr = Cmdprintf(Session, Bufferptr, "Command Sent\r");
diff --git a/CommonCode.c b/CommonCode.c
index f5d5125..ecac115 100644
--- a/CommonCode.c
+++ b/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
 
@@ -1061,6 +1068,7 @@ BOOL ReadConfigFile(int Port, int ProcLine(char * buf, int Port))
 				WritetoConsoleLocal("\n");
 				WritetoConsoleLocal("Bad config record ");
 				WritetoConsoleLocal(errbuf);
+				WritetoConsoleLocal("\n");
 			}
 		}
 	}
diff --git a/FBBRoutines.c b/FBBRoutines.c
index c283f32..bc0a854 100644
--- a/FBBRoutines.c
+++ b/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);
diff --git a/FreeDATA.c b/FreeDATA.c
index 9e4b349..ac1cb65 100644
--- a/FreeDATA.c
+++ b/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);	
+			}
 		}
 
 
diff --git a/KAMPactor.c b/KAMPactor.c
index 318c6e0..ec461d3 100644
--- a/KAMPactor.c
+++ b/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;	
 }
 
 
diff --git a/L2Code.c b/L2Code.c
index 94fc9f5..5b13919 100644
--- a/L2Code.c
+++ b/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;
@@ -2431,12 +2459,11 @@ CheckNSLoop:
 		{
 			// Already have a copy, so discard old and keep this
 			
-			Debugprintf ("Frame %d out of seq but already have copy - release it", NS);
 			ReleaseBuffer(Q_REM(&LINK->RXFRAMES[NS]));
 		}
 		else
 		{
-			Debugprintf ("Frame %d out of seq - save", NS);
+//			Debugprintf ("Frame %d out of seq - save", NS);
 		}
 
 		Buffer->CHAIN = 0;
@@ -2793,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;
@@ -3919,7 +3946,6 @@ CheckNSLoop2:
 			struct PORTCONTROL * PORT = LINK->LINKPORT;
 			MESSAGE * OldBuffer = Q_REM(&LINK->RXFRAMES[LINK->LINKNR]);
 		
-			Debugprintf("L2 about to send REJ - process saved Frame %d", LINK->LINKNR);
 			PROC_I_FRAME(LINK, PORT, OldBuffer); // Passes on  or releases Buffer
 
 			// NR has been updated.
@@ -3978,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)
 {
@@ -3992,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;
 	}
 	
diff --git a/L3Code.c b/L3Code.c
index b4f3d65..b516634 100644
--- a/L3Code.c
+++ b/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)
 			{
diff --git a/L4Code.c b/L4Code.c
index 2372a9e..56a0a23 100644
--- a/L4Code.c
+++ b/L4Code.c
@@ -304,6 +304,7 @@ VOID SENDL4MESSAGE(TRANSPORTENTRY * L4, struct DATAMESSAGE * Msg)
 		return;
 	}
 
+	
 	L3MSG = GetBuff();
 
 	if (L3MSG == 0)
diff --git a/LinBPQ.c b/LinBPQ.c
index fc5e900..6ba4b1c 100644
--- a/LinBPQ.c
+++ b/LinBPQ.c
@@ -381,41 +381,48 @@ BOOL CtrlHandler(DWORD fdwCtrlType)
 #include <signal.h>
 
 // Linux Signal Handlers
-
 static void segvhandler(int sig)
 {
-	void *array[10];
-	size_t size;
-	char msg[] = "SIGSEGV Received\n";
+    void *array[10];
+    size_t size;
+    char msg[] = "\nSIGSEGV Received\n";
 
-	write(STDERR_FILENO, msg, strlen(msg));
+    write(STDERR_FILENO, msg, strlen(msg));
 
-	// get void*'s for all entries on the stack
-	size = backtrace(array, 10);
+    // get void*'s for all entries on the stack
+    size = backtrace(array, 10);
 
-	// print out all the frames to stderr
+    // print out all the frames to stderr
 
-	backtrace_symbols_fd(array, size, STDERR_FILENO);
+    backtrace_symbols_fd(array, size, STDERR_FILENO);
 
-  exit(1);
+    write(STDOUT_FILENO, msg, strlen(msg));
+    backtrace_symbols_fd(array, size, STDOUT_FILENO);
+
+    exit(1);
 }
 
 static void abrthandler(int sig)
 {
-	void *array[10];
-	size_t size;
-	char msg[] = "SIGABRT Received\n";
+    void *array[10];
+    size_t size;
+    char msg[] = "\nSIGABRT Received\n";
 
-	write(STDERR_FILENO, msg, strlen(msg));
+    write(STDERR_FILENO, msg, strlen(msg));
+    write(STDOUT_FILENO, msg, strlen(msg));
 
-	// get void*'s for all entries on the stack
+    // get void*'s for all entries on the stack
 
-	size = backtrace(array, 10);
-	backtrace_symbols_fd(array, size, STDERR_FILENO);
+    size = backtrace(array, 10);
+    backtrace_symbols_fd(array, size, STDERR_FILENO);
 
-	exit(1);
+    write(STDOUT_FILENO, msg, strlen(msg));
+    backtrace_symbols_fd(array, size, STDOUT_FILENO);
+
+    exit(1);
 }
 
+
 static void sigterm_handler(int sig)
 {
 	syslog(LOG_INFO, "terminating on SIGTERM\n");
@@ -847,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
 
diff --git a/MHSave.txt b/MHSave.txt
new file mode 100644
index 0000000..e69de29
diff --git a/RHP.c b/RHP.c
index 18b933d..a82b091 100644
--- a/RHP.c
+++ b/RHP.c
@@ -451,8 +451,13 @@ int processRHCPSend(SOCKET Socket, char * Msg, char * ReplyBuffer)
 	int ID;
 	char * Data;
 	char * ptr;
+	unsigned char * uptr;
 	int c;
 	int Len;
+	unsigned int HexCode1;
+	unsigned int HexCode2;
+
+	int n;
 
 	int Handle = 1;
 
@@ -470,9 +475,10 @@ int processRHCPSend(SOCKET Socket, char * Msg, char * ReplyBuffer)
 
 	RHPSession = RHPSessions[Handle - 1];
 
-	// Look for \ escapes
+	// Look for \ escapes, Can now also get \u00c3
 
 	ptr = Data;
+	Len = strlen(Data);				// in case no escapes
 
 	while (ptr = strchr(ptr, '\\'))
 	{
@@ -483,23 +489,60 @@ int processRHCPSend(SOCKET Socket, char * Msg, char * ReplyBuffer)
 		case 'r':
 
 			*ptr = 13;
+			memmove(ptr + 1, ptr + 2, strlen(ptr + 1));
 			break;	
+
+		case 'u':
+
+			HexCode1 = HexCode2 = 0;
+			
+			n = toupper(ptr[2]) - '0';
+			if (n > 9) n = n - 7;
+			HexCode1 |= n << 4;
+
+			n = toupper(ptr[3]) - '0';
+			if (n > 9) n = n - 7;
+			HexCode1 |= n;
+
+			n = toupper(ptr[4]) - '0';
+			if (n > 9) n = n - 7;
+			HexCode2 |= n << 4;
+
+			n = toupper(ptr[5]) - '0';
+			if (n > 9) n = n - 7;
+			HexCode2 |= n;
+
+			if (HexCode1 == 0 || HexCode1 == 0xC2)
+			{
+				uptr = ptr;
+				*uptr = HexCode2;
+			}
+			else if (HexCode1 == 0xc2)
+			{
+				uptr = ptr;
+				*uptr = HexCode2 + 0x40;
+			}
+
+			memmove(ptr + 1, ptr + 6, strlen(ptr + 5));		
+			break;
+
 			
 		case '\\':
 
 			*ptr = '\\';
+			memmove(ptr + 1, ptr + 2, strlen(ptr + 1));
 			break;	
 
 		case '"':
 
 			*ptr = '"';
+			memmove(ptr + 1, ptr + 2, strlen(ptr + 1));
 			break;	
 		}
-		memmove(ptr + 1, ptr + 2, strlen(ptr + 1));
 		ptr++;
+		Len = ptr - Data;
 	}
 
-	Len = strlen(Data);
 	ptr = Data;
 
 	while (Len > RHPPaclen)
@@ -640,7 +683,7 @@ void RHPPoll()
 
 				// Message is JSON so Convert CR to \r, \ to \\ " to \"
 
-				// Looks like I need to escape everything not between 0x20 and 0x7f eg \U00c3
+				// Looks like I need to escape everything not between 0x20 and 0x7f eg \u00c3
 
 
 				while (c = *(ptr))
diff --git a/TNCCode.c b/TNCCode.c
index 37cd8e2..5103cfe 100644
--- a/TNCCode.c
+++ b/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;
 	}
 
diff --git a/UZ7HODrv.c b/UZ7HODrv.c
index 8c36e2b..ac33278 100644
--- a/UZ7HODrv.c
+++ b/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
 			{
diff --git a/VARA.c b/VARA.c
index 4d46984..4574fa4 100644
--- a/VARA.c
+++ b/VARA.c
@@ -1720,7 +1720,6 @@ VConnected:
 				GetSemaphore(&Semaphore, 52);
 				VARAProcessReceivedControl(TNC);
 				FreeSemaphore(&Semaphore);
-				Debugprintf("VARA Returned from processing control packet");
 			}
 								
 			if (FD_ISSET(TNC->TCPDataSock, &readfs))
diff --git a/Versions.h b/Versions.h
index 707d0f4..a8b7c24 100644
--- a/Versions.h
+++ b/Versions.h
@@ -10,15 +10,15 @@
 
 #endif
 
-#define KVers 6,0,24,69
-#define KVerstring "6.0.24.69\0"
+#define KVers 6,0,24,71
+#define KVerstring "6.0.24.71\0"
 
 
 #ifdef CKernel
 
 #define Vers KVers
 #define Verstring KVerstring
-#define Datestring "March 2025"
+#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"
diff --git a/WINMOR.c b/WINMOR.c
index f0f9d98..2a3d766 100644
--- a/WINMOR.c
+++ b/WINMOR.c
@@ -139,6 +139,10 @@ VOID WritetoTraceSupport(struct TNCINFO * TNC, char * Msg, int Len)
 	int LineLen, i;
 	UCHAR Save;
 	int SaveLen = Len;
+	char Time[16];
+	time_t T;
+	struct tm * tm;
+
 	if (Len < 0)
 		return;
 
@@ -206,10 +210,16 @@ lineloop:
 #endif
 			// Write to Web Buffer
 
+			T = time(NULL);
+			tm = gmtime(&T);
+	
+			sprintf_s(Time, sizeof(Time),"%02d:%02d ", tm->tm_hour, tm->tm_min);
+
+			strcat(TNC->WebBuffer, Time);
 			strcat(TNC->WebBuffer, Line);
 			strcat(TNC->WebBuffer, "\r\n");
 			if (strlen(TNC->WebBuffer) > 4500)
-				memmove(TNC->WebBuffer, &TNC->WebBuffer[500], 4490);	// Make sure null is moved
+				memmove(TNC->WebBuffer, &TNC->WebBuffer[500], strlen(&TNC->WebBuffer[500]) + 1);	// Make sure null is moved
 		Skip:
 			ptr1 = ptr2;
 
@@ -248,10 +258,16 @@ lineloop:
 #else
 			index=SendMessage(TNC->hMonitor, LB_ADDSTRING, 0, (LPARAM)(LPCTSTR) ptr1 );
 #endif
+			T = time(NULL);
+			tm = gmtime(&T);
+	
+			sprintf_s(Time, sizeof(Time),"%02d:%02d ", tm->tm_hour, tm->tm_min);
+			strcat(TNC->WebBuffer, Time);
+
 			strcat(TNC->WebBuffer, ptr1);
 			strcat(TNC->WebBuffer, "\r\n");
 			if (strlen(TNC->WebBuffer) > 4500)
-				memmove(TNC->WebBuffer, &TNC->WebBuffer[500], 4490);	// Make sure null is moved
+				memmove(TNC->WebBuffer, &TNC->WebBuffer[500], strlen(&TNC->WebBuffer[500]) + 1);	// Make sure null is moved
 		}
 	}
 
diff --git a/WebMail.c b/WebMail.c
index 90ae26a..6510618 100644
--- a/WebMail.c
+++ b/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)
 	{
diff --git a/asmstrucs.h b/asmstrucs.h
index 6394ef1..34b8ce5 100644
--- a/asmstrucs.h
+++ b/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;
diff --git a/bpqaxip.c b/bpqaxip.c
index af23508..92cc9ab 100644
--- a/bpqaxip.c
+++ b/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
 
diff --git a/cMain.c b/cMain.c
index 06503fd..1815950 100644
--- a/cMain.c
+++ b/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;
diff --git a/config.c b/config.c
index 84df6b3..2ca25d3 100644
--- a/config.c
+++ b/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++)
diff --git a/configstructs.h b/configstructs.h
index 2bdf983..f2efec3 100644
--- a/configstructs.h
+++ b/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
diff --git a/kiss.c b/kiss.c
index b511296..2f2f071 100644
--- a/kiss.c
+++ b/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;
diff --git a/makefile b/makefile
index 7f870ff..6d7c6e4 100644
--- a/makefile
+++ b/makefile
@@ -19,15 +19,15 @@ OBJS = pngwtran.o pngrtran.o pngset.o pngrio.o pngwio.o pngtrans.o pngrutil.o pn
 
 CC = gcc
 		                       
-all: CFLAGS = -DLINBPQ -MMD -g -rdynamic -fcommon
+all: CFLAGS = -DLINBPQ -MMD -g -rdynamic -fcommon -fasynchronous-unwind-tables
 all: LDFLAGS = -l:libpaho-mqtt3a.a -l:libjansson.a
 all: linbpq
 
 
-nomqtt: CFLAGS = -DLINBPQ -MMD -fcommon -g  -rdynamic -DNOMQTT
+nomqtt: CFLAGS = -DLINBPQ -MMD -fcommon -g  -rdynamic -DNOMQTT -fasynchronous-unwind-tables
 nomqtt: linbpq
 
-noi2c: CFLAGS = -DLINBPQ -MMD -DNOI2C -g  -rdynamic -fcommon
+noi2c: CFLAGS = -DLINBPQ -MMD -DNOI2C -g  -rdynamic -fcommon -fasynchronous-unwind-tables
 noi2c: linbpq
 
 
diff --git a/mqtt.c b/mqtt.c
index ff1c716..a9e91b4 100644
--- a/mqtt.c
+++ b/mqtt.c
@@ -429,6 +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) {};
 
 #endif
-
diff --git a/upnp.c b/upnp.c
index 96cb9d3..8190a62 100644
--- a/upnp.c
+++ b/upnp.c
@@ -93,7 +93,11 @@ 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;
@@ -119,8 +123,11 @@ int upnpInit()
 	{
 		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");
@@ -150,8 +157,11 @@ int upnpClose()
 	{
 		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");