/*----------------------------------------------------------------------------*/
/* Program:  survey2s.c		(Assignment#4)                "Server Application"
/*
/* Written By: Dan Swaney
/* Class     : CS476/576 - Unix Systems Programming (Instructor: Dr. Wahab)
/* Date      : November 10, 1997
/*
/* Description: This program will:
/*              1. Act as a server serving multiple client apps (survey2c)
/*                 of which to collect data for a survey.
/*
/*              2. Display a master instructor window that displays results
/*                 as they are compiled.
/*
/* Parameters: survey2s <time in minutes> <host server> <port address>
/*
/*             <time in minutes> - timespan of survey of which users can 
/*                                 participate users are notified of the result
/*                                 when timer reaches zero.
/*             <host server> - the machine name or IP address of where this
/*                             server is to be running (e.g. buttercup)
/*             <port address> - enter a value between 1025 and 65535 
/*                              (0 for random pick)
/*                              The client must know this port in order to
/*                              connect and participate in the survey.
/*             
/* Example: %survey2s 5 buttercup 4001
/*          (assuming you have an xsession on buttercup)
/*-----------------------------------------------------------------------------*/

#include <Xm/Xm.h>     /* Required by all Motif applications */
#include <Xm/Label.h>  /* Required by XmLabel widget */
#include <Xm/PushB.h>  /* Required by XmPushButton widget */
#include <Xm/Form.h>   /* Required by XmForm widget */
#include <Xm/RowColumn.h> /* Required by XmRowColumnWidgetClass */
#include <Xm/BulletinB.h> /* Required by XmBulletinBoard Widget */
#include <Xm/ToggleB.h>   /* Required by XmToggleButtonWidgetClass */
#include <Xm/Scale.h>     /* Required by XmScaleWidgetClass */
#include <Xm/Separator.h> /* Required by XmSeparatorWidgetClass */
#include <Xm/Text.h>

#include <sys/time.h>
#include <sys/param.h>
#include <sys/types.h>    /* This group of includes are for the */
#include <sys/socket.h>   /* Berkeley Socket usage. */
#include <sys/socket.h>
#include <sys/file.h>
#include <sys/wait.h>     /* Needed for status codes of waitpid() */

#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>

#include <arpa/inet.h>

#include <errno.h>
#include <string.h>
#include <netdb.h>

#include <stdlib.h>    /* Needed for exit() */
#include <stdio.h>     /* Needed to use fprintf */

#define MAX_USERS  6
#define INSTRUCTOR 0

#define MAX_PACKET_SIZE 255

#define WND_HEIGHT 400
#define WND_WIDTH  305

#define TIMEOUT 2

static XtAppContext hTheApp;
   
static Widget wShell;
static Widget wPanel;
static Widget wSendButton, wQuitButton;

static Widget wRowColCheckBox, wCheckBoxGroup;
static Widget wCheckboxSet;

static Widget wScale;
static Widget wQuestionLabel;
static Widget wSeparator;

static Widget wYesCount;
static Widget wNoCount;

static Widget wMessageLabel;
static Widget wCountdownLabel;

static Widget wTextField;

static Widget wDummyText;

static Widget wPopupShell;
static Widget wMessage;
	
static int  g_nUsers     = 0;
static int  g_nTotalResponses = 0;
static int  g_nYesCount  = 0;
static int  g_nNoCount   = 0;
static int  g_nSecondsLeft = 0;
static int  g_nMinutesLeft = 0;

static int  bQueryInProgress = FALSE;
static int  MessageBoxIsUp = FALSE;


static char g_sQuestion[MAX_PACKET_SIZE];

static char g_cAnswer;
static int  g_nResponded;
static int  g_nActive;

static Display *hUDisplay;

static char sUDisplayName[255];

static char sTemp[255];
static XmString xsTemp;

static int bInstructorIsQuitting = FALSE;

static char sProgramName[255];
static char sTimeLimit[7];

static int nNumberOfUsers;

static char sProcessName[50];
static char sMessage[255];


typedef struct AnswerInfoStruct
{
	char Answer[10];
	int  nValue;
} ANSWERINFOSTRUCT;

static ANSWERINFOSTRUCT AnswerInfo;


typedef struct tcpServerInfo
{
	char sThisHost[80];
	char sThisPort[80];

	char sInputBuffer[MAX_PACKET_SIZE];
	
	struct servent *sp;
	struct hostent *hp; /*, *gethostbyname();*/

	struct sockaddr_in server;
	struct sockaddr_in from;

	int fromlen;
	int length;

	int sd, psd;

	int sockets1[2]; /* Used for Pipe Between Main Program and Listener Loop */
	int sockets2[2]; /* Used for Pipe */
} TCPSERVERINFO;

static TCPSERVERINFO tsi;
static int pid;    /* Used for forked child process */

typedef struct myProcessInfo
{
	int pid;
	int socketsP1[2]; /* Talk to the Parent Process (Read) */
	int socketsP2[2]; /* Talk to the Parent Process (Write)*/

	int nActive;  /* If the Process is Active */

	int psd; /* Keeps track of socket for client app */
} MYPROCESSINFO;

static MYPROCESSINFO hProcessInfo[99];

/*
struct hostent {
	char *h_name;
	char **h_aliases;
	int  h_addrtype;
	int  h_length;
	char *h_addr_list;
}

struct servent {
	char *s_name;
	char **s_aliases;
	int  s_port;
	char *s_proto;
}

struct sockaddr_in {
	short          sin_family;
	u_short        sin_port;
	struct in_addr sin_addr;
}
*/

/*---------------------------------------------------------------*/
/* Function Prototypes                                           */
/*---------------------------------------------------------------*/
static void SendButtonCallback( Widget w, XtPointer clientData, XtPointer callData );
static void QuitButtonCallback( Widget w, XtPointer clientData, XtPointer callData );
static void ValueChangedCallback(Widget w, XtPointer clientData, XtPointer callData);

static void DoNothingCallback(Widget w, XtPointer clientData, XtPointer callData);
static void TextMotionCallback(Widget w, XtPointer clientData, XtPointer callData);
static void TextModifiedCallback(Widget w, XtPointer clientData, XtPointer callData);
static void TextFocusCallback(Widget w, XtPointer clientData, XtPointer callData);

/*---------------------------------------------------------------------------------*/  							   

void main( int argc, char **argv)
{
	int          i;
	strcpy(sProcessName, "MAIN\0");
	/*-------------------------------------------------------*/
	/* Note: We are doing everything manually since we'll be */
	/*       dealing with multiple displays                  */
	/*-------------------------------------------------------*/
	
	/* Initialize the Intrinsics */
	XtToolkitInitialize();
	
	for(i=0; i<9; i++)
	{
		hProcessInfo[i].pid = 0;
		hProcessInfo[i].nActive = FALSE;
	}
	
	/* Create Instructor Window Context */
	hTheApp = XtCreateApplicationContext();
	
	/* Check for Valid Number of Arguments (before opening window) */
	if (argc != 4)
	{
		DisplayMessage("Invalid Number of Arguments!", INSTRUCTOR, TRUE);
		DisplayMessage("\nFormat: survey2c <time limit> <this host> <this port>", INSTRUCTOR, TRUE);
		exit(1);
	}
	
	/* Move the arguments into application's variables for safe keeping */
	strcpy(sProgramName, argv[0]);
	strcpy(sTimeLimit,   argv[1]);
	strcpy(tsi.sThisHost,    argv[2]);
	strcpy(tsi.sThisPort,    argv[3]);

	InitTcpServer();

	CreateInstructorWindow();
	
	DisplayMessage("Starting Application...", INSTRUCTOR, FALSE);
	XtAppMainLoop(hTheApp);
}

/*---------------------------------------------------------*/
/* Name: CreateInstructorWindow()                          */
/*                                                         */
/* Description: First-time creation of the Instructor      */
/*              window and it's components.                */
/*                                                         */
/*---------------------------------------------------------*/
static int CreateInstructorWindow()
{
	int  nWindowWidth, nWindowHeight;
	int  Xo, Yo;
	int  i, iTemp;
	char sCheckBox[2][255];
	int  iZero = 0;
	
	XmString xsTitle;
	/*----------------------------------*/
	/*         Open the Display         */
	/*----------------------------------*/
	DisplayMessage("Opening the Display...", INSTRUCTOR);

	hUDisplay = XtOpenDisplay(hTheApp, sUDisplayName, sProgramName, 
	                                     "Survey2", NULL, 0, &iZero, NULL);
	
	/*----------------------------------*/
	/*    Create the Top Level Shell    */
	/*----------------------------------*/
	DisplayMessage("Creating the Shell...", INSTRUCTOR);
	wShell = XtAppCreateShell(hTheApp, "Survey2", applicationShellWidgetClass, 
	                                     hUDisplay, NULL, 0);
	
	
	/*----------------------------------*/
	/*   Create Bulletin Board Panel    */
	/*----------------------------------*/
	DisplayMessage("Creating Panel...", INSTRUCTOR);
	wPanel = XtVaCreateManagedWidget("panel", xmBulletinBoardWidgetClass, wShell, 
										XmNx, 0, XmNy, 0,
										NULL);
	
	/*----------------------------------*/
	/*       Create Push Buttons        */
	/*----------------------------------*/
	Xo = ((WND_WIDTH / 2) - (60 / 2) + 1) + 5; /* Note: 5 is the offset */
	Yo = ((WND_HEIGHT / 2) - 2 + 1) - 30;
	wSendButton = XtVaCreateManagedWidget( "Send", xmPushButtonWidgetClass, wPanel, 
	                                      XmNx, Xo, XmNy, Yo, 
										  XmNwidth,  60,
	                                      NULL);
	Xo = ((WND_WIDTH / 2) - (60 / 2) + 1) + 5;
	Yo = ((WND_HEIGHT) - 2 + 1) - 30;
	wQuitButton = XtVaCreateManagedWidget( "Quit", xmPushButtonWidgetClass, wPanel,
	                                      XmNx, Xo, XmNy, Yo,
										  XmNwidth,  60,
	                                      NULL);
	
	XtAddCallback(wSendButton, XmNactivateCallback,
                 SendButtonCallback, INSTRUCTOR );
	
	XtAddCallback(wQuitButton, XmNactivateCallback,
	             QuitButtonCallback, INSTRUCTOR );
	
	/*-----------------------------------*/
	/*         Create Separator          */
	/*-----------------------------------*/
	Yo = (WND_HEIGHT / 2);
	wSeparator = XtVaCreateManagedWidget("separator",
	                                        xmSeparatorWidgetClass, wPanel,
											XmNx, 0, XmNy, Yo,
											XmNwidth, WND_WIDTH,
											XmNseparatorType, XmSHADOW_ETCHED_IN,
											NULL);
	XtManageChild( wSeparator );
	
	/*----------------------------------*/
	/*          Create Scale            */
	/*----------------------------------*/
	xsTitle = XmStringCreateLtoR( "Total Users that have Responded:", XmFONTLIST_DEFAULT_TAG );
	
	Xo = ((WND_WIDTH / 2) - (70 / 2) + 1);
	Yo = ((WND_HEIGHT) - 2 + 1) + 30 + 30;
	wScale = XtVaCreateManagedWidget( "scale", xmScaleWidgetClass,
	                                 wPanel, XmNshowValue, TRUE,
									 XmNminimum, 0,
									 XmNmaximum, 999,
									 XmNscaleHeight, 20,
									 XmNscaleWidth, WND_WIDTH,
									 XmNx, 5, XmNy, 200,
									 XmNorientation, XmHORIZONTAL,
									 XmNtitleString, xsTitle,
									 NULL);
	XmStringFree( xsTitle );
	
	XtAddCallback( wScale, XmNdragCallback, DoNothingCallback, NULL);
	
	/*----------------------------------*/
	/*       Create Yes Labels          */
	/*----------------------------------*/
    Xo = ((WND_WIDTH / 2) - (100 / 2) + 1) - 25;
	Yo = WND_HEIGHT / 4 * 3;
	xsTemp = XmStringCreateLtoR( "Yes:", XmFONTLIST_DEFAULT_TAG);
	XtVaCreateManagedWidget("YesStaticLabel",
	                                        xmLabelWidgetClass, wPanel,
											XmNlabelString, xsTemp,
											XmNx, Xo, XmNy, Yo,
											NULL);
	XmStringFree(xsTemp);

	Xo += 40;
	xsTemp = XmStringCreateLtoR( "0", XmFONTLIST_DEFAULT_TAG);
	wYesCount = XtVaCreateManagedWidget("YesCount",
	                                        xmLabelWidgetClass, wPanel,
											XmNlabelString, xsTemp,
											XmNx, Xo, XmNy, Yo,
											NULL);
	XtManageChild( wYesCount );
	XmStringFree(xsTemp);

	/*----------------------------------*/
	/*        Create No Labels          */
	/*----------------------------------*/
    Xo = ((WND_WIDTH / 2) + (100 / 2) + 1) - 25;
	Yo = WND_HEIGHT / 4 * 3;
	xsTemp = XmStringCreateLtoR( "No:", XmFONTLIST_DEFAULT_TAG);
	XtVaCreateManagedWidget("NoStaticLabel",
	                                        xmLabelWidgetClass, wPanel,
											XmNlabelString, xsTemp,
											XmNx, Xo, XmNy, Yo,
											NULL);
	XmStringFree(xsTemp);
	
	Xo += 40;
	xsTemp = XmStringCreateLtoR( "0", XmFONTLIST_DEFAULT_TAG);
	wNoCount = XtVaCreateManagedWidget("NoCount",
	                                        xmLabelWidgetClass, wPanel,
											XmNlabelString, xsTemp,
											XmNx, Xo, XmNy, Yo,
											NULL);
	XtManageChild( wNoCount );
	XmStringFree(xsTemp);
	
	/*----------------------------------*/
	/*       Create Text Field          */
	/*----------------------------------*/
	g_sQuestion[0] = '\0'; /* In case junk exists...this makes the string len = 0 */

	xsTemp = XmStringCreateLtoR( "Type in a question to ask:", XmFONTLIST_DEFAULT_TAG);
	XtVaCreateManagedWidget("QuestionStaticLabel",
	                                        xmLabelWidgetClass, wPanel,
											XmNlabelString, xsTemp,
											XmNx, 5, XmNy, 30,
											NULL);
	XmStringFree(xsTemp);

	wTextField = XtVaCreateManagedWidget( "TextField", xmTextWidgetClass, wPanel, 
	                                      XmNx, 5, XmNy, 50, 
										  XmNwidth, WND_WIDTH,
	                                      NULL);
    XtManageChild( wTextField );

	XtAddCallback( wTextField, XmNmodifyVerifyCallback, TextModifiedCallback, NULL);
	XtAddCallback( wTextField, XmNmodifyVerifyCallback, TextMotionCallback,   NULL);
    XtAddCallback( wTextField, XmNfocusCallback,        TextFocusCallback,    NULL);


	/*----------------------------------*/
	/*       Create Message Label       */
	/*----------------------------------*/
    xsTemp = XmStringCreateLtoR( " ", XmFONTLIST_DEFAULT_TAG);
    wMessageLabel = XtVaCreateManagedWidget("MessageLabel",xmLabelWidgetClass, wPanel,
											XmNlabelString, xsTemp,
											XmNx, 5, XmNy, 130,
											XmNwidth, WND_WIDTH,
											NULL);
	XmStringFree(xsTemp);
	
	/*----------------------------------------*/
	/*    Create Countdown Message Label      */
	/*----------------------------------------*/
    xsTemp = XmStringCreateLtoR( " ", XmFONTLIST_DEFAULT_TAG);
    wCountdownLabel = XtVaCreateManagedWidget("CountdownLabel",xmLabelWidgetClass, wPanel,
											XmNlabelString, xsTemp,
											XmNx, 5, XmNy, 90,
											XmNwidth, WND_WIDTH,
											NULL);
	XmStringFree(xsTemp);

	/*---------------------------------------------*/
	/* Realize the Shell Widget to the Application */
	/*---------------------------------------------*/
	DisplayMessage("Realizing Shell Widget...");
	XtRealizeWidget(wShell);

	return(TRUE);
}


/*---------------------------------------------------------*/
/* Name: DoNothingCallback()                               */
/*                                                         */
/* Description: Dummy Callback for doing nothing           */
/*                                                         */
/*---------------------------------------------------------*/
static void DoNothingCallback(Widget w, XtPointer clientData, XtPointer callData)
{
	return;
}


/*---------------------------------------------------------*/
/* Name: TextMotionCallback()                              */
/*                                                         */
/* Description: Handles preventing the user from typing    */
/*              in a text field if a Question was already  */
/*              sent and users haven't responded yet.      */
/*                                                         */
/*---------------------------------------------------------*/
static void TextMotionCallback( Widget w, XtPointer clientData, XtPointer callData )
{
	XmTextVerifyCallbackStruct *cbs = (XmTextVerifyCallbackStruct *) callData;

	if(bQueryInProgress == TRUE)
	{
		cbs->doit = FALSE;
		DisplayMessage("The question has already been sent.\nPlease wait until all users have responded\nbefore sending a new question.", INSTRUCTOR);
	}
}

/*---------------------------------------------------------*/
/* Name: TextModifiedCallback()                            */
/*                                                         */
/* Description: Handles moving the text as it is typed     */
/*              in a text field into a variable.           */
/*              Note: Only if users aren't still responding*/
/*              to a question sent.                        */
/*                                                         */
/*---------------------------------------------------------*/
static void TextModifiedCallback( Widget w, XtPointer clientData, XtPointer callData )
{
	int nIndex;

	XmTextVerifyCallbackStruct *cbs = (XmTextVerifyCallbackStruct *) callData;

	if((bQueryInProgress == TRUE) || (cbs->text->ptr == NULL))
	{
		cbs->doit = FALSE;
	}
	else
	{
		nIndex = strlen(g_sQuestion);
        if (nIndex < 255)
		{
			g_sQuestion[nIndex++] = cbs->text->ptr[0];
			g_sQuestion[nIndex] = '\0';
		}
		else
		{
			cbs->doit = FALSE;
			DisplayMessage("The question is limited to 255 characters max!", INSTRUCTOR);
		}
	}
}

/*---------------------------------------------------------*/
/* Name: TextFocusCallback()                               */
/*                                                         */
/* Description: Called when the Text Field Gets Focus      */
/*                                                         */
/*---------------------------------------------------------*/
static void TextFocusCallback( Widget w, XtPointer clientData, XtPointer callData )
{
	g_nActive = TRUE;
}

/*---------------------------------------------------------*/
/* Name: SendButtonCallback()          (INSTRUCTOR WINDOW) */
/*                                                         */
/* Description: This function is called when an            */
/*              instructor clicked on the Send Button      */
/*              on the Instructor window.                  */
/*---------------------------------------------------------*/
static void SendButtonCallback( Widget w, XtPointer clientData, XtPointer callData)
{
    int		 bValidAnswer = FALSE;	
	char     sValue[255];
	XmString xsValue[255];

	g_nActive = TRUE;

	if (bQueryInProgress == FALSE)
	{
		/* If Instructor entered a question... */
		if (strlen(g_sQuestion) > 0)
		{
			g_nTotalResponses = 0;
			g_nYesCount       = 0;
			g_nNoCount        = 0;
			g_nMinutesLeft    = atoi(sTimeLimit);
			g_nMinutesLeft--;
			g_nSecondsLeft    = 60;

			bQueryInProgress = TRUE;

			UpdateMessageLabel("=Waiting for Responses=");

			UpdateScale(g_nTotalResponses, g_nUsers);

			ListenForConnections();
		}
		else
		{
			DisplayMessage("You must type in a question before pressing 'Send'!", INSTRUCTOR, TRUE);
		}
	} /* end if users remaining */

	if(bInstructorIsQuitting == TRUE)
	{
		PrintMessage("SEND BUTTON: Closing server...\n");
		close(tsi.sd);

		PrintMessage("SEND BUTTON: Exiting Application...\n");
		exit(0);
		return;
	}
}

/*---------------------------------------------------------*/
/* Name: QuitButtonCallback()   (USER & INSTRUCTOR WINDOW) */
/*                                                         */
/* Description: This function is called when a user/       */
/*              instructor clicked on the Quit Button      */
/*              on the User or Instructor windows.         */
/*---------------------------------------------------------*/
static void QuitButtonCallback( Widget w, XtPointer clientData, XtPointer callData)
{
	int rc, nStatus;
	int i;

	PrintMessage("Quit Button Pressed!\n");

	
	if(bQueryInProgress == TRUE)
	{
		DisplayMessage("You must wait until the survey is over before you can Quit!\n", FALSE);
		return;
	}
	else
	{
		bInstructorIsQuitting = TRUE;

		PrintMessage("QUIT BUTTON: Closing server...\n");
		close(tsi.sd);

		PrintMessage("QUIT BUTTON: Exiting Application...\n");
		exit(0);
		return;
	}
}

/*---------------------------------------------------------*/
/* Name: DisplayMessage()                                  */
/*                                                         */
/* Description: This function will create and display a    */
/*              pop-up window with a message to a user or  */
/*              instructor                                 */
/*                                                         */
/* Parameters:  sMessage - the message to display.         */
/*---------------------------------------------------------*/
DisplayMessage(char* sMessage, int bModal)
{
	XmString xsMessage;

    if((wShell == NULL) || (g_nActive == FALSE)) 
	{
		printf("%s\n", sMessage);
	}
	else
	{		
        MessageBox(sMessage, bModal);
	}
}

/*---------------------------------------------------------*/
/* Name: MessageBox()         (USER & INSTRUCTOR WINDOWS)  */
/*                                                         */
/* Description: This function is called by DisplayMessage()*/
/*              only when there is a Parent Window visible */
/*              to handle the MessageBox as a child.       */
/*              This function will create a message box to */
/*              display a message to the user.             */
/*---------------------------------------------------------*/
MessageBox(char* sMessage, int bModal)
{
	XmString xsMessage;
	XmString xsTitle;
	
	Widget   wMessageBox;
	
	char sTemp[255];
	
	/*----------------------------------*/
	/*   Create Bulletin Board Dialog   */
	/*----------------------------------*/
	sprintf(sTemp, "MB");
	wMessageBox = (Widget) XmCreateWarningDialog(wShell, "name", NULL, 0);
	xsTitle = XmStringCreateLtoR( "survey2", XmFONTLIST_DEFAULT_TAG);
	
	if(bModal==TRUE)
	{
		XtVaSetValues(wMessageBox, 
					XmNdialogTitle, xsTitle,
					XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL,
					XtVaTypedArg, XmNmessageString, XmRString,
					sMessage, strlen(sMessage) + 1,
					NULL);
		XBell(hUDisplay,0);
	}
	else
	{
		XtVaSetValues(wMessageBox, 
					XmNdialogTitle, xsTitle,
					XmNdialogStyle, XmDIALOG_MODELESS,
					XmNautoUnmanage, TRUE,
					XtVaTypedArg, XmNmessageString, XmRString,
					sMessage, strlen(sMessage) + 1,
					NULL);
	}

	XtManageChild( wMessageBox );
	
	if(bModal==TRUE)
	{
		while( XtIsManaged (wMessageBox) )
		{
			XEvent event;
			XtAppNextEvent(XtWidgetToApplicationContext(wMessageBox), &event);
			XtDispatchEvent(&event);
		}
		XtDestroyWidget(wMessageBox);
	}
	else
	{
		HandlePendingEvents(XtWidgetToApplicationContext(wMessageBox));
	}
}

/*---------------------------------------------------------*/
/* Name: UpdateMessageLabel()  (USER & INSTRUCTOR WINDOWS) */
/*                                                         */
/* Description: This function is called when a message     */
/*              is to be displayed, but not in a message   */
/*              box.  This thought originally was to make  */
/*              a dialog appear and PopDown() automatically*/
/*              but this was extra, and since it was taking*/
/*              too long to develop, I fell for a simpler  */
/*              method for now.                            */
/*---------------------------------------------------------*/
UpdateMessageLabel(char *sMessage)
{
	XEvent event;
	XmString xsTemp;
	int      i;
    char     sTemp[100] = " ";
	
	int nExtraPadding = (45 / 2) - (strlen(sMessage) / 2) + 1;
	
    for(i=0; i<nExtraPadding; i++)
	{
		strcat(sTemp, " ");
	}
    strcat(sTemp, sMessage);
	xsTemp = XmStringCreateLtoR( sTemp, XmFONTLIST_DEFAULT_TAG);
	XtVaSetValues(wMessageLabel, 
				XmNlabelString, xsTemp,
				NULL);

	XmStringFree(xsTemp);

	HandlePendingEvents(XtWidgetToApplicationContext(wMessageLabel));
}

/*---------------------------------------------------------*/
/* Name: UpdateCountdownLabel()        (USER & INSTRUCTOR) */
/*                                                         */
/* Description: This function is called when a message     */
/*              is to be displayed, but not in a message   */
/*              box.  This thought originally was to make  */
/*              a dialog appear and PopDown() automatically*/
/*              but this was extra, and since it was taking*/
/*              too long to develop, I fell for a simpler  */
/*              method for now.                            */
/*---------------------------------------------------------*/
UpdateCountdownLabel(int nMinutesLeft, int nSecondsLeft)
{
	XEvent event;
	XmString xsTemp;
	int      i, nExtraPadding;
    char     sTemp[100], sMessage[100];

	if(nSecondsLeft<10)
	{
		sprintf(sMessage, "Time Remaining: %d:0%d ", nMinutesLeft, nSecondsLeft);
	}
	else
	{
		sprintf(sMessage, "Time Remaining: %d:%d ", nMinutesLeft, nSecondsLeft);
	}

	nExtraPadding = (45 / 2) - (strlen(sMessage) / 2) + 1;
	
	strcpy(sTemp, " ");
    for(i=0; i<nExtraPadding; i++)
		strcat(sTemp, " ");
	
    strcat(sTemp, sMessage);
	xsTemp = XmStringCreateLtoR( sTemp, XmFONTLIST_DEFAULT_TAG);
	XtVaSetValues(wCountdownLabel, XmNlabelString, xsTemp, NULL);

	XmStringFree(xsTemp);

	HandlePendingEvents(XtWidgetToApplicationContext(wCountdownLabel));
}

/*---------------------------------------------------------*/
/* Name: HandlePendingEvents()  (USER & INSTRUCTOR WINDOWS)*/
/*                                                         */
/* Description: This function is called when refreshing is */
/*              needed allowing parts of windows that need */
/*              messages processed right away.             */
/*              This will process ALL messages on the      */
/*              queue for that widget (app can also be a   */
/*              widget if using the function...            */
/*              XtWidgetToApplicationContext() .           */
/*---------------------------------------------------------*/
HandlePendingEvents( XtAppContext app )
{
	XEvent event;

	if((strcmp(sProcessName, "LISTENER")==0)||
	   (strcmp(sProcessName, "MAIN")==0))
	{
		while(XtAppPending(app))
		{
			XtAppNextEvent(app, &event);
			XtDispatchEvent(&event);
		}
	}
	else
	{
		sleep(1);
	}
}

/*---------------------------------------------------------*/
/* Name: UpdateStatFields()   (USER & INSTRUCTOR WINDOWS)  */
/*                                                         */
/* Description: This function is called when fields on a   */
/*              user/instructor window needs to be updated */
/*              This is NOT a callback function.           */
/*                                                         */
/*---------------------------------------------------------*/
UpdateStatFields()
{
	char *sLabel;
    char *sValue;
	int  nTemp, nValue;
    
	/*for(tuid=0; tuid < g_nUsers; tuid++)
	{	if (g_nActive[tuid] == TRUE)
		{
		*/
			/* Sets the Yes Count */
			sprintf(sTemp, "%d", g_nYesCount);
			xsTemp = XmStringCreateLtoR( sTemp, XmFONTLIST_DEFAULT_TAG);		
			XtVaSetValues(wYesCount, XmNlabelString, xsTemp, NULL);
			XmStringFree(xsTemp);
			
			/* Sets the No Count */
			sprintf(sTemp, "%d", g_nNoCount);
			xsTemp = XmStringCreateLtoR( sTemp, XmFONTLIST_DEFAULT_TAG);
			XtVaSetValues(wNoCount, XmNlabelString, xsTemp, NULL);
			XmStringFree(xsTemp);
						
			/* Sets the Scale to the Number Remaining */
			UpdateScale(g_nTotalResponses, g_nUsers);
		/*}	
	}*/
}


/*---------------------------------------------------------*/
/* Name: UpdateScale()                                     */
/*                                                         */
/* Description: This function updates the scale widget's   */
/*              value for both User and Instructor Windows.*/
/*---------------------------------------------------------*/
UpdateScale(int nNewValue, int nNewMaxValue)
{
	XtVaSetValues(wScale, XmNvalue,   nNewValue,    NULL);
	XtVaSetValues(wScale, XmNmaximum, nNewMaxValue, NULL);
}

/*---------------------------------------------------------*/
/* Name: InitTcpServer()                                   */
/*                                                         */
/* Description: This function initializes the server by    */
/*              getting the host information, address, and */
/*              socket for sending and receiving.  It also */
/*              binds the socket to the address.           */
/*---------------------------------------------------------*/
int InitTcpServer()
{
	int nThisPort;

	tsi.sp = getservbyname("echo", "tcp"); /* Gets Local Tcp Echo Service Name */

	/* Verify Host Information, NAME, and INET ADDRESS */

	/* Look up our host's network address */
	if( (tsi.hp = gethostbyname(tsi.sThisHost)) == NULL)
	{
		fprintf(stderr, "Can't find host %s\n", tsi.sThisHost);
		exit(-1);
	}

	bcopy( tsi.hp->h_addr, &(tsi.server.sin_addr), tsi.hp->h_length);
	printf("   (TCP/Server INET ADDRESS is: %s )\n", inet_ntoa(tsi.server.sin_addr));

	/* Construct Address of server socket to send to. */
	tsi.server.sin_family = tsi.hp->h_addrtype; /* server.sin_family = AF_INET; */

	tsi.server.sin_addr.s_addr = htonl(INADDR_ANY); /* host to network long */

	nThisPort = atoi(tsi.sThisPort);

	tsi.server.sin_port = htons((u_short) nThisPort); /* Port 0 tells host to find first */
			   /* available port and assign it   OR server.sin_port = sp->s_port;*/
	
	/* Create socket on which to send and receive */
	tsi.sd = socket (tsi.hp->h_addrtype, SOCK_STREAM, 0); /* sd = socket (PF_INET, SOCK_DGRAM, 0); */

	if(tsi.sd < 0)
	{
		perror("opening stream socket");
		exit(-1);
	}

	/* Bind the Socket to the Address */
	if(bind( tsi.sd, &(tsi.server), sizeof((tsi.server)) ) < 0)
	{
		close(tsi.sd);
		perror("binding name to stream socket");
		exit(-1);
	}

	tsi.length = sizeof(tsi.server);
	if( getsockname( tsi.sd, &(tsi.server), &(tsi.length) ) < 0)
	{
		perror("getting socket name");
		exit(0);
	}

	printf("Server Port is: %d\n", ntohs(tsi.server.sin_port));
}

/*-------------------------------------------------------------------*/
/* Name: ListenForConnections()     "LISTENER","ACCEPTOR","RECEIVER" */
/*                                                                   */
/* Description: This function listens for incoming new               */
/*              incoming requests from clients and accepts           */
/*              them.                                                */
/*-------------------------------------------------------------------*/
int ListenForConnections()
{
	fd_set read_template;
    int rc, nStatus, wrc, nBytesRead;
	char line[MAX_PACKET_SIZE];

	strcpy(sProcessName, "LISTENER\0");
	/*PrintMessage("LISTENER: Entering ListenForConnections()...\n");*/
	/*-----------------------------------------------------------*/
	/* Tells OS that we are ready to start accepting connections */
	/* on this socket (with a backup of up to 5)                 */
	/*-----------------------------------------------------------*/
	if(rc = listen(tsi.sd, 5) < 0)
	{
		perror("listen");
		return FALSE;
	}

	/*--------------------------------------------------------------*/
	/* Create a Pipe for next fork child process to talk back to us */
	/*--------------------------------------------------------------*/
	if( socketpair( PF_UNIX, SOCK_STREAM, 0, tsi.sockets1) < 0 )
	{
		perror("socketpair failed");
		exit(1);
	}
	
	/*--------------------------------------------------------------*/
	/* Create a Pipe for next fork child process to talk back to us */
	/*--------------------------------------------------------------*/
	if( socketpair( PF_UNIX, SOCK_STREAM, 0, tsi.sockets2) < 0 )
	{
		perror("socketpair failed");
		exit(1);
	}
	
	/*-----------------------------------------------------------*/
	/* At this point, the pid will contain the childs process id */
	/* that the parent can use to communicate                    */
	/* (Note: If the child process clone, the pid = 0 )          */
	/* -- This will only get set once as ListenForConnections()  */
	/* -- can only be called once per survey                     */
	/*-----------------------------------------------------------*/
	pid = fork();
	if(pid == 0 ) /* New Child Process */
	{
		strcpy(sProcessName, "ACCEPTOR\0");
	
		/*PrintMessage("ACCEPTOR: Cloned fork started...\n");*/
		/*--------------------------------------------------------------------------------------------*/
		/* Here's what's happening:                                                                   */
		/* - The for loop is in a child process which means that this is the ACCEPTOR LOOP            */
		/* - There is only ONE ACCEPTOR LOOP ever                                                     */
		/* - The ACCEPTOR LOOP manages all child pids for childs that deal with clients               */
		/* - The ACCEPTOR LOOPS responsibility is to pass messages between the child and the main loop*/
		/*   so that the interface can update the fields on the screen and instruct the ACCEPTOR to   */
		/*   report totals to all childs who then report totals to their client apps                  */
		/*                                                                                            */
		/* - To communicate with the main loop, messages will be passed via tsi.sockets1,2 pairs      */
		/* - To communicate with a child, messages will be passed via                                 */
		/*                                                  hProcessInfo[nNumberOfUsers].socketsP1,2  */
		/*--------------------------------------------------------------------------------------------*/
		for(;;)
		{	
			/*--------------------------------------------------*/
			/* Step A1 - Check for a waiting Client Application */ /* ACCEPTOR */
			/*--------------------------------------------------*/
			if(strcmp(sProcessName, "ACCEPTOR")==0)
			{
				printf("ACCEPTOR: Waiting...\n");

				tsi.psd = AcceptIfAvailable(tsi.sd, &(tsi.server), &(tsi.length)); /* Accept Request To Socket sd */
			}
			else
			{
				printf("Error Occurred...tried to Accept when not ACCEPTOR!\n");
			}
			                                                                       /* & use Socket psd            */
			/*-----------------------------------------------------------*/
			/* Step A1a - If no clients, then loop back to the top again */
			/*-----------------------------------------------------------*/
			if(tsi.psd < 0) 
			{
				sprintf(sMessage, "%s: Error#%d -- No Valid Connection Found Yet!\n", sProcessName, errno);
				PrintMessage(sMessage);
			}
			else 
			if(tsi.psd == 0)
			{
				sprintf(sMessage, "%s: No New Connections Found...\n", sProcessName);
				PrintMessage(sMessage);
			}
			else
			{
				/* Let's just dump the pid into an array for safe keeping for now */
				nNumberOfUsers++;
				
				/*------------------------------------------------------------------------*/
				/* Step A2 - Create a Pipe for next fork child process to talk back to us */
				/*------------------------------------------------------------------------*/
				if( socketpair( PF_UNIX, SOCK_STREAM, 0, hProcessInfo[nNumberOfUsers].socketsP1) < 0 )
				{
					perror("socketpair failed");
					exit(1);
				}
				
				if( socketpair( PF_UNIX, SOCK_STREAM, 0, hProcessInfo[nNumberOfUsers].socketsP2) < 0 )
				{
					perror("socketpair failed");
					exit(1);
				}
				
				/* By this time, it's safe to say the Client Window is active and open to communication */
				hProcessInfo[nNumberOfUsers].nActive = TRUE;
				
				/* Note: The pid is still preserved in the original */
				/*       process so it's ok to reuse this variable  */		
				/* The Child pid is == 0, the Parent > 0, an error < 0 */

				/*------------------------------------------------------------------------*/
				/* Step A3 - Clone the Parent so the Parent can look for more connections */
				/*          and the child process can deal with the new single user       */
				/*          (This clone is the "RECEIVER" of client app recvs.)           */
				/*------------------------------------------------------------------------*/
				pid = fork();
				if(pid == 0) /* New Child Process */
				{
					sprintf(sProcessName, "RECVR%d\0", nNumberOfUsers);
					
					sprintf(sMessage, "%s: Cloned receiver fork started (psd=%d)...\n", sProcessName, tsi.psd);
					PrintMessage(sMessage);
									
					
					RListenForPackets(); /* until a quit is signaled */
					        /* Use hProcessInfo[tsi.pid].socketsP1[1] to send a quit message to this child */
					        /* Use hProcessInfo[tsi.pid].socketsP2[2] to recv a message from this child */
					
					break;
				}
				else
				if(pid > 0) /* Parent Process */
				{
					sprintf(sMessage, "%s: New Child was spawned (%d) psd=%d\n", sProcessName, pid, tsi.psd);
					PrintMessage(sMessage);

					/* We don't want to wait since the loop will look for more processes */
					/* Wait for Child Processes -- This will be called immediately */
					/*                             while the 2nd forked process starts */
					
					/* Let's just dump the pid into an array for safe keeping for now */
					hProcessInfo[nNumberOfUsers].pid = pid;
					hProcessInfo[nNumberOfUsers].psd = tsi.psd;
				
					/* Notify Listener so Listener can update the screen */
					strcpy(line, "New User");				
					write(tsi.sockets2[1], line, sizeof(line));	/* this should send 'quit' when needed */
	
					sleep(1);
			
				}
				else
				if(pid < 0) /* Error Occurred */
				{
					sprintf(sMessage, "%s: Cloned receiver fork failed...%d\n", sProcessName, pid);
					PrintMessage(sMessage);
					
					break;
				}
				
			}	/* end else if */
			
			/* The rest is ACCEPTOR only code -- the Child will break earlier */

			/*--------------------------------------------------------------------------*/
			/* STEP A4                         CHILD --> ACCEPTOR                       */
			/* This will look to see if there are any messages from the child processes */
			/* like 'quit button pressed' or 'sending yes' or 'sending no'              */
			/*--------------------------------------------------------------------------*/
			AListenToChildProcesses();

			/*-------------------------------------------------------------------*/
			/* STEP A5                         LISTENER --> ACCEPTOR             */
			/* This will listen for a single message from the parent process     */
			/* Listens to sockets1[0] since main/listener will be sending on [1] */
			/* (Anytime the Acceptor receives something on this socket, it will  */
			/*  broadcast the message to all clients)                            */
			/*-------------------------------------------------------------------*/
			nStatus = AListenOnceToParent(tsi.sockets1[0], line);

			if(nStatus == TRUE)
			{
				sprintf(sMessage,"%s: Sending '%s' to all child processes...\n", sProcessName, line);
				PrintMessage(sMessage);
				
				/* Send Message To All Children??? */
				ASendMessageToAllChildProcesses(line);
				
				if(strncmp(line, "quit", 4)==0)
				{
					sprintf(sMessage, "%s: Exiting\n", sProcessName);
					PrintMessage(sMessage);

					break;
				}
			}
		} /* For */
	}
	else
	if(pid > 0) /* Parent Process -- "LISTENER" */
	{
		sprintf(sMessage, "%s: Loops till 'quit' issued -- waiting for ACCEPTOR to end\n", sProcessName);
		PrintMessage(sMessage);

		/*--------------------------------------------------------------------------*/
		/* Wait for Child Processes -- This will be called immediately              */
		/*                             while the 1st forked process starts          */
		/*                                                                          */
		/* Basically, this will talk between the Connection Listener/Motif Main and */
		/* the Acceptor Loop (who manages all other local child processes.          */
		/*                                                                          */
		/*--------------------------------------------------------------------------*/
		wrc = waitpid(pid, &nStatus, WNOHANG); /* Doesn't suspend processing */
		
		/*while((wrc != 0) && (wrc != -1))*/
		while(1)
		{			
			sprintf(sMessage, "%s: Waiting...\n", sProcessName);
			PrintMessage(sMessage);
			printf("%s: Waiting...\n", sProcessName);
			
			sleep(1);

			/* Send Countdown To Users (if any) */
			if(g_nSecondsLeft==60)
			{
				/* TODOTODO */
				if(g_nMinutesLeft==0)
					sprintf(sMessage, "Time Remaining: < 1 Minute\0", g_nMinutesLeft);
				else
				if(g_nMinutesLeft==1)
					sprintf(sMessage, "Time Remaining: 1 Minute\0", g_nMinutesLeft);
				else
					sprintf(sMessage, "Time Remaining: %d Minutes\0", g_nMinutesLeft);
				
				send(tsi.sockets1[1], sMessage, strlen(sMessage)+1, 0);
			}

			/* Decrements Counter 1 second adjusting Minutes if needed */
			g_nSecondsLeft--;
			UpdateCountdownLabel(g_nMinutesLeft, g_nSecondsLeft);
			
			if(g_nSecondsLeft==0)
			{
				if(g_nMinutesLeft==0)
				{
					printf("TIMEOUT OCCURRED!\n");

					sprintf(sMessage, "Results:\n\n  # of Yes Answers: %d\n  # of No Answers: %d\n  Total # of Users: %d\n\0",
						               g_nYesCount, g_nNoCount, g_nUsers);
					send(tsi.sockets1[1], sMessage, strlen(sMessage)+1, 0);

					sleep(1);

					strcpy(sMessage, "quit\0");
					send(tsi.sockets1[1], sMessage, strlen(sMessage)+1, 0);

					bQueryInProgress=FALSE;

					UpdateMessageLabel("=Survey has Ended=");

					break;
				}
				else
				{
					g_nSecondsLeft=60;
					g_nMinutesLeft--;
				}
			}
			

			/* STEP 1 - Handle Paint Events, etc for Interface */
			HandlePendingEvents(hTheApp); /* Let's the GUI part of the program keep running */
			
			/*----------------------------------------------------------------*/
			/* STEP 2 -                            ACCEPTOR -> LISTENER       */
			/* Receive Packet from SockPair connection to Acceptor            */
			/*                                                                */
			/* Peeks to see if Parent Process is trying to send something and */
			/* reads if it is                                                 */
			/*----------------------------------------------------------------*/
			rc = RecvIfAvailable(tsi.sockets2[0], line, MAX_PACKET_SIZE);
			
			if(rc == TRUE)				
			{								
				sprintf(sMessage, "%s: line read at pid %d = %s\n", sProcessName, pid, line);
				PrintMessage(sMessage);
				
				printf("%s: line read at pid %d = %s\n", sProcessName, pid, line);
				
				/* Here we need to check what is being sent back: Yes, No... */
				if(strncmp(line,"Yes", 3)==0)
				{
					printf("Yes Answered!\n");
					g_nYesCount++;
					g_nTotalResponses++;
				}

				if(strncmp(line,"No",2)==0)
				{
					printf("No Answered!\n");
					g_nNoCount++;
					g_nTotalResponses++;
				}

				if(strncmp(line,"Unanswered",10)==0)
				{
					printf("Un-Answered!\n");
					g_nTotalResponses++;
				}

				if(strncmp(line,"New User",8)==0)
				{
					printf("New User!\n");
					g_nUsers++;

					/* Send Countdown To Users (if any) */
					sprintf(sMessage, "Time Remaining: %d Minutes\0", g_nMinutesLeft);
					send(tsi.sockets1[1], sMessage, strlen(sMessage)+1, 0);
					

				}

				/* And Update the Scale and Stat Fields */
				UpdateStatFields();
				UpdateScale(g_nTotalResponses, g_nUsers);
			}
			
			/*------------------------------------------------------------------*/
			/* STEP 3 - If Instructor hit the Quit Button, then send message to */
			/*          Acceptor and let the Acceptor worry about notifying the */
			/*          other processes                                         */
			/*------------------------------------------------------------------*/
			if(bInstructorIsQuitting == TRUE)
			{
				/*-------------------------------------------------------------*/
				/* Send the quit message to the child who manages all polling  */
				/* (LISTENER -> ACCEPTOR)                                      */
				/*-------------------------------------------------------------*/
				strcpy(line, "quit");
				
				write(tsi.sockets1[1], line, strlen(line)+1);	/* this should send 'quit' when needed */
															/* to stop all children down the line */
				sleep(1);

				break; /* break from while loop */
			}	

			/*-------------------------------------------------------------------*/
			/* STEP 4 - Check if Counter Expired, and send messages to all users */
			/*          then send a quit to the ACCEPTOR to end it and all       */
			/*          of it's child processes                                  */
			/*-------------------------------------------------------------------*/
		} /* end while */

		sprintf(sMessage, "%s: Listener is exiting...\n");
		PrintMessage(sMessage);

	}		
	else 
	if(pid < 0) /* Error Occurred */
	{
		printf("%s: Cloned fork failed...%d\n", sProcessName, pid);
	}
		
	/* If Process Isn't the LISTENER, then end the process... */
	if(strcmp(sProcessName, "LISTENER")!=0)
	{
		exit(0);
	}
}


/*-------------------------------------------------------------------*/
/* Name: AListenToChildProcesses()                "ACCEPTOR" ONLY!   */
/*                                                                   */
/* Description: This function listens to see if any RECEIVER child   */
/*              processes are trying to send something and handles   */
/*              what to do with it.                                  */
/*-------------------------------------------------------------------*/
int AListenToChildProcesses()
{
	int		i, rc; 
	char	line[MAX_PACKET_SIZE];

	for(i=1; i <= 9; i++)
	{
		if(hProcessInfo[i].nActive == TRUE) /* If Client App is still running... */
		{
			/*printf("%s: Checking child#%d for incoming message...\n", sProcessName, i);*/
			rc = RecvIfAvailable(hProcessInfo[i].socketsP2[0], line, MAX_PACKET_SIZE);

			if(rc == TRUE) /* We Received Something!!! */
			{
				sprintf(sMessage, "%s: line read at pid %d; user#%d; psd=%d;  line= %s\n", sProcessName, hProcessInfo[i].pid, hProcessInfo[i].psd, i, line);
				PrintMessage(sMessage);

				printf("%s: line read at pid %d = %s\n", sProcessName, hProcessInfo[i].pid, line);

				/* Send the message to the next child */
				/*write(hProcessInfo[i].socketsP[1], line, sizeof(line));	/* this should send 'quit' when needed */
												/* to stop all children down the line */

				if(strncmp(line, "user quitting", 13)==0)
				{
					hProcessInfo[i].nActive = FALSE; /* Marks this user as not active anymore */

					write(hProcessInfo[i].socketsP1[1], "quit", MAX_PACKET_SIZE); /* Tells child to quit */
				}


				/* If we receive something the LISTENER needs to know about... */
				if((strncmp(line,"Yes", 3)==0) ||
				   (strncmp(line,"No",2)==0)   ||
				   (strncmp(line,"Unanswered",10)==0))
				{
					write(tsi.sockets2[1], line, MAX_PACKET_SIZE); /* sends to child */
				}
/*
				if(strncmp(line,"No",2)==0)
					write(tsi.sockets2[1], line, MAX_PACKET_SIZE); /* sends to child */
/*
				if(strncmp(line,"Unanswered",10)==0)
					write(tsi.sockets2[1], line, MAX_PACKET_SIZE); /* sends to child */
			}
		}
	}
}


/*-------------------------------------------------------------------*/
/* Name: ASendMessageToAllChildProcesses()        "ACCEPTOR" ONLY!   */
/*                                                                   */
/* Description: This function broadcasts a message to all RECEIVER   */
/*              child processes (who will then pass it on to the     */
/*              CLIENT APPs                                          */
/*-------------------------------------------------------------------*/
int ASendMessageToAllChildProcesses(char *line)
{
	int	i, rc, nStatus;

	for(i=1; i <= nNumberOfUsers; i++)
	{
		sprintf(sMessage, "%s: BROADCAST: User#%d...%s\n", sProcessName, i, line);
		PrintMessage(sMessage);

		if(hProcessInfo[i].nActive == TRUE) /* If Client App is still running... */
		{
			/* Send the message to the next child */
			send(hProcessInfo[i].socketsP1[1], line, strlen(line) + 1, 0);	/* this should send 'quit' when needed */
												/* to stop all children down the line */
			sprintf(sMessage, "%s: BROADCAST: Message sent!\n", sProcessName);
			PrintMessage(sMessage);
		}
	}
	return TRUE;
}


/*-------------------------------------------------------------------*/
/* Name: AListenOnceToParent()                    "ACCEPTOR" ONLY!   */
/*                                                                   */
/* Description: This function listens to see if the LISTENER is      */
/*              trying to send something
/*-------------------------------------------------------------------*/
int AListenOnceToParent(int socket, char *line)
{
	int		i, rc; 
	
	rc = RecvIfAvailable(socket, line, MAX_PACKET_SIZE);

	if(rc == TRUE) /* We Received Something!!! */
	{
		sprintf(sMessage, "%s: AListenOnceToParent: LISTENER is sending message to ACCEPTOR...%s\n", sProcessName, line);
		PrintMessage(sMessage);
	}

	return rc;	
}


/*---------------------------------------------------------*/
/* Name: AcceptIfAvailable()             "ACCEPTOR" ONLY!  */
/*                                                         */
/* Description: This function will check for a new         */
/*              connection request from CLIENT apps        */
/*              (Non-Blocking Version)                     */
/*---------------------------------------------------------*/
int AcceptIfAvailable(int sd, int *server, int *length)
{
	fd_set	read_template;
	int		nStatus;
	int     sd_child;

	struct timeval TimeVal;
		TimeVal.tv_sec = TIMEOUT;
		TimeVal.tv_usec = 0;

	FD_ZERO(&read_template);
	FD_SET(sd, &read_template);

	nStatus = select(FD_SETSIZE, &read_template, (fd_set *) 0, (fd_set *) 0, TimeVal); /* Checks for 1 second */

	if(nStatus < 0)
	{
		perror("select error");
		sd_child = -1;
	}
	else
	if(nStatus == 0)
	{
		/* Nothing There */
	
	}
	else
	{
		if(FD_ISSET(sd, &read_template)) /* If There is Someone Waiting to be heard... */
		{
			sd_child = accept(sd, server, length);
			sprintf(sMessage, "%s: Connected to new client...socket=%d\n", sProcessName, sd_child);
			PrintMessage(sMessage);
			printf(sMessage);

			/* Send the Question To the Client App */
			send(sd_child, g_sQuestion, strlen(g_sQuestion)+1, 0);
		}
	}

	FD_CLR(sd, &read_template);
	return sd_child;
}

/*---------------------------------------------------------*/
/* Name: RecvIfAvailable()                                 */
/*                                                         */
/* Description: This function will check to see if anything*/
/*              is waiting to be read from a socket.  If   */
/*              there is something, it reads it and returns*/
/*              TRUE.  Otherwise, returns FALSE.           */
/*---------------------------------------------------------*/
int RecvIfAvailable(int socket, char* line, int nPacketSize)
{
	fd_set	read_template;
	int		nReturnValue, i;
	int		nStatus = -1;

	struct timeval TimeVal;
		TimeVal.tv_sec = 2;
		TimeVal.tv_usec = 1;

	FD_ZERO(&read_template);
  	FD_SET(socket, &read_template);
	
	nStatus = select(FD_SETSIZE, &read_template, (fd_set *) 0, (fd_set *) 0, TimeVal); /* Checks for 2 seconds */
	
    switch(nStatus)
	{
		case 0:
		{
			/* Nothing to Read */
			sprintf(sMessage, "%s:    Nothing to read...\n", sProcessName);
			PrintMessage(sMessage);

			nReturnValue = FALSE;
			break;
		}

		case -1:
		{
			perror("select error");
			nReturnValue = FALSE;
			break;
		}

		default:
		{
			for(i=0; i < sizeof(line); i++)
			{
			   line[i] = '\0'; /* Clears the buffer */
			}

			sprintf(sMessage, "%s:    RECV: Before FD_ISSET...\n", sProcessName);
			/*PrintMessage(sMessage);*/
			
			if(FD_ISSET(socket, &read_template)) /* If There is Someone Waiting to be heard... */
			{
				sprintf(sMessage, "%s:    RECV: Before read...\n", sProcessName);
				/*PrintMessage(sMessage);*/
				
				recv(socket, line, nPacketSize, 0); /* Takes the line off the stack */
			
				sprintf(sMessage, "%s:    RECV: Info read from socket (%d bytes)...%s\n", sProcessName, nPacketSize, line);
				PrintMessage(sMessage);
				
				nReturnValue = TRUE;
				break;
			}
			else
			{
				nReturnValue = FALSE;
				break;
			}
			
		}
	} /* switch */
	FD_CLR(socket, &read_template);
	return nReturnValue;
}


/*---------------------------------------------------------*/
/* Name: RListenForPackets()          USED BY RECEIVER     */
/*                                                         */
/* Description: This function will receive an incoming     */
/*              packet (if there is one) from a client     */
/*              or route packets from it's parent to the   */
/*              client                                     */
/*---------------------------------------------------------*/
void RListenForPackets()
{
	int  nBytesRead;
	char line[255];
	int  rc;

	sprintf(sMessage, "%s: Entering RListenForPackets()...\n", sProcessName);
	PrintMessage(sMessage);
	
	while(1)
	{
		sprintf(sMessage, "%s: Checking for Acceptor Messages...\n", sProcessName);
		PrintMessage(sMessage);

		sleep(1);

		/* STEP 1 - Check if Parent Packets are Being Sent */

		/* Peeks to see if Parent Process is trying to send something */
		/* Read the contents into a buffer (to redirect to childs)    */
		rc = RecvIfAvailable(hProcessInfo[nNumberOfUsers].socketsP1[0], tsi.sInputBuffer, MAX_PACKET_SIZE);
		
		if(rc == TRUE)											
		{															
			sprintf(sMessage, "%s:    RECV: %s\n", sProcessName, tsi.sInputBuffer);
			PrintMessage(sMessage);
			
			/* Send the message to the corresponding child */
			printf("RECEIVER sending message to CLIENT APP...%s\n", tsi.sInputBuffer);

			rc = send(tsi.psd, tsi.sInputBuffer, strlen(tsi.sInputBuffer)+1,0);	/* this should send 'quit' when needed */
												/* to stop all children down the line */
			
			if(strncmp(tsi.sInputBuffer, "quit", 4) == 0)
			{
				sprintf(sMessage, "%s:    Shutting down pid %s...\n", sProcessName, pid);
				PrintMessage(sMessage);
				shutdown(pid);
				break;
			}
		}

		/* STEP 2 - Let the Application have time to handle Motif Events */
		HandlePendingEvents(hTheApp);


		/* STEP 3 - Check to see if Child is Sending */
		sprintf(sMessage, "%s: Checking for Client App Messages (socket=%d)...\n", sProcessName, tsi.psd);
		PrintMessage(sMessage);
		
		rc = RecvIfAvailable(tsi.psd, tsi.sInputBuffer, MAX_PACKET_SIZE);

		if(rc == TRUE)											
		{															
			sprintf(sMessage, "%s:    RECV: %s\n", sProcessName, tsi.sInputBuffer);
			PrintMessage(sMessage);
			/*	if(strncmp(tsi.sInputBuffer, "user quitting - Unanswered", 26) == 0)
				{
					/* Let the ACCEPTOR or LISTENER deal with telling the program */

					/* Sends Message to ACCEPTOR */
			/*		strcpy(line, "Unanswered");
					rc = send(hProcessInfo[nNumberOfUsers].socketsP2[1], line, strlen(line)+1, 0);	/* handles if user didn't answer */
			/*	}
				else
				if(strncmp(tsi.sInputBuffer, "user quitting - Answered  ", 26) == 0)
				{
					/* Let the ACCEPTOR or LISTENER deal with telling the program */
			/*	}
				
				/* Sends Message to ACCEPTOR */
				rc = send(hProcessInfo[nNumberOfUsers].socketsP2[1], tsi.sInputBuffer, strlen(tsi.sInputBuffer)+1, 0);	/* this should send 'quit' when needed */
																						/* to stop all children down the line */
				sprintf(sMessage, "%s:    SEND: Sent message to Acceptor...%s\n",sProcessName, tsi.sInputBuffer);
				PrintMessage(sMessage);	
		}
		
		
		/* STEP 4 - Let the Application have time to handle Motif Events */
		HandlePendingEvents(hTheApp);
	}

	sprintf(sMessage, "%s: Leaving RListenForPackets()...\n", sProcessName);
	PrintMessage(sMessage);
}

/*---------------------------------------------------------*/
/* Name: SendPacketToClient()                              */
/*                                                         */
/* Description: This function will send an outgoing        */
/*              packet to a client.                        */
/*---------------------------------------------------------*/
void SendPacketToClient(char *line)
{
	int  rc;
	
	/* Send the Packet To the Client App */
	if(send(tsi.psd, line, strlen(line)+1, 0) < 0)
	{
		perror("sending stream message");
	}
	else
	{		
		sprintf(sMessage, "%s: Packet sent to client...%s\n", sProcessName, line);
		PrintMessage(sMessage);
	}	
}

/*--------------- OBSOLETE STUFF -----------------------------------------------*/
/*int WaitForChildToEnd(int cpid, int socketpair[])
{
int nStatus;
int wrc;

wrc = waitpid(cpid, &nStatus, WNOHANG); /* Doesn't suspend processing */
		
/*	while((wrc != 0) && (wrc != -1))
{
	sprintf(sMessage, "%s: Waiting for Child to End...\n", sProcessName);
	PrintMessage(sMessage);
	sleep(1);
	
	wrc = waitpid(cpid, &nStatus, WNOHANG); /* Doesn't suspend processing */
	
/*		HandlePendingEvents(hTheApp);
		/* Peeks to see if Parent Process is trying to send something */
		/*nBytesRead = recv(socketpair[0], line, sizeof(line), MSG_PEEK);	/* peeks at the */
																		/* data without */																		/* removing it  */
/*	} /* end while */
/*}
*/

PrintMessage(char *sMessage)
{
	return; /* Remove This line to see detailed output */

	if(strcmp(sProcessName, "LISTENER") == 0)
		return;
	if(strcmp(sProcessName, "ACCEPTOR") == 0)
		return;
	printf(sMessage);
}