//
// TAPSERVER.C
//
// TAP
// File Transfer Data Sharing
// Server Code
// Revision 1.10
//
// 12/28/94   First Created
//
#define INCL_WIN
#define INCL_DOS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <process.h>
#include <os2.h>
#include "tapserve.h"
#include "tapres.h"

//
// PTAPSERVERINFO InitializeServer_TAP(char szVersion[]);
//
// Initializes the TAP Server
//
// Parameters:
// szVersion
//   Server version string, max. 30 characters.
//
// Returns: Pointer to server instance data, or NULL
// on failure.
//
PTAPSERVERINFO InitializeServer_TAP(char szVersion[])
{
PTAPSERVERINFO pTapServerInfo = NULL;

	// Create pTapServerInfo
	pTapServerInfo = malloc(sizeof(TAPSERVERINFO));

	// Did we get back a valid pointer?
	if (pTapServerInfo)
	{
		// Initialize pTapServerInfo
		pTapServerInfo -> cb = sizeof(TAPSERVERINFO);
		pTapServerInfo -> phWritePipe = NULL;
		pTapServerInfo -> lNumPipes = 0;
		pTapServerInfo -> lShutdown = FALSE;
		pTapServerInfo -> lFileOpen = FALSE;

		// Create unowned mutual exclusion semaphore for
		// controlling access to the TAP server
		DosCreateMutexSem(NULL,
								&(pTapServerInfo -> hServerMutex),
								0L,
								FALSE);

		// Initialize version string

		strncpy(pTapServerInfo -> szVersion,
					TAP_SERVER_VERSION,
					sizeof (pTapServerInfo->szVersion) - 1);
				// NUL terminate  (note that strncpy will not NUL terminate when max len is reached)
		pTapServerInfo -> szVersion[sizeof (pTapServerInfo->szVersion) - 1] = '\0';

		// Initialize pTapServerInfo -> tiTapInfo (Pipe packet)

		pTapServerInfo -> tiTapInfo . szFileName [0] = 0;
		pTapServerInfo -> tiTapInfo . lCurrentFileSize = TAP_SIZE_UNKNOWN;
		pTapServerInfo -> tiTapInfo . lCompleteFileSize = TAP_SIZE_UNKNOWN;
		pTapServerInfo -> tiTapInfo . ulFlags = 0;

		// Create pipe update semaphore in set mode
		DosCreateEventSem(NULL,
								&(pTapServerInfo -> hevUpdate),
								0L,
								FALSE);

		// Start server thread
      #ifdef __BORLANDC__
		pTapServerInfo -> tidTAPServer = (TID)
			_beginthread(ServerThread_TAP, 8192, (void *) pTapServerInfo);
      #else
		pTapServerInfo -> tidTAPServer = (TID)
			_beginthread(ServerThread_TAP, NULL, 8192, (void *) pTapServerInfo);
      #endif
	}

	szVersion = szVersion;

	return pTapServerInfo;
}

//
// int DeInitializeServer_TAP(PTAPSERVERINFO pTapServerInfo);
//
// DeInitializes the TAP Server
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
//
// Returns: TRUE on success.
//
int DeInitializeServer_TAP(PTAPSERVERINFO pTapServerInfo)
{
int iRet = TRUE;

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Tell server thread to shutdown,
	// it will take care of freeing memory
	pTapServerInfo -> lShutdown = TRUE;
	iRet = !DosPostEventSem(pTapServerInfo -> hevUpdate);

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// int StartApplication_TAP(PTAPSERVERINFO pTapServerInfo,
//										char *szAppPath,
//										char *szAppParams,
//										char *szAppTitle)
//
// Starts a TAP Application and sets up the TAP Server
// to service the application.
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
// szAppPath
//   Fully qualified application executable specification.
// szAppParams
//   Command line parameters sent to the application.
// szAppTitle
//   Default TAP Application title (for VIO titlebar).
//
// Returns: TRUE on success
//
int StartApplication_TAP(PTAPSERVERINFO pTapServerInfo,
									char *szAppPath,
									char *szAppParams,
									char *szAppTitle)
{
int iRet = TRUE;
char *szParameters;
PROGDETAILS Details;
PTIB ptib;
PPIB ppib;
char szPipeName[CCHMAXPATH];

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Allocate memory for a new pipe
	pTapServerInfo -> lNumPipes ++;
	if (pTapServerInfo -> phWritePipe)
		pTapServerInfo -> phWritePipe = (HFILE *)
				realloc(pTapServerInfo -> phWritePipe,
								(size_t)(pTapServerInfo -> lNumPipes * sizeof(HFILE)));
	else
		pTapServerInfo -> phWritePipe = (HFILE *)
				malloc((size_t)(pTapServerInfo -> lNumPipes * sizeof(HFILE)));

	// Query our environment
	// so we can create a unique
	// pipe name!
	DosGetInfoBlocks(&ptib, &ppib);

	// Create pipe name
	sprintf(szPipeName,
				"\\PIPE\\TapPipe%d_%d_%d",
				ppib -> pib_ulpid,
				ptib -> tib_ptib2 -> tib2_ultid,
				pTapServerInfo -> lNumPipes);

	// Create a new named pipe
	DosCreateNPipe(szPipeName,
						&(pTapServerInfo -> phWritePipe[ pTapServerInfo -> lNumPipes - 1]),
						NP_NOWRITEBEHIND |
						NP_INHERIT |
						NP_ACCESS_DUPLEX,
						NP_NOWAIT |
						NP_TYPE_BYTE |
						1,
						1024,
						8192,
						0);

	// Allow a client to connect
	DosConnectNPipe(pTapServerInfo -> phWritePipe [ pTapServerInfo -> lNumPipes - 1]);

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	// ***
	// Setup for application launch
	// ***

	// Query our environment
	// to pass on to the shell
	DosGetInfoBlocks(&ptib, &ppib);

	// Setup calling data structure
	memset (&Details, 0, sizeof(PROGDETAILS));
	Details.Length          = sizeof(PROGDETAILS);
	Details.progt.progc     = PROG_DEFAULT;
	Details.progt.fbVisible = SHE_VISIBLE;
	Details.pszTitle        = szAppTitle;
	Details.pszExecutable   = szAppPath;
	Details.pszEnvironment  = ppib->pib_pchenv;
	Details.swpInitial.fl   = SWP_ACTIVATE; /* window positioning */
	Details.swpInitial.hwndInsertBehind = HWND_TOP;

	// Add our parameter to the end of the parameter list
	szParameters = (char *) malloc(strlen(szAppParams) + 100);
	sprintf(szParameters, "%s /TAP=%s", szAppParams, szPipeName);

	// Start application
	if (!WinStartApp(NULLHANDLE,
					&Details,
					szParameters,
					NULL,
					SAF_STARTCHILDAPP))
		iRet=FALSE;

	// Free up parameter list
	free((void *) szParameters);

	// Wait for client to connect

	{  ULONG ulMaxRetries = 50;	// Wait no longer than 5 seconds! 
		for (;;) {
			AVAILDATA availData;
			ULONG		 ulDummy;
			ULONG		 ulState;
			DosPeekNPipe (pTapServerInfo -> phWritePipe [ pTapServerInfo -> lNumPipes - 1],
			           	&ulDummy, 0, &ulDummy, &availData, &ulState);

			if (ulState == NP_CONNECTED)
				break;

			if (ulMaxRetries-- == 0)
				return (-1);

			DosSleep (100);
			}
		}

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Write server version 

	{	PTAPPACKET pTapPacket;
		ULONG  ulBytesWritten;
		USHORT usVersionLength = (USHORT)strlen (pTapServerInfo->szVersion);
		USHORT usPacketLength = (USHORT)(sizeof (pTapPacket->versionPacket) + usVersionLength);
		pTapPacket = malloc (usPacketLength);
		pTapPacket->versionPacket.cb = usPacketLength;
		pTapPacket->versionPacket.usFlags = TAP_VERSION;
		pTapPacket->versionPacket.usVersionLength = usVersionLength;
		strcpy (pTapPacket->versionPacket.szVersion, pTapServerInfo->szVersion);
		DosWrite (pTapServerInfo -> phWritePipe [ pTapServerInfo -> lNumPipes - 1],
					pTapPacket, pTapPacket->versionPacket.cb, &ulBytesWritten);
		free (pTapPacket);
		}

	// If a file is currently open we need to send the new pipe a BOF !

	if (pTapServerInfo->lFileOpen) {
		PTAPPACKET pTapPacket;
		ULONG  ulBytesWritten;
		USHORT usFileNameLength = (USHORT)strlen (pTapServerInfo->tiTapInfo.szFileName);
		USHORT usPacketLength = (USHORT)(sizeof (pTapPacket->beginFilePacket) + usFileNameLength);
		pTapPacket = malloc (usPacketLength);
		pTapPacket->beginFilePacket.cb = usPacketLength;
		pTapPacket->beginFilePacket.usFlags = TAP_BOF;
		pTapPacket->beginFilePacket.lCurrentFileSize = pTapServerInfo->tiTapInfo.lCurrentFileSize;
		pTapPacket->beginFilePacket.lCompleteFileSize = pTapServerInfo->tiTapInfo.lCompleteFileSize;
		pTapPacket->beginFilePacket.usFileNameLength = usFileNameLength;
		strcpy (pTapPacket->beginFilePacket.szFileName, pTapServerInfo->tiTapInfo.szFileName);
		DosWrite (pTapServerInfo -> phWritePipe [ pTapServerInfo -> lNumPipes - 1],
					pTapPacket, pTapPacket->beginFilePacket.cb, &ulBytesWritten);
		free (pTapPacket);
		}

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// int SelectApplication_TAP(PTAPSERVERINFO pTapServerInfo,
//									  HWND hWndParent,
//									  HWND hWndOwner,
//									  HMODULE hmod);
//
// Allows the user to select from a list of installed
// TAP applications and launches that TAP application.
//
// In order for this function to work you must add the
// resource file TAPSERVE.RC to your resources. To locate
// these resources you must pass the module handle or
// NULLHANDLE if the resources should be loaded from the
// application's EXE.
//
// Alternatively you can launch TAP applications directly
// by calling StartApplication_TAP.
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
// hWndParent
//   Handle to the parent window of the dialog.
// hWndOwner
//   Handle to the owner window of the dialog.
// hmod
//   Handle to the module that contains the application's
//   resources, or NULLHANDLE if resources come from the
//   application's EXE.
//
//  Returns: TRUE on success.
//
int SelectApplication_TAP(PTAPSERVERINFO pTapServerInfo,
								  HWND hWndParent,
								  HWND hWndOwner,
								  HMODULE hmod)
{
int iRet = TRUE;
	// Bring up the application selection dialog
	if (WinDlgBox(hWndParent,
						 hWndOwner,
						 SelectApplicationDlgProc,
						 hmod,
						 DLG_SELECT_TAP,
						 pTapServerInfo )
			== DID_ERROR )
		iRet = FALSE;

	return iRet;
}

//
// int GetApplications_TAP(char *szApplications, PULONG pulSize);
//
// Gets a list of registered TAP Applications and/or size
// of the list of TAP Applications. The list of TAP applications
// is returned as a buffer of null-terminated ASCII strings,
// the final ASCII string double null-terminated.
//
// For Example: String1\0String2\0FinalString\0\0
//
// Parameters:
// szApplications
//   Pointer to a buffer where the application list will
//   be stored. If this is NULL, only the application list
//   size will be put in pulSize. (Output)
// pulSize
//   Size of the szApplications buffer in bytes. (Input)
//   Size of the application list, in bytes. (Output)
//
// Returns: TRUE on success.
//
int GetApplications_TAP(char *szApplications, PULONG pulSize)
{
int iRet = TRUE;

	// If we have a pointer, get the data
	if (szApplications)
		if (!PrfQueryProfileString(HINI_SYSTEMPROFILE,
												TAP_INI_APPNAME,
												NULL,
												"\0\0",
												szApplications,
												*pulSize))
				iRet = FALSE;

	// And always return how much data we query in pulSize
	if (!PrfQueryProfileSize(HINI_SYSTEMPROFILE,
										TAP_INI_APPNAME,
										NULL,
										pulSize))
		iRet = FALSE;

	return iRet;
}

//
// int GetApplicationInfo_TAP(char *szAppName,
//										PTAPAPPENTRY pTapAppInfo);
//
// Given a TAP Application name (retrieved with
// GetApplications_TAP) returns a structure containing
// information about that TAP Application. For more
// information, the structure is located in TAP.H.
//
// Parameters:
// szAppName
//   Name of the TAP Application.
// pTapAppInfo
//   Pointer to a TapAppInfo structure. (Output)
//
// Returns: TRUE on success.
//
int GetApplicationInfo_TAP(char *szAppName,
									PTAPAPPENTRY pTapAppInfo)
{
int iRet = TRUE;
ULONG DataLength;

	// Setup length of our data structure
	DataLength = sizeof(TAPAPPENTRY);

	// Query application information
	if (!PrfQueryProfileData(HINI_SYSTEMPROFILE,
										TAP_INI_APPNAME,
										szAppName,
										pTapAppInfo,
										&DataLength))
		iRet = FALSE;

	return iRet;
}

//
// int SetFileName_TAP(PTAPSERVERINFO pTapServerInfo,
//								char *szFileName);
//
// Sets the name of the current TAP file.
//
// This filename must include path information (either
// relative or fully qualified). That is, "TAP\TAPSAMP.EXE"
// is an acceptable path. This function will automatically
// fully qualify a relative path.
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
// szFileName
//   Relative or fully qualified file specification.
//
// Returns: TRUE on success.
//
int SetFileName_TAP(PTAPSERVERINFO pTapServerInfo,
							char *szFileName)
{
int iRet = TRUE;

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Create a fully qualified file name and put
	// it into the pipe packet
	DosQueryPathInfo(szFileName,
						  FIL_QUERYFULLNAME,
						  pTapServerInfo -> tiTapInfo . szFileName,
						  CCHMAXPATH);

	// Set flag indicating we started a new file
	pTapServerInfo -> lFileOpen = TRUE;
	pTapServerInfo -> tiTapInfo.ulFlags |= TAP_BOF;

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// int SetCompleteSize_TAP(PTAPSERVERINFO pTapServerInfo,
//									long lCompleteFileSize);
//
// Sets the complete size of the file. If this size is
// not known it may be set to -1 (TAP_SIZE_UNKNOWN).
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
// lCompleteFileSize
//   Size of the file when transfer is complete.
//
// Returns: TRUE on success.
//
int SetCompleteSize_TAP(PTAPSERVERINFO pTapServerInfo,
								long lCompleteFileSize)
{
int iRet = TRUE;

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Set complete file size in pipe packet
	pTapServerInfo -> tiTapInfo . lCompleteFileSize = lCompleteFileSize;

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// int SetCurrentSize_TAP(PTAPSERVERINFO pTapServerInfo,
// 								long lCurrentFileSize);
//
// Sets the current size of the file. If thie size is
// not known it may be set to -1 (TAP_SIZE_UNKNOWN).
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
// lCurrentFileSize
//   Size of the file at the current time.
//
// Returns: TRUE on success.
//
int SetCurrentSize_TAP(PTAPSERVERINFO pTapServerInfo,
								long lCurrentFileSize)
{
int iRet = TRUE;

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Set current file size in pipe packet
	pTapServerInfo -> tiTapInfo . lCurrentFileSize = lCurrentFileSize;

	// Set flag indicating the file size changed
	pTapServerInfo->tiTapInfo.ulFlags |= TAP_NEW_SIZE;

	// Send new file information down the pipe
	DosPostEventSem(pTapServerInfo -> hevUpdate);

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// int EmergencyClose_TAP(PTAPSERVERINFO pTapServerInfo)
//
// Calls for all TAP Applications to immediately
// close the current file.
//
// This function might be called if the current file needs
// to be erased, moved, copied, etc. Note that this file
// close operation will not take affect as soon as this
// function returns. A 1/4 second delay is recommended
// following this call before attempting any other file
// operations. Normally the operation will succeed, but
// if it fails delay another 1/4 second and retry the
// operation.
//
// NOTE: This does NOT close the current file on the
// server side. You must do this yourself.
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
//
// Returns: TRUE on success.
//
int EmergencyClose_TAP(PTAPSERVERINFO pTapServerInfo)
{
int iRet = TRUE;

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Set flag asking for an emergency close file
	pTapServerInfo->tiTapInfo.ulFlags |= TAP_EMERGENCY_CLOSE;
	pTapServerInfo -> lFileOpen = FALSE;

	// Send new file information down the pipe
	DosPostEventSem(pTapServerInfo -> hevUpdate);

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// int Cancel_TAP(PTAPSERVERINFO pTapServerInfo);
//
// Alerts the TAP Applications that the current
// transfer batch has been cancelled.
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
//
// Returns: TRUE on success.
//
int Cancel_TAP(PTAPSERVERINFO pTapServerInfo)
{
int iRet = TRUE;

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Set flag asking for a cancel transfer
	pTapServerInfo->tiTapInfo.ulFlags |= TAP_CANCEL;
	pTapServerInfo -> lFileOpen = FALSE;

	// Send new file information down the pipe
	DosPostEventSem(pTapServerInfo -> hevUpdate);

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// int EndOfFile_TAP(PTAPSERVERINFO pTapServerInfo);
//
// Alerts the TAP Applications that we have reached
// the end of the current file.
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
//
// Returns: TRUE on success.
//
int EndOfFile_TAP(PTAPSERVERINFO pTapServerInfo)
{
int iRet = TRUE;

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Set flag saying we've reached the end of this file
	pTapServerInfo -> tiTapInfo.ulFlags |= TAP_EOF;
	pTapServerInfo -> lFileOpen = FALSE;

	// Send new file information down the pipe
	DosPostEventSem(pTapServerInfo -> hevUpdate);

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// int EndOfBatch_TAP(PTAPSERVERINFO pTapServerInfo);
//
// Alerts the TAP Applications that we have reached
// the end of the current file transfer batch.
// That is, that the application should expect no more
// files.
//
// Parameters:
// pTapServerInfo
//   Pointer to the TAP Server instance data.
//
// Returns: TRUE on success.
//
int EndOfBatch_TAP(PTAPSERVERINFO pTapServerInfo)
{
int iRet = TRUE;

	// Request exclusive access to the server
	DosRequestMutexSem(pTapServerInfo -> hServerMutex,
								(ULONG)SEM_INDEFINITE_WAIT);

	// Set flag saying we've reached the end of the batch
	pTapServerInfo->tiTapInfo.ulFlags |= TAP_EOB;
	pTapServerInfo -> lFileOpen = FALSE;

	// Send new file information down the pipe
	DosPostEventSem(pTapServerInfo -> hevUpdate);

	// Release exclusive access to the server
	DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

	return iRet;
}

//
// void ServerThread_TAP(void *ServerInfo)
//
//              -= Internal only =-
// -= Not to be called from outside this module =-
//
// Handles the dispatch of file information to
// TAP Applications.
//
void ServerThread_TAP (void *ServerInfo) {
	PTAPSERVERINFO pTapServerInfo = (PTAPSERVERINFO) ServerInfo;
	ULONG PostCount;
	ULONG BytesWritten;
	long cnter;
	PTAPPACKET pTapPacket;
	USHORT usPacketLength;
	

	for (;;)
	{
		// Wait until someone asks us to send a new pipe packet
		DosWaitEventSem(pTapServerInfo -> hevUpdate, (ULONG)SEM_INDEFINITE_WAIT);

		// Request exclusive access to the server
		DosRequestMutexSem(pTapServerInfo -> hServerMutex,	(ULONG)SEM_INDEFINITE_WAIT);

		// Note that TAP_VERSION is handled elsewhere; it is sent immediately when thread is created!

		if (pTapServerInfo->tiTapInfo.ulFlags & TAP_BOF) {
			USHORT usFileNameLength = (USHORT)strlen (pTapServerInfo->tiTapInfo.szFileName);
			usPacketLength = (USHORT)(sizeof (pTapPacket->beginFilePacket) + usFileNameLength);
			pTapPacket = malloc (usPacketLength);
			pTapPacket->beginFilePacket.lCurrentFileSize = pTapServerInfo->tiTapInfo.lCurrentFileSize;
			pTapPacket->beginFilePacket.lCompleteFileSize = pTapServerInfo->tiTapInfo.lCompleteFileSize;
			pTapPacket->beginFilePacket.usFileNameLength = usFileNameLength;
			strcpy (pTapPacket->beginFilePacket.szFileName, pTapServerInfo->tiTapInfo.szFileName);
			}
		else if (pTapServerInfo->tiTapInfo.ulFlags & TAP_NEW_SIZE) {
			usPacketLength = (USHORT)sizeof (pTapPacket->newSizePacket);
			pTapPacket = malloc (usPacketLength);
			pTapPacket->newSizePacket.lCurrentFileSize = pTapServerInfo->tiTapInfo.lCurrentFileSize;
			pTapPacket->newSizePacket.lCompleteFileSize = pTapServerInfo->tiTapInfo.lCompleteFileSize;
			}
		else {
			usPacketLength = sizeof (pTapPacket->flagPacket);
			pTapPacket = malloc (usPacketLength);
			}

		pTapPacket->flagPacket.cb = usPacketLength;
		pTapPacket->flagPacket.usFlags = (USHORT)pTapServerInfo->tiTapInfo.ulFlags;

		// Send the packet down all pipes
		for (cnter=0; cnter < pTapServerInfo->lNumPipes; cnter++) {
			DosWrite (pTapServerInfo->phWritePipe[cnter], pTapPacket, pTapPacket->flagPacket.cb, &BytesWritten);
			}

		free (pTapPacket);

		// Reset flags
		pTapServerInfo -> tiTapInfo . ulFlags = 0L;

		// Reset update event semaphore
		DosResetEventSem(pTapServerInfo -> hevUpdate, &PostCount);

		// Release exclusive access to the server
		DosReleaseMutexSem(pTapServerInfo -> hServerMutex);

		// If this is a shutdown request break out
		if (pTapServerInfo -> lShutdown)
			break;
	}

	// ***
	// Shut down code
	// ***

	// Close semaphores
	DosCloseEventSem(pTapServerInfo -> hevUpdate);
	DosCloseMutexSem(pTapServerInfo -> hServerMutex);

	// Close pipes
	for(cnter=0; cnter < pTapServerInfo->lNumPipes; cnter++) {
		DosClose(pTapServerInfo -> phWritePipe[cnter]);
		}

	// Free memory
	free((void *) pTapServerInfo -> phWritePipe);
	free((void *) pTapServerInfo);

	// End this thread
	_endthread();
}

//
// void LaunchApplicationThread_TAP(void *data);
//
// Thread to start the TAP application,
// so we don't hog the message queue
//
void LaunchApplicationThread_TAP(void *data)
{
PLAUNCHINFO pLaunchInfo = (PLAUNCHINFO) data;
HAB hab;
HMQ hmq;

   // And to make things even more fun,
   // StartApplication_TAP requires the
   // presence of a message queue
   hab=WinInitialize(0);
   hmq=WinCreateMsgQueue(hab, 0);

	// Start TAP application
   StartApplication_TAP(pLaunchInfo -> pTapServerInfo,
								pLaunchInfo -> szProgram,
								pLaunchInfo -> szParams,
								pLaunchInfo -> szTitle);

   // We are responsible for freeing this structure
   free(pLaunchInfo);

   // Free up PM resources
   WinDestroyMsgQueue(hmq);
   WinTerminate(hab);

   // End this thread
   _endthread();
}

//
// MRESULT EXPENTRY SelectApplicationDlgProc(HWND hWnd, ULONG msg, MPARAM mp1, MPARAM mp2);
//
//              -= Internal only =-
// -= Not to be called from outside this module =-
//
MRESULT EXPENTRY SelectApplicationDlgProc(HWND hWnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
MRESULT mResult;

	switch (msg)
	{
		case WM_INITDLG :
		{
		char *szApps;
		ULONG ulSize;

			// ***
			// Store PTAPSERVERINFO in the window words
			// ***
			WinSetWindowPtr(hWnd, QWL_USER, (PVOID) mp2);

			// ***
			// Initialize listbox with TAP applications available
			// ***

			// Get size of application list
			if (GetApplications_TAP(NULL, &ulSize))
			{
				// Allocate enough memory for list
				szApps = (char *) malloc(ulSize + 10);

				if (GetApplications_TAP(szApps, &ulSize))
				{
				ULONG cnter;
				char szApp[256];
				int iAppLen;

					// Traverse the array of strings
					for (cnter=0, iAppLen = 0; cnter<ulSize; cnter++)
							// Is there more to be added to the app name?
							if (szApps[cnter])
								szApp[iAppLen++] = szApps[cnter];
							else
								// No, have we seen two NULLs in a row?
								if (!iAppLen)
									// We've reached the end of the list
									break;
								else
								{
									// This is the end of an app name
									szApp[iAppLen] = 0;
									iAppLen = 0;

									// Insert this application into the
									// list box
									WinSendDlgItemMsg(hWnd,
															ID_APPLIST_TAP,
															LM_INSERTITEM,
															(MPARAM) LIT_SORTASCENDING,
															(MPARAM) szApp);
								}
				}

				// Free up application list
				free(szApps);
			}

			mResult = (MRESULT) FALSE;
			break;
		}

		case WM_CONTROL :
		{
		USHORT id = SHORT1FROMMP(mp1);
		USHORT usNotifyCode = SHORT2FROMMP(mp1);

			// Was an application selected in the list box?
			if ((id == ID_APPLIST_TAP) &&
				 (usNotifyCode == LN_SELECT))
			{
			TAPAPPENTRY TapAppEntry;
			char szAppName[256];
			SHORT sItemSelected;
			IPT MLETextLen;

				// Get selected application name
				sItemSelected = (SHORT)
					WinSendDlgItemMsg(hWnd,
											ID_APPLIST_TAP,
											LM_QUERYSELECTION,
											(MPARAM) LIT_FIRST,
											(MPARAM) 0);

				WinSendDlgItemMsg(hWnd,
										ID_APPLIST_TAP,
										LM_QUERYITEMTEXT,
										(MPARAM) MPFROM2SHORT(sItemSelected, 256),
										(MPARAM) szAppName);

				// Get the description of the application
				GetApplicationInfo_TAP(szAppName, &TapAppEntry);

				// Put new application description into MLE
				MLETextLen = (IPT)
					WinSendDlgItemMsg(hWnd,
											ID_APPDESC_TAP,
											MLM_QUERYTEXTLENGTH,
											(MPARAM) 0,
											(MPARAM) 0);

				WinSendDlgItemMsg(hWnd,
										ID_APPDESC_TAP,
										MLM_SETSEL,
										(MPARAM) 0,
										(MPARAM) MLETextLen);

				WinSendDlgItemMsg(hWnd,
										ID_APPDESC_TAP,
										MLM_INSERT,
										(MPARAM) TapAppEntry.szDescription,
										(MPARAM) 0);

			}

			// Call default handler
			mResult = WinDefDlgProc(hWnd, msg, mp1, mp2);
			break;
		}

		case WM_COMMAND :
		{
			// Should we launch an application?
			if (SHORT1FROMMP(mp1) == DID_OK)
			{
			SHORT sItemSelected;
			char szAppName[256];

				// Get selected item number
				sItemSelected = (SHORT)
					WinSendDlgItemMsg(hWnd,
											ID_APPLIST_TAP,
											LM_QUERYSELECTION,
											(MPARAM) LIT_FIRST,
											(MPARAM) 0);

				if (sItemSelected != LIT_NONE)
				{
				PTAPSERVERINFO pTapServerInfo;
				TAPAPPENTRY TapAppEntry;
            PLAUNCHINFO pLaunchInfo;

					// Get pTapServerInfo
					pTapServerInfo = (PTAPSERVERINFO) WinQueryWindowPtr(hWnd, QWL_USER);

					// Get name of selected item
					WinSendDlgItemMsg(hWnd,
											ID_APPLIST_TAP,
											LM_QUERYITEMTEXT,
											(MPARAM) MPFROM2SHORT(sItemSelected, 256),
											(MPARAM) szAppName);

					// Get application's information
					GetApplicationInfo_TAP(szAppName, &TapAppEntry);

               // Start a thread to launch the application,
               // otherwise we will hog the message queue.
               // The launch thread will terminate after the
               // TAP application has started.
               pLaunchInfo = malloc(sizeof(LAUNCHINFO));
               pLaunchInfo -> cb = sizeof(LAUNCHINFO);
               pLaunchInfo -> pTapServerInfo = pTapServerInfo;
               strcpy(pLaunchInfo -> szProgram, TapAppEntry.szProgram);
               strcpy(pLaunchInfo -> szParams, TapAppEntry.szParams);
               strcpy(pLaunchInfo -> szTitle, "TAP Application");

#ifdef __BORLANDC__
               _beginthread(LaunchApplicationThread_TAP,
                            8192L,
                            pLaunchInfo);
#else
               _beginthread(LaunchApplicationThread_TAP,
                            NULL,
                            8192L,
                            pLaunchInfo);
#endif
   			}
			}

			// Call default handler
			mResult = WinDefDlgProc(hWnd, msg, mp1, mp2);
			break;
		}

		default :
			// Call default handler
			mResult = WinDefDlgProc(hWnd, msg, mp1, mp2);
			break;
	}

	return mResult;
}