//
// TAPAPP.C
//
// TAP
// File Transfer Data Sharing
// Application Code
// Revision 1.10
//
// 12/28/94 First created
// 4/24/95 Structures aligned with DWORDS
// Dynamic extension lists added
// Fixed EMERGENCY_CLOSE to use bitwise NOT (~)
//
#define INCL_DOSERRORS
#define INCL_WINSHELLDATA
#define INCL_DOS
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <string.h>
#include <os2.h>
#include "tapapp.h"
//
// PTAPAPPENTRY BuildTapAppEntry_TAP(char *szDescription,
// char *szProgram,
// char *szParams,
// PSZ pszExtension[],
// ULONG ulNumExtensions);
//
// This function allocates and builds a TAPAPPENTRY
// that should be used to register a TAP application with
// the TAP servers.
//
// Parameters
// szDescription
// Description, up to 255 characters, of the application.
// szProgram
// Fully qualified path to the TAP executable.
// szParams
// Parameters to pass to the TAP program (max: 83 characters)
// pszExtension
// A pointer to an array of pointers to strings, each
// string containing an file extension this application
// supports.
// ulNumExtensions
// Number of extensions the application can handle.
// If this is zero, pszExtension may be NULL.
//
// Returns
// A pointer to a TAPAPPENTRY.
//
// WARNING: The CALLER (that's you) is responsible for
// freeing this structure after using it.
// This can be done by calling the standard
// C function free.
//
PTAPAPPENTRY BuildTapAppEntry_TAP(char *szDescription,
char *szProgram,
char *szParams,
PSZ pszExtension[],
ULONG ulNumExtensions)
{
PTAPAPPENTRY pTapAppEntry;
PEXTENSIONLIST pExtList;
ULONG i, ulSize;
// Compute the size of the TAPAPPENTRY structure with
// the extension list appended
for (i = 0, ulSize = sizeof(TAPAPPENTRY); i < ulNumExtensions; i++)
ulSize += sizeof(((PEXTENSIONLIST)NULL)->cb) +
sizeof(((PEXTENSIONLIST)NULL)->szExtension) +
strlen(pszExtension[i]);
// Allocate a TAPAPPENTRY structure
pTapAppEntry = (PTAPAPPENTRY) malloc (ulSize);
// Fill in the TAPAPPENTRY structure
pTapAppEntry->cb = ulSize;
strcpy(pTapAppEntry -> szDescription, szDescription);
strcpy(pTapAppEntry -> szProgram, szProgram);
strcpy(pTapAppEntry -> szParams, szParams);
pTapAppEntry->ulExtensions = ulNumExtensions;
// Set pExtList to point to the memory location immediately
// following the TAPAPPENTRY structure
pExtList = (PEXTENSIONLIST) ((PBYTE)pTapAppEntry + sizeof(TAPAPPENTRY));
// Fill the memory after TAPPAPPENTRY with variable size EXTENSIONLISTs
for (i = 0; i < ulNumExtensions; i++)
{
pExtList -> cb = sizeof(((PEXTENSIONLIST)NULL)->cb) +
sizeof(((PEXTENSIONLIST)NULL)->szExtension) +
strlen(pszExtension[i]);
strcpy(pExtList->szExtension, pszExtension[i]);
// Go to the next EXTENSIONLIST structure
pExtList = (PEXTENSIONLIST) ((PBYTE)pExtList + pExtList -> cb);
}
// Warning, the caller must free this up.
return pTapAppEntry;
}
//
// int RegisterApplication_TAP(char *szAppName,
// PTAPAPPENTRY pTapAppEntry);
//
// Registers a TAP Application so that TAP Servers can
// find it. This need only be done once.
//
// Parameters:
// szAppName
// Name of the TAP Application
// pTapAppEntry
// A pointer to a structure containing
// information about this TAP application.
// See TAP.H for the members of this
// structure. The TAP application is
// responsible for filling this out
// completely and correctly.
//
// Returns: TRUE on success
//
int RegisterApplication_TAP(char *szAppName,
PTAPAPPENTRY pTapAppEntry)
{
int iRet = TRUE;
// Write application data to the INI file
iRet =
(INT)PrfWriteProfileData(HINI_SYSTEMPROFILE,
TAP_INI_APPNAME,
szAppName,
(PVOID) pTapAppEntry,
pTapAppEntry -> cb);
return iRet;
}
//
// int DeRegisterApplication_TAP(char *szAppName);
//
// Deregisters a TAP Application so that it is unavailable
// to TAP Servers.
//
// Parameters:
// szAppName
// Name of the TAP Application
//
// Returns: TRUE on success
//
int DeRegisterApplication_TAP(char *szAppName)
{
int iRet = TRUE;
// Remove application from the INI file
iRet =
(INT)PrfWriteProfileData(HINI_SYSTEMPROFILE,
TAP_INI_APPNAME,
szAppName,
NULL,
0);
return iRet;
}
//
// int OpenFile_TAP(PTAPAPPINFO pTapAppInfo, PHFILE phFile);
//
// Opens the current file being transferred for
// shared reading.
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
// phFile
// Pointer to an OS/2 file handle. (output)
//
// Returns: TRUE on success
//
int OpenFile_TAP(PTAPAPPINFO pTapAppInfo, PHFILE phFile)
{
APIRET rc;
ULONG ActionTaken;
int iRet = TRUE;
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
//
// Open an already existing file for read only access
//
// As a child process we really already have an
// inherited file handle but we're ignoring this fact
//
rc = DosOpen(pTapAppInfo -> tiCurrent . szFileName,
&(pTapAppInfo -> hUserFile),
&ActionTaken,
0,
FILE_NORMAL,
OPEN_ACTION_FAIL_IF_NEW |
OPEN_ACTION_OPEN_IF_EXISTS,
OPEN_SHARE_DENYNONE |
OPEN_ACCESS_READONLY,
NULL);
if (rc)
iRet = FALSE;
else
// Success, return file handle
*phFile = pTapAppInfo -> hUserFile;
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
return iRet;
}
//
// int CloseFile_TAP(PTAPAPPINFO pTapAppInfo, HFILE hFile)
//
// Closes a the current file opened with OpenFile_TAP.
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
// hFile
// OS/2 handle to the file to be closed.
//
// Returns: TRUE on success
//
int CloseFile_TAP(PTAPAPPINFO pTapAppInfo, HFILE hFile)
{
int iRet = TRUE;
APIRET rc;
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
// Close file
rc = DosClose(hFile);
if (rc)
iRet = FALSE;
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
return iRet;
}
//
// PTAPAPPINFO InitializeApplication_TAP(int argc, char **argv);
//
// Initializes the TAP subsystem. This function must be called
// as one of the first functions called in the TAP application.
//
// Parameters:
// argc & argv - Standard command line parameters passed
// to main on startup
//
// Returns: A pointer to the TAP instance data on success,
// otherwise NULL. A NULL return value most likely means this
// program was NOT started from a TAP server as required.
//
PTAPAPPINFO InitializeApplication_TAP(int argc, char **argv)
{
PTAPAPPINFO pTapAppInfo = NULL;
int cnter;
char szPipeName[CCHMAXPATH];
HFILE PipeHandle;
ULONG ActionTaken;
APIRET rc;
// Parse pipe name from the command line
for(cnter=0; cnter<argc; cnter++)
if (!strncmp(argv[cnter], "/TAP=", 5))
strcpy(szPipeName, (argv[cnter] + 5));
// Open named pipe
rc = DosOpen(szPipeName,
&PipeHandle,
&ActionTaken,
0L,
FILE_NORMAL,
FILE_OPEN,
OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE,
(PEAOP2) NULL);
// Allocate memory
if (!rc)
pTapAppInfo = (PTAPAPPINFO) malloc(sizeof(TAPAPPINFO));
if (pTapAppInfo)
{
// Initialize TAPAPPINFO structure
pTapAppInfo -> cb = sizeof(TAPAPPINFO);
pTapAppInfo -> lShutdown = FALSE;
pTapAppInfo -> hReadPipe = (HFILE) PipeHandle;
// Create mutex semaphore
DosCreateMutexSem(NULL,
&(pTapAppInfo -> hAppMutex),
0,
FALSE);
// Initialize version info
pTapAppInfo -> szVersion[0] = '\0';
pTapAppInfo -> lVersionAvailable = FALSE;
// Initialize TAPINFO structures
pTapAppInfo -> tiCurrent . szFileName [0] = '\0';
pTapAppInfo -> tiCurrent . lCurrentFileSize = TAP_SIZE_UNKNOWN;
pTapAppInfo -> tiCurrent . lCompleteFileSize = TAP_SIZE_UNKNOWN;
pTapAppInfo -> tiCurrent . ulFlags = 0;
pTapAppInfo -> tiNext . szFileName [0] = '\0';
pTapAppInfo -> tiNext . lCurrentFileSize = TAP_SIZE_UNKNOWN;
pTapAppInfo -> tiNext . lCompleteFileSize = TAP_SIZE_UNKNOWN;
pTapAppInfo -> tiNext . ulFlags = 0;
// Start TAP Application thread
#ifdef __BORLANDC__
_beginthread(ApplicationThread_TAP,
8192,
(void *) pTapAppInfo);
#else
_beginthread(ApplicationThread_TAP,
NULL,
8192,
(void *) pTapAppInfo);
#endif
}
return pTapAppInfo;
}
//
// int DeInitializeApplication_TAP(PTAPAPPINFO pTapAppInfo);
//
// Deinitializes the TAP subsystem.
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
//
// Returns: TRUE on success
//
int DeInitializeApplication_TAP(PTAPAPPINFO pTapAppInfo)
{
int iRet = TRUE;
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
// Tell the application thread we want to shut down
pTapAppInfo -> lShutdown = TRUE;
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
return iRet;
}
//
// int NextFile_TAP(PTAPAPPINFO pTapAppInfo);
//
// Waits for the next file in the transfer session
// or a cancel or an end of batch condition.
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
//
// Returns: TRUE if another file transfer has started.
// FALSE if a cancel or end of batch condition has
// been encountered.
//
int NextFile_TAP(PTAPAPPINFO pTapAppInfo)
{
int iRet = TRUE;
int ExitCondition = FALSE;
do
{
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
// Check if the next packet begins a new file
ExitCondition = pTapAppInfo -> tiNext.ulFlags & TAP_BOF ? TRUE : FALSE;
// Special condition: if the TAP applicationstarted at this middle
// of a file, we get no BOF (Begin of File) flag. To detect this
// condition we check if the current filename is the null string
// while the next filename is the non-empty string
if ( (pTapAppInfo -> tiCurrent.szFileName [0] == 0) &&
(pTapAppInfo -> tiNext.szFileName [0] != 0) )
ExitCondition = TRUE;
// Check for exit conditions
if ( (pTapAppInfo -> tiNext.ulFlags & TAP_CANCEL) ||
(pTapAppInfo -> tiNext.ulFlags & TAP_EOB) )
{
iRet = FALSE;
ExitCondition = TRUE;
}
// If we're going to exit, update the current data packet
if (ExitCondition)
{
pTapAppInfo -> tiCurrent = pTapAppInfo -> tiNext;
pTapAppInfo -> tiNext . ulFlags = 0;
}
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
// Wait for 1/4 sec if this loop will repeat
if (!ExitCondition)
DosSleep(250);
} while (!ExitCondition);
return iRet;
}
//
// int MoreData_TAP(PTAPAPPINFO pTapAppInfo);
//
// Waits for more data to arrive or one of
// the following conditions to occur:
// CANCEL, END OF BATCH, BEGIN NEW FILE, EOF
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
//
// Returns: TRUE if more data has been received.
// FALSE if any other condition has occured.
//
// If FALSE is returned there will be no more data
// for the current file. Recommended action is to
// check the file size and process any still
// unprocessed data, then call NextFile_TAP
// to determine if there are any more files to
// process.
//
int MoreData_TAP(PTAPAPPINFO pTapAppInfo)
{
int iRet = TRUE;
int ExitCondition = FALSE;
do
{
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
// Check for exit conditions that pertain to
// batch conditions (End of batch, cancel)
// that should be handled by NextFile
if ( (pTapAppInfo -> tiNext.ulFlags & TAP_CANCEL) ||
(pTapAppInfo -> tiNext.ulFlags & TAP_EOB) ||
(pTapAppInfo -> tiNext.ulFlags & TAP_BOF) )
{
iRet = FALSE;
ExitCondition = TRUE;
}
else
// Check for exit conditions we need
// to handle here (pertain to the file)
if (pTapAppInfo -> tiNext.ulFlags & TAP_EOF)
{
iRet = FALSE;
ExitCondition = TRUE;
pTapAppInfo -> tiNext . ulFlags = 0;
}
else
// Check if the next packet has new data
if (pTapAppInfo -> tiNext.ulFlags & TAP_NEW_SIZE)
{
ExitCondition = TRUE;
pTapAppInfo -> tiNext . ulFlags = 0;
}
if (ExitCondition)
pTapAppInfo -> tiCurrent = pTapAppInfo -> tiNext;
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
// Wait for 1/4 sec if this loop will repeat
if (!ExitCondition)
DosSleep(250);
} while (!ExitCondition);
return iRet;
}
//
// long QueryStatus_TAP(PTAPAPPINFO pTapAppInfo);
//
// Queries the status of the current file.
// This really isn't very useful.
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
//
// Returns: Bitmapped flags
//
long QueryStatus_TAP(PTAPAPPINFO pTapAppInfo)
{
long lRet = 0;
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
// Return current TAP flags
lRet = (LONG)(pTapAppInfo -> tiCurrent . ulFlags);
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
return lRet;
}
//
// int QueryServerVersion_TAP(PTAPAPPINFO pTapAppInfo,
// char *szVersion);
//
// Queries the server version string. This function
// returns a valid server version string only when it
// has received at least one packet of information
// over the named pipe. It's therefore recommended
// that this not be used until the first call to
// NextFile_TAP returns.
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
// szVersion
// Pointer to a memory location of at least 31 bytes
// to hold the server version string (output)
//
// Returns: TRUE on success
//
int QueryServerVersion_TAP(PTAPAPPINFO pTapAppInfo,
char *szVersion,
ULONG ulBufLen)
{
int iRet = TRUE;
ULONG ulRetries = 10; // Max 10 retries = 2.5 sec
for (;;) {
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
if (pTapAppInfo -> lVersionAvailable)
break;
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
if (ulRetries-- == 0)
return (FALSE);
DosSleep (250);
}
// Make a copy of the server version string
strncpy (szVersion, pTapAppInfo -> szVersion, ulBufLen - 1);
szVersion[ulBufLen - 1] = '\0';
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
return iRet;
}
//
// int QueryFileName_TAP(PTAPAPPINFO pTapAppInfo,
// char *szFileName);
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
// szFileName
// Pointer to a memory block of CCHMAXPATH length
// where the current fully qualified path and file name
// is copied. (output)
//
// Returns: TRUE on success;
//
int QueryFileName_TAP(PTAPAPPINFO pTapAppInfo,
char *szFileName)
{
int iRet = TRUE;
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
// Make a copy of the fully qualified file name
strcpy(szFileName, pTapAppInfo -> tiCurrent . szFileName);
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
return iRet;
}
//
// long QueryCompleteSize_TAP((PTAPAPPINFO pTapAppInfo);
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
//
// Returns: The size of the complete file or -1 (TAP_SIZE_UNKNOWN)
// if that size is unknown.
//
long QueryCompleteSize_TAP(PTAPAPPINFO pTapAppInfo)
{
long lRet = TRUE;
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
// Return complete size
lRet = pTapAppInfo -> tiCurrent . lCompleteFileSize;
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
return lRet;
}
//
// long QueryCurrentSize_TAP((PTAPAPPINFO pTapAppInfo);
//
// Parameters:
// pTapAppInfo
// Pointer to the TAP application's instance data.
//
// Returns: The size of the current file or -1 (TAP_SIZE_UNKNOWN)
// if that size is unknown.
//
long QueryCurrentSize_TAP(PTAPAPPINFO pTapAppInfo)
{
long lRet = TRUE;
// Request exclusive access
DosRequestMutexSem(pTapAppInfo -> hAppMutex,
(ULONG)SEM_INDEFINITE_WAIT);
// Return current size
lRet = pTapAppInfo -> tiCurrent . lCurrentFileSize;
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
return lRet;
}
//
// void ApplicationThread_TAP(void *AppInfo)
//
// -= NOT to be called by any other module =-
//
// This is a thread function which serves
// the purpose of servicing the queue and
// updating data structures accordingly.
//
// This function also handles emergency file
// closes.
//
void ApplicationThread_TAP (void *AppInfo) {
PTAPAPPINFO pTapAppInfo = (PTAPAPPINFO)AppInfo;
while (!pTapAppInfo->lShutdown) {
USHORT usPacketSize = 0;
ULONG ulBytesRead;
PTAPPACKET pTapPacket;
for (;;) {
AVAILDATA availData;
ULONG ulState;
DosPeekNPipe (pTapAppInfo->hReadPipe, &usPacketSize, sizeof (usPacketSize), &ulBytesRead, &availData, &ulState);
// Have we got the whole packet yet ?
if ((ulBytesRead == sizeof (usPacketSize)) && (availData.cbpipe >= usPacketSize))
break;
// Shutdown on request or if pipe is no longer connected
if ((pTapAppInfo->lShutdown) || (ulState != NP_STATE_CONNECTED))
goto _ShutDown;
// Not enough data yet, sleep for 1/4 second
DosSleep (250);
}
// Read packet
pTapPacket = (PTAPPACKET)malloc (usPacketSize);
DosRead(pTapAppInfo->hReadPipe, pTapPacket, usPacketSize, &ulBytesRead);
if (ulBytesRead == usPacketSize) {
ULONG ulFlags = pTapPacket->flagPacket.usFlags;
if (ulFlags & TAP_EMERGENCY_CLOSE) {
// Close up file ASAP
DosClose (pTapAppInfo -> hUserFile);
// Reset emergency flag, it has been handled
ulFlags &= ~(ULONG)TAP_EMERGENCY_CLOSE;
}
// Request exclusive access
DosRequestMutexSem (pTapAppInfo->hAppMutex, (ULONG)SEM_INDEFINITE_WAIT);
if (ulFlags & TAP_VERSION) {
LONG lLen = min (sizeof (pTapAppInfo->szVersion) - 1, pTapPacket->versionPacket.usVersionLength);
strncpy (pTapAppInfo->szVersion, pTapPacket->versionPacket.szVersion, (UINT)lLen);
pTapAppInfo->szVersion[lLen] = '\0';
pTapAppInfo -> lVersionAvailable = TRUE;
}
else if (ulFlags & TAP_BOF) {
LONG lLen;
pTapAppInfo->tiNext.lCurrentFileSize = pTapPacket->beginFilePacket.lCurrentFileSize;
pTapAppInfo->tiNext.lCompleteFileSize = pTapPacket->beginFilePacket.lCompleteFileSize;
lLen = min (sizeof (pTapAppInfo->tiNext.szFileName) - 1, pTapPacket->beginFilePacket.usFileNameLength);
strncpy (pTapAppInfo->tiNext.szFileName, pTapPacket->beginFilePacket.szFileName, (UINT)lLen);
pTapAppInfo->tiNext.szFileName[lLen] = '\0';
}
else if (ulFlags & TAP_NEW_SIZE) {
pTapAppInfo->tiNext.lCurrentFileSize = pTapPacket->newSizePacket.lCurrentFileSize;
pTapAppInfo->tiNext.lCompleteFileSize = pTapPacket->newSizePacket.lCompleteFileSize;
}
// Acknowledge server if requested
if (ulFlags & TAP_ACKNOWLEDGE) {
ULONG ulBytesWritten;
pTapPacket->flagPacket.cb = sizeof (pTapPacket->flagPacket);
pTapPacket->flagPacket.usFlags = TAP_ACKNOWLEDGE;
DosWrite (pTapAppInfo->hReadPipe, pTapPacket, pTapPacket->flagPacket.cb, &ulBytesWritten);
}
pTapAppInfo->tiNext.ulFlags |= ulFlags;
// Release exclusive access
DosReleaseMutexSem(pTapAppInfo -> hAppMutex);
}
free (pTapPacket);
}
_ShutDown:
// ***
// Shutdown
// ***
// Free mutex
DosCloseMutexSem(pTapAppInfo -> hAppMutex);
// Shut down pipe
DosClose(pTapAppInfo -> hReadPipe);
// Free memory
free (pTapAppInfo);
}
