RedAlert/CODE/COMBUF.CPP

/*
**	Command & Conquer Red Alert(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program 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.
**
**	This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/* $Header: /CounterStrike/COMBUF.CPP 1     3/03/97 10:24a Joe_bostic $ */
/***************************************************************************
 **   C O N F I D E N T I A L --- W E S T W O O D    S T U D I O S        **
 ***************************************************************************
 *                                                                         *
 *                 Project Name : Command & Conquer                        *
 *                                                                         *
 *                    File Name : COMBUF.CPP                             	*
 *                                                                         *
 *                   Programmer : Bill Randolph                            *
 *                                                                         *
 *                   Start Date : December 19, 1994                        *
 *                                                                         *
 *                  Last Update : October 23, 1995 [BRR]                   *
 *                                                                         *
 *-------------------------------------------------------------------------*
 * Functions:                                                              *
 *   CommBufferClass::CommBufferClass -- class constructor           		*
 *   CommBufferClass::~CommBufferClass -- class destructor           		*
 *   CommBufferClass::Init -- initializes this queue                       *
 *   CommBufferClass::Init_Send_Queue -- Clears the send queue             *
 *   CommBufferClass::Queue_Send -- queues a message for sending           *
 *   CommBufferClass::UnQueue_Send -- removes next entry from send queue	*
 *   CommBufferClass::Get_Send -- gets ptr to queue entry                  *
 *   CommBufferClass::Queue_Receive -- queues a received message				*
 *   CommBufferClass::UnQueue_Receive -- removes next entry from send queue*
 *   CommBufferClass::Get_Receive -- gets ptr to queue entry               *
 *   CommBufferClass::Add_Delay -- adds a new delay value for response time*
 *   CommBufferClass::Avg_Response_Time -- returns average response time  	*
 *   CommBufferClass::Max_Response_Time -- returns max response time  		*
 *   CommBufferClass::Reset_Response_Time -- resets computations				*
 *   Mono_Debug_Print -- Debug output routine                              *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include	"function.h"
#include <stdio.h>
#include <mem.h>
#include "combuf.h"
#include "connect.h"	// for command names for debug output
#include "wwlib32.h"	// to enable mono output


/***************************************************************************
 * CommBufferClass::CommBufferClass -- class constructor             		*
 *                                                                         *
 * INPUT:                                                                  *
 *		numsend		# queue entries for sending										*
 *		numreceive	# queue entries for receiving										*
 *		maxlen		maximum desired packet length, in bytes						*
 *		extralen		max size of app-specific extra bytes (optional)				*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   12/19/1994 BR : Created.                                              *
 *=========================================================================*/
CommBufferClass::CommBufferClass(int numsend, int numreceive, int maxlen,
	int extralen)
{
	int i;

	//------------------------------------------------------------------------
	//	Init variables
	//------------------------------------------------------------------------
	MaxSend = numsend;
	MaxReceive = numreceive;
	MaxPacketSize = maxlen;
	MaxExtraSize = extralen;

	//------------------------------------------------------------------------
	//	Allocate the queue entries
	//------------------------------------------------------------------------
	SendQueue = new SendQueueType[numsend];
	ReceiveQueue = new ReceiveQueueType[numreceive];

	SendIndex = new int[numsend];
	ReceiveIndex = new int[numreceive];

	//------------------------------------------------------------------------
	//	Allocate queue entry buffers
	//------------------------------------------------------------------------
	for (i = 0; i < MaxSend; i++) {
		SendQueue[i].Buffer = new char[maxlen];
		if (MaxExtraSize > 0) {
			SendQueue[i].ExtraBuffer = new char[MaxExtraSize];
		}
		else {
			SendQueue[i].ExtraBuffer = NULL;
		}
	}

	for (i = 0; i < MaxReceive; i++) {
		ReceiveQueue[i].Buffer = new char[maxlen];
		if (MaxExtraSize > 0) {
			ReceiveQueue[i].ExtraBuffer = new char[MaxExtraSize];
		}
		else {
			ReceiveQueue[i].ExtraBuffer = NULL;
		}
	}

	Init();

}	/* end of CommBufferClass */


/***************************************************************************
 * CommBufferClass::~CommBufferClass -- class destructor             		*
 *                                                                         *
 * INPUT:                                                                  *
 *		none.																						*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   12/19/1994 BR : Created.                                              *
 *=========================================================================*/
CommBufferClass::~CommBufferClass()
{
	int i;

	//------------------------------------------------------------------------
	//	Free queue entry buffers
	//------------------------------------------------------------------------
	for (i = 0; i < MaxSend; i++) {
		delete [] SendQueue[i].Buffer;
		if (SendQueue[i].ExtraBuffer) {
			delete [] SendQueue[i].ExtraBuffer;
		}
	}

	for (i = 0; i < MaxReceive; i++) {
		delete [] ReceiveQueue[i].Buffer;
		if (ReceiveQueue[i].ExtraBuffer) {
			delete [] ReceiveQueue[i].ExtraBuffer;
		}
	}

	delete [] SendQueue;
	delete [] ReceiveQueue;

	delete [] SendIndex;
	delete [] ReceiveIndex;

}	/* end of ~CommBufferClass */


/***************************************************************************
 * CommBufferClass::Init -- initializes this queue                         *
 *                                                                         *
 * INPUT:                                                                  *
 *		none.																						*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   01/20/1995 BR : Created.                                              *
 *=========================================================================*/
void CommBufferClass::Init(void)
{
	int i;

	//------------------------------------------------------------------------
	//	Init data members
	//------------------------------------------------------------------------
	SendTotal = 0L;
	ReceiveTotal = 0L;

	DelaySum = 0L;
	NumDelay = 0L;
	MeanDelay = 0L;
	MaxDelay = 0L;

	SendCount = 0;

	ReceiveCount = 0;

	//------------------------------------------------------------------------
	//	Init the queue entries
	//------------------------------------------------------------------------
	for (i = 0; i < MaxSend; i++) {
		SendQueue[i].IsActive = 0;
		SendQueue[i].IsACK = 0;
		SendQueue[i].FirstTime = 0L;
		SendQueue[i].LastTime = 0L;
		SendQueue[i].SendCount = 0L;
		SendQueue[i].BufLen = 0;
		SendQueue[i].ExtraLen = 0;

		SendIndex[i] = 0;
	}

	for (i = 0; i < MaxReceive; i++) {
		ReceiveQueue[i].IsActive = 0;
		ReceiveQueue[i].IsRead = 0;
		ReceiveQueue[i].IsACK = 0;
		ReceiveQueue[i].BufLen = 0;
		ReceiveQueue[i].ExtraLen = 0;

		ReceiveIndex[i] = 0;
	}

	//------------------------------------------------------------------------
	//	Init debug values
	//------------------------------------------------------------------------
	DebugOffset = 0;
	DebugSize = 0;
	DebugNames = NULL;
	DebugNameCount = 0;

}	/* end of Init */


/***************************************************************************
 * CommBufferClass::Init_Send_Queue -- Clears the send queue               *
 *                                                                         *
 * INPUT:                                                                  *
 *		none.																						*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   10/23/1995 BRR : Created.                                             *
 *=========================================================================*/
void CommBufferClass::Init_Send_Queue(void)
{
	int i;

	//------------------------------------------------------------------------
	//	Init data members
	//------------------------------------------------------------------------
	SendCount = 0;

	//------------------------------------------------------------------------
	//	Init the queue entries
	//------------------------------------------------------------------------
	for (i = 0; i < MaxSend; i++) {
		SendQueue[i].IsActive = 0;
		SendQueue[i].IsACK = 0;
		SendQueue[i].FirstTime = 0L;
		SendQueue[i].LastTime = 0L;
		SendQueue[i].SendCount = 0L;
		SendQueue[i].BufLen = 0;
		SendQueue[i].ExtraLen = 0;

		SendIndex[i] = 0;
	}

}	/* end of Init_Send_Queue */


/***************************************************************************
 * CommBufferClass::Queue_Send -- queues a message for sending             *
 *                                                                         *
 * INPUT:                                                                  *
 *		buf			buffer containing the message										*
 *		buflen		length of 'buf'														*
 *		extrabuf		buffer containing extra data (optional)						*
 *		extralen		length of extra data (optional)									*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		1 = OK, 0 = no room in the queue													*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   12/20/1994 BR : Created.                                              *
 *=========================================================================*/
int CommBufferClass::Queue_Send(void *buf, int buflen, void *extrabuf,
	int extralen)
{
	int i;
	int index;

	//------------------------------------------------------------------------
	//	Error if no room in the queue
	//------------------------------------------------------------------------
	if (SendCount==MaxSend || buflen > MaxPacketSize)
		return(0);

	//------------------------------------------------------------------------
	//	Find an empty slot
	//------------------------------------------------------------------------
	index = -1;
	for (i = 0; i < MaxSend; i++) {
		if (SendQueue[i].IsActive==0) {
			index = i;
			break;
		}
	}
	if (index == -1)
		return (0);

	//------------------------------------------------------------------------
	//	Set entry flags
	//------------------------------------------------------------------------
	SendQueue[index].IsActive = 1;			// entry is now active
	SendQueue[index].IsACK = 0;				// entry hasn't been ACK'd
	SendQueue[index].FirstTime = 0L;			// filled in by Manager when sent
	SendQueue[index].LastTime = 0L;			// filled in by Manager when sent
	SendQueue[index].SendCount = 0L;			// filled in by Manager when sent
	SendQueue[index].BufLen = buflen;		// save buffer size

	//------------------------------------------------------------------------
	//	Copy the packet data
	//------------------------------------------------------------------------
	memcpy(SendQueue[index].Buffer,buf,buflen);

	//------------------------------------------------------------------------
	//	Fill in the extra data, if there is any
	//------------------------------------------------------------------------
	if (extrabuf!=NULL && extralen > 0 && extralen <= MaxExtraSize) {
		memcpy(SendQueue[index].ExtraBuffer,extrabuf,extralen);
		SendQueue[index].ExtraLen = extralen;
	}
	else {
		SendQueue[index].ExtraLen = 0;
	}

	//------------------------------------------------------------------------
	//	Save this entry's index
	//------------------------------------------------------------------------
	SendIndex[SendCount] = index;

	//------------------------------------------------------------------------
	//	Increment counters & entry ptr
	//------------------------------------------------------------------------
	SendCount++;
	SendTotal++;

	return(1);

}	/* end of Queue_Send */


/***************************************************************************
 * CommBufferClass::UnQueue_Send -- removes next entry from send queue		*
 *                                                                         *
 * Frees the given entry; the index given by the caller is the "active"		*
 * index value (ie the "nth" active entry), not the actual index in the		*
 * array.																						*
 *                                                                         *
 * INPUT:                                                                  *
 *		buf			buffer to store entry's data in; if NULL, it's discarded	*
 *		buflen		filled in with length of entry retrieved						*
 *		index			"index" of entry to un-queue										*
 *		extrabuf		buffer for extra data (optional)									*
 *		extralen		ptr to length of extra data (optional)							*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		1 = OK, 0 = no entry to retrieve													*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   12/20/1994 BR : Created.                                              *
 *=========================================================================*/
int CommBufferClass::UnQueue_Send(void *buf, int *buflen, int index,
	void *extrabuf, int *extralen)
{
	int i;

	//------------------------------------------------------------------------
	//	Error if no entry to retrieve
	//------------------------------------------------------------------------
	if (SendCount==0 || SendQueue[SendIndex[index]].IsActive==0) {
		return(0);
	}

	//------------------------------------------------------------------------
	//	Copy the data from the entry
	//------------------------------------------------------------------------
	if (buf!=NULL) {
		memcpy(buf,SendQueue[SendIndex[index]].Buffer,
			SendQueue[SendIndex[index]].BufLen);
		(*buflen) = SendQueue[SendIndex[index]].BufLen;
	}

	//------------------------------------------------------------------------
	//	Copy the extra data
	//------------------------------------------------------------------------
	if (extrabuf!=NULL && extralen!=NULL) {
		memcpy(extrabuf,SendQueue[SendIndex[index]].ExtraBuffer,
			SendQueue[SendIndex[index]].ExtraLen);
		(*extralen) = SendQueue[SendIndex[index]].ExtraLen;
	}

	//------------------------------------------------------------------------
	//	Set entry flags
	//------------------------------------------------------------------------
	SendQueue[SendIndex[index]].IsActive = 0;
	SendQueue[SendIndex[index]].IsACK = 0;
	SendQueue[SendIndex[index]].FirstTime = 0L;
	SendQueue[SendIndex[index]].LastTime = 0L;
	SendQueue[SendIndex[index]].SendCount = 0L;
	SendQueue[SendIndex[index]].BufLen = 0;
	SendQueue[SendIndex[index]].ExtraLen = 0;

	//------------------------------------------------------------------------
	//	Move Indices back one
	//------------------------------------------------------------------------
	for (i = index; i < SendCount - 1; i++) {
		SendIndex[i] = SendIndex[i + 1];
	}
	SendIndex[SendCount - 1] = 0;
	SendCount--;

	return(1);

}	/* end of UnQueue_Send */


/***************************************************************************
 * CommBufferClass::Get_Send -- gets ptr to queue entry                    *
 *                                                                         *
 * This routine gets a pointer to the indicated queue entry.  The index		*
 * value is relative to the next-accessible queue entry; 0 = get the			*
 * next available queue entry, 1 = get the one behind that, etc.				*
 *                                                                         *
 * INPUT:                                                                  *
 *		index		index of entry to get (0 = 1st available)							*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		ptr to entry																			*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   12/21/1994 BR : Created.                                              *
 *=========================================================================*/
SendQueueType * CommBufferClass::Get_Send(int index)
{
	if (SendQueue[SendIndex[index]].IsActive==0) {
		return(NULL);
	}
	else {
		return(&SendQueue[SendIndex[index]]);
	}

}	/* end of Get_Send */


/***************************************************************************
 * CommBufferClass::Queue_Receive -- queues a received message					*
 *                                                                         *
 * INPUT:                                                                  *
 *		buf			buffer containing the message										*
 *		buflen		length of 'buf'														*
 *		extrabuf		buffer containing extra data (optional)						*
 *		extralen		length of extra data (optional)									*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		1 = OK, 0 = no room in the queue													*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   12/20/1994 BR : Created.                                              *
 *=========================================================================*/
int CommBufferClass::Queue_Receive(void *buf, int buflen, void *extrabuf,
	int extralen)
{
	int i;
	int index;

	//------------------------------------------------------------------------
	//	Error if no room in the queue
	//------------------------------------------------------------------------
	if (ReceiveCount==MaxReceive || buflen > MaxPacketSize) {
		return(0);
	}

	//------------------------------------------------------------------------
	//	Find an empty slot
	//------------------------------------------------------------------------
	index = -1;
	for (i = 0; i < MaxReceive; i++) {
		if (ReceiveQueue[i].IsActive==0) {
			index = i;
			break;
		}
	}
	if (index == -1)
		return (0);

	//------------------------------------------------------------------------
	//	Set entry flags
	//------------------------------------------------------------------------
	ReceiveQueue[index].IsActive = 1;
	ReceiveQueue[index].IsRead = 0;
	ReceiveQueue[index].IsACK = 0;
	ReceiveQueue[index].BufLen = buflen;

	//------------------------------------------------------------------------
	//	Copy the packet data
	//------------------------------------------------------------------------
	memcpy(ReceiveQueue[index].Buffer,buf,buflen);

	//------------------------------------------------------------------------
	//	Fill in the extra data, if there is any
	//------------------------------------------------------------------------
	if (extrabuf!=NULL && extralen > 0 && extralen <= MaxExtraSize) {
		memcpy(ReceiveQueue[index].ExtraBuffer,extrabuf,extralen);
		ReceiveQueue[index].ExtraLen = extralen;
	}
	else {
		ReceiveQueue[index].ExtraLen = 0;
	}

	//------------------------------------------------------------------------
	//	Save this entry's index
	//------------------------------------------------------------------------
	ReceiveIndex[ReceiveCount] = index;

	//------------------------------------------------------------------------
	//	Increment counters & entry ptr
	//------------------------------------------------------------------------
	ReceiveCount++;
	ReceiveTotal++;

	return(1);

}	/* end of Queue_Receive */


/***************************************************************************
 * CommBufferClass::UnQueue_Receive -- removes next entry from send queue	*
 *                                                                         *
 * Frees the given entry; the index given by the caller is the "active"		*
 * index value (ie the "nth" active entry), not the actual index in the		*
 * array.																						*
 *                                                                         *
 * INPUT:                                                                  *
 *		buf			buffer to store entry's data in; if NULL, it's discarded	*
 *		buflen		filled in with length of entry retrieved						*
 *		index			index of entry to un-queue											*
 *		extrabuf		buffer for extra data (optional)									*
 *		extralen		ptr to length of extra data (optional)							*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		1 = OK, 0 = no entry to retrieve													*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   12/20/1994 BR : Created.                                              *
 *=========================================================================*/
int CommBufferClass::UnQueue_Receive(void *buf, int *buflen, int index,
	void *extrabuf, int *extralen)
{
	int i;

	//------------------------------------------------------------------------
	//	Error if no entry to retrieve
	//------------------------------------------------------------------------
	if (ReceiveCount==0 || ReceiveQueue[ReceiveIndex[index]].IsActive==0) {
		return(0);
	}

	//------------------------------------------------------------------------
	//	Copy the data from the entry
	//------------------------------------------------------------------------
	if (buf!=NULL) {
		memcpy(buf,ReceiveQueue[ReceiveIndex[index]].Buffer,
			ReceiveQueue[ReceiveIndex[index]].BufLen);
		(*buflen) = ReceiveQueue[ReceiveIndex[index]].BufLen;
	}

	//------------------------------------------------------------------------
	//	Copy the extra data
	//------------------------------------------------------------------------
	if (extrabuf!=NULL && extralen!=NULL) {
		memcpy(extrabuf,ReceiveQueue[ReceiveIndex[index]].ExtraBuffer,
			ReceiveQueue[ReceiveIndex[index]].ExtraLen);
		(*extralen) = ReceiveQueue[ReceiveIndex[index]].ExtraLen;
	}

	//------------------------------------------------------------------------
	//	Set entry flags
	//------------------------------------------------------------------------
	ReceiveQueue[ReceiveIndex[index]].IsActive = 0;
	ReceiveQueue[ReceiveIndex[index]].IsRead = 0;
	ReceiveQueue[ReceiveIndex[index]].IsACK = 0;
	ReceiveQueue[ReceiveIndex[index]].BufLen = 0;
	ReceiveQueue[ReceiveIndex[index]].ExtraLen = 0;

	//------------------------------------------------------------------------
	//	Move Indices back one
	//------------------------------------------------------------------------
	for (i = index; i < ReceiveCount - 1; i++) {
		ReceiveIndex[i] = ReceiveIndex[i + 1];
	}
	ReceiveIndex[ReceiveCount - 1] = 0;
	ReceiveCount--;

	return(1);

}	/* end of UnQueue_Receive */


/***************************************************************************
 * CommBufferClass::Get_Receive -- gets ptr to queue entry                 *
 *                                                                         *
 * This routine gets a pointer to the indicated queue entry.  The index		*
 * value is relative to the next-accessible queue entry; 0 = get the			*
 * next available queue entry, 1 = get the one behind that, etc.				*
 *                                                                         *
 * INPUT:                                                                  *
 *		index		index of entry to get (0 = 1st available)							*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		ptr to entry																			*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   12/21/1994 BR : Created.                                              *
 *=========================================================================*/
ReceiveQueueType * CommBufferClass::Get_Receive(int index)
{
	if (ReceiveQueue[ReceiveIndex[index]].IsActive==0) {
		return(NULL);
	}
	else {
		return(&ReceiveQueue[ReceiveIndex[index]]);
	}

}	/* end of Get_Receive */


/***************************************************************************
 * CommBufferClass::Add_Delay -- adds a new delay value for response time  *
 *                                                                         *
 * This routine updates the average response time for this queue.  The		*
 * computation is based on the average of the last 'n' delay values given,	*
 * It computes a running total of the last n delay values, then divides 	*
 * that by n to compute the average.													*
 *																									*
 * When the number of values given exceeds the max, the mean is subtracted	*
 * off the total, then the new value is added in.  Thus, any single delay	*
 * value will have an effect on the total that approaches 0 over time, and	*
 * the new delay value contributes to 1/n of the mean.							*
 *                                                                         *
 * INPUT:                                                                  *
 *		delay			value to add into the response time computation				*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   01/19/1995 BR : Created.                                              *
 *=========================================================================*/
void CommBufferClass::Add_Delay(unsigned long delay)
{
	int roundoff = 0;

	if (NumDelay==256) {
		DelaySum -= MeanDelay;
		DelaySum += delay;
		if ( (DelaySum & 0x00ff) > 127)
			roundoff = 1;
		MeanDelay = (DelaySum >> 8) + roundoff;
	}
	else {
		NumDelay++;
		DelaySum += delay;
		MeanDelay = DelaySum / NumDelay;
	}

	if (delay > MaxDelay) {
		MaxDelay = delay;
	}

}	/* end of Add_Delay */


/***************************************************************************
 * CommBufferClass::Avg_Response_Time -- returns average response time    	*
 *                                                                         *
 * INPUT:                                                                  *
 *		none.																						*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		latest computed average response time											*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   01/19/1995 BR : Created.                                              *
 *=========================================================================*/
unsigned long CommBufferClass::Avg_Response_Time(void)
{
	return(MeanDelay);

}	/* end of Avg_Response_Time */


/***************************************************************************
 * CommBufferClass::Max_Response_Time -- returns max response time    		*
 *                                                                         *
 * INPUT:                                                                  *
 *		none.																						*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		latest computed average response time											*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   01/19/1995 BR : Created.                                              *
 *=========================================================================*/
unsigned long CommBufferClass::Max_Response_Time(void)
{
	return(MaxDelay);

}	/* end of Max_Response_Time */


/***************************************************************************
 * CommBufferClass::Reset_Response_Time -- resets computations					*
 *                                                                         *
 * INPUT:                                                                  *
 *		none.																						*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   01/19/1995 BR : Created.                                              *
 *=========================================================================*/
void CommBufferClass::Reset_Response_Time(void)
{
	DelaySum = 0L;
	NumDelay = 0L;
	MeanDelay = 0L;
	MaxDelay = 0L;

}	/* end of Reset_Response_Time */


/***************************************************************************
 * CommBufferClass::Configure_Debug -- sets up special debug values        *
 *                                                                         *
 * Mono_Debug_Print2() can look into a packet to pull out a particular		*
 * ID, and can print both that ID and a string corresponding to				*
 * that ID.  This routine configures these values so it can find				*
 * and decode the ID.  This ID is used in addition to the normal				*
 * CommHeaderType values.																	*
 *                                                                         *
 * INPUT:                                                                  *
 *		type_offset		ID's byte offset into packet									*
 *		type_size		size of ID, in bytes; 0 if none								*
 *		names				ptr to array of names; use ID as an index into this	*
 *		maxnames			max # in the names array; 0 if none.						*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		Names shouldn't be longer than 12 characters.								*
 *                                                                         *
 * HISTORY:                                                                *
 *   05/31/1995 BRR : Created.                                             *
 *=========================================================================*/
void CommBufferClass::Configure_Debug(int type_offset, int type_size,
	char **names, int namestart, int namecount)
{
	DebugOffset = type_offset;
	DebugSize = type_size;
	DebugNames = names;
	DebugNameStart = namestart;
	DebugNameCount = namecount;

}	/* end of Configure_Debug */


/***************************************************************************
 * Mono_Debug_Print -- Debug output routine                                *
 *                                                                         *
 * This routine leaves 5 lines at the top for the caller's use.				*
 *                                                                         *
 * INPUT:                                                                  *
 *		refresh		1 = clear screen & completely refresh							*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   05/02/1995 BRR : Created.                                             *
 *=========================================================================*/
void CommBufferClass::Mono_Debug_Print(int refresh)
{
#ifdef WWLIB32_H
	int i;												// loop counter
	static int send_col[] = {1,14,28};			// coords of send queue columns
	static int receive_col[] = {40,54,68};		// coords of recv queue columns
	int row,col;										// current row,col for printing
	int num;												// max # items to print

	struct CommHdr {									// this mirrors the CommHeaderType
		unsigned short MagicNumber;
		unsigned char Code;
		unsigned long PacketID;
	} *hdr;

	//------------------------------------------------------------------------
	//	If few enough entries, call the verbose debug version
	//------------------------------------------------------------------------
	if (MaxSend <= 16) {
		Mono_Debug_Print2(refresh);
		return;
	}

	//------------------------------------------------------------------------
	//	Refresh the screen
	//------------------------------------------------------------------------
	if (refresh) {
		Mono_Clear_Screen ();
		Mono_Printf("ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n");
		Mono_Printf("³                                                                             ³\n");
		Mono_Printf("³                                                                             ³\n");
		Mono_Printf("³                                                                             ³\n");
		Mono_Printf("ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´\n");
		Mono_Printf("³              Send Queue              ³             Receive Queue            ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³ ID  Ct ACK   ID  Ct ACK    ID  Ct ACK³ ID  Rd ACK    ID  Rd ACK   ID  Rd ACK³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ");
	}

	//------------------------------------------------------------------------
	//	Print Send Queue items
	//------------------------------------------------------------------------
	if (MaxSend <= 48) {
		num = MaxSend;
	}
	else {
		num = 48;
	}
	col = 0;
	row = 0;
	for (i = 0; i < MaxSend; i++) {
		Mono_Set_Cursor (send_col[col],row + 8);
		if (SendQueue[i].IsActive) {
			hdr = (CommHdr *)SendQueue[i].Buffer;
			hdr->MagicNumber = hdr->MagicNumber;
			hdr->Code = hdr->Code;
			Mono_Printf ("%4d %2d  %d",hdr->PacketID, SendQueue[i].SendCount,
				SendQueue[i].IsACK);
		}
		else {
			Mono_Printf ("____ __  _ ");
		}

		row++;
		if (row > 15) {
			row = 0;
			col++;
		}
	}

	//------------------------------------------------------------------------
	//	Print Receive Queue items
	//------------------------------------------------------------------------
	if (MaxReceive <= 48) {
		num = MaxSend;
	}
	else {
		num = 48;
	}
	col = 0;
	row = 0;
	for (i = 0; i < MaxReceive; i++) {
		Mono_Set_Cursor (receive_col[col],row + 8);
		if (ReceiveQueue[i].IsActive) {
			hdr = (CommHdr *)ReceiveQueue[i].Buffer;
			Mono_Printf ("%4d  %d  %d",hdr->PacketID, ReceiveQueue[i].IsRead,
				ReceiveQueue[i].IsACK);
		}
		else {
			Mono_Printf ("____  _  _ ");
		}

		row++;
		if (row > 15) {
			row = 0;
			col++;
		}
	}

#else
	refresh = refresh;
#endif
}	/* end of Mono_Debug_Print */


/***************************************************************************
 * CommBufferClass::Mono_Debug_Print2 -- Debug output; alternate format    *
 *                                                                         *
 * This routine prints more information than the other version; it's			*
 * called only if the number of queue entries is small enough to support	*
 * this format.																				*
 *                                                                         *
 * INPUT:                                                                  *
 *		refresh		1 = clear screen & completely refresh							*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   05/31/1995 BRR : Created.                                             *
 *=========================================================================*/
void CommBufferClass::Mono_Debug_Print2(int refresh)
{
#ifdef WWLIB32_H
	int i;												// loop counter
	char txt[80];
	int val;

	struct CommHdr {									// this mirrors the CommHeaderType
		unsigned short MagicNumber;
		unsigned char Code;
		unsigned long PacketID;
	} *hdr;

	//------------------------------------------------------------------------
	//	Refresh the screen
	//------------------------------------------------------------------------
	if (refresh) {
		Mono_Clear_Screen ();
		Mono_Printf("ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n");
		Mono_Printf("³                                                                             ³\n");
		Mono_Printf("³                                                                             ³\n");
		Mono_Printf("³                                                                             ³\n");
		Mono_Printf("ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´\n");
		Mono_Printf("³              Send Queue              ³             Receive Queue            ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³ ID  Ct Type   Data  Name         ACK ³ ID  Rd Type   Data  Name         ACK ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("³                                      ³                                      ³\n");
		Mono_Printf("ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ");
	}

	//------------------------------------------------------------------------
	//	Print Send Queue items
	//------------------------------------------------------------------------
	for (i = 0; i < MaxSend; i++) {
		Mono_Set_Cursor (1,8 + i);

		//.....................................................................
		//	Print an active entry
		//.....................................................................
		if (SendQueue[i].IsActive) {

			//..................................................................
			//	Get header info
			//..................................................................
			hdr = (CommHdr *)SendQueue[i].Buffer;
			hdr->MagicNumber = hdr->MagicNumber;
			hdr->Code = hdr->Code;
			sprintf(txt,"%4d %2d %-5s  ",
				hdr->PacketID,
				SendQueue[i].SendCount,
				ConnectionClass::Command_Name(hdr->Code));

			//..................................................................
			//	Decode app's ID & its name
			//..................................................................
			if (DebugSize && (DebugOffset + DebugSize) <= SendQueue[i].BufLen) {
				if (DebugSize==1) {
					val = *(SendQueue[i].Buffer + DebugOffset);

				}
				else if (DebugSize==2) {
					val = *((short *)(SendQueue[i].Buffer + DebugOffset));

				}
				else if (DebugSize==4) {
					val = *((int *)(SendQueue[i].Buffer + DebugOffset));
				}
				sprintf(txt + strlen(txt),"%4d  ",val);

				if (DebugNameCount > 0 && val >= 0 && val < DebugNameCount) {
					sprintf(txt + strlen(txt),"%-12s  %x",
						DebugNames[val - DebugNameStart], SendQueue[i].IsACK);
				}
				else {
					sprintf(txt + strlen(txt),"              %x",
						SendQueue[i].IsACK);
				}
			}
			else {
				sprintf(txt + strlen(txt),"                    %x",
					SendQueue[i].IsACK);
			}

			Mono_Printf("%s",txt);
		}
		else {

			//..................................................................
			//	Entry isn't active; print blanks
			//..................................................................
			Mono_Printf("____ __                            _");
		}
	}

	//------------------------------------------------------------------------
	//	Print Receive Queue items
	//------------------------------------------------------------------------
	for (i = 0; i < MaxReceive; i++) {
		Mono_Set_Cursor (40,8 + i);

		//.....................................................................
		//	Print an active entry
		//.....................................................................
		if (ReceiveQueue[i].IsActive) {

			//..................................................................
			//	Get header info
			//..................................................................
			hdr = (CommHdr *)ReceiveQueue[i].Buffer;
			hdr->MagicNumber = hdr->MagicNumber;
			hdr->Code = hdr->Code;
			sprintf(txt,"%4d %2d %-5s  ",
				hdr->PacketID,
				ReceiveQueue[i].IsRead,
				ConnectionClass::Command_Name(hdr->Code));

			//..................................................................
			//	Decode app's ID & its name
			//..................................................................
			if (DebugSize && (DebugOffset + DebugSize) <= ReceiveQueue[i].BufLen) {
				if (DebugSize==1) {
					val = *(ReceiveQueue[i].Buffer + DebugOffset);

				}
				else if (DebugSize==2) {
					val = *((short *)(ReceiveQueue[i].Buffer + DebugOffset));

				}
				else if (DebugSize==4) {
					val = *((int *)(ReceiveQueue[i].Buffer + DebugOffset));
				}
				sprintf(txt + strlen(txt),"%4d  ",val);

				if (DebugNameCount > 0 && val >= 0 && val < DebugNameCount) {
					sprintf(txt + strlen(txt),"%-12s  %x",
						DebugNames[val - DebugNameStart], ReceiveQueue[i].IsACK);
				}
				else {
					sprintf(txt + strlen(txt),"              %x",
						ReceiveQueue[i].IsACK);
				}
			}
			else {
				sprintf(txt + strlen(txt),"                    %x",
					ReceiveQueue[i].IsACK);
			}

			Mono_Printf("%s",txt);
		}
		else {

			//..................................................................
			//	Entry isn't active; print blanks
			//..................................................................
			Mono_Printf("____ __                            _");
		}
	}

#else
	refresh = refresh;
#endif
}	/* end of Mono_Debug_Print2 */


/************************** end of combuf.cpp ******************************/