PC Online 1996 October/PCO_10.ISO/filesbbs/lw321.arj/TAP11.ZIP/tapserve.c

C/C++ Source or Header | 1995-05-10 | 28.1 KB | 1,028 lines

//
// 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;
}