Nwpipe.c

/*
 * Copyright © 2001 Novell, Inc. All Rights Reserved.
 *
 * You may distribute under the terms of either the GNU General Public
 * License or the Artistic License, as specified in the README file.
 *
 */

/*
 * FILENAME		:	NWPipe.c
 * DESCRIPTION	:	Functions to implement pipes on NetWare.
 * Author		:	HYAK
 * Date			:	January 2001.
 *
 */



#include <nwadv.h>
#include <nwdsdefs.h>

#include "win32ish.h"
#include "nwpipe.h"
#include "nwplglob.h"


// This was added since the compile failed saying "undefined P_WAIT"
// when USE_ITHREADS was commented in the makefile
#ifndef P_WAIT
#define	P_WAIT		0
#endif

#ifndef P_NOWAIT
#define	P_NOWAIT	1
#endif




/*============================================================================================

 Function		:	fnPipeFileMakeArgv

 Description	:	This function makes the argument array.

 Parameters 	:	ptpf	(IN)	-	Input structure.

 Returns		:	Boolean.

==============================================================================================*/

BOOL fnPipeFileMakeArgv(PTEMPPIPEFILE ptpf)
{
	int i=0, j=0;
	int dindex = 0;
	int sindex = 0;

	ptpf->m_argv_len = 0;


	// Below 2 is added for the following reason:
	//   - The first one is for an additional value that will be added through ptpf->m_redirect.
	//   - The second one is for a NULL termination of the array.
	//     This is required for spawnvp API that takes a NULL-terminated array as its 3rd parameter.
	//     If the array is NOT NULL-terminated, then the server abends at the spawnvp call !!
	ptpf->m_argv = (char **) malloc((ptpf->m_pipeCommand->m_argc + 2) * sizeof(char*));
	if (ptpf->m_argv == NULL)
		return FALSE;

	// For memory allocation it is just +1 since the last one is only for NULL-termination
	// and no memory is required to be allocated.
	for(i=0; i<(ptpf->m_pipeCommand->m_argc + 1); i++)
	{
		ptpf->m_argv[i] = (char *) malloc(MAX_DN_BYTES * sizeof(char));
		if (ptpf->m_argv[i] == NULL)
		{
			for(j=0; j<i; j++)
			{
				if(ptpf->m_argv[j])
				{
					free(ptpf->m_argv[j]);
					ptpf->m_argv[j] = NULL;
				}
			}
			free(ptpf->m_argv);
			ptpf->m_argv = NULL;

			return FALSE;
		}
	}

	// Copy over parsed items, removing "load" keyword if necessary.
	sindex = ((stricmp(ptpf->m_pipeCommand->m_argv[0], LOAD_COMMAND) == 0) ? 1 : 0);
	while (sindex < ptpf->m_pipeCommand->m_argc)
	{
		strcpy(ptpf->m_argv[dindex], ptpf->m_pipeCommand->m_argv[sindex]);
		dindex++;
		sindex++;
	}

	if (stricmp(ptpf->m_argv[0], PERL_COMMAND_NAME) == 0)	// If Perl is the first command.
	{
		ptpf->m_launchPerl = TRUE;

		#ifdef MPK_ON
			ptpf->m_perlSynchSemaphore = kSemaphoreAlloc((BYTE *)"pipeSemaphore", 0);
		#else
			ptpf->m_perlSynchSemaphore = OpenLocalSemaphore(0);
		#endif	//MPK_ON
	}
	else if (stricmp(ptpf->m_argv[0], (char *)"perlglob") == 0)
		ptpf->m_doPerlGlob = TRUE;


	// Create last argument, which will redirect to or from the temp file
	if (!ptpf->m_doPerlGlob || ptpf->m_mode)
	{
		if (!ptpf->m_mode)	// If read mode?
		{
			if (ptpf->m_launchPerl)
				strcpy(ptpf->m_redirect, (char *)">");
			else
				strcpy(ptpf->m_redirect, (char *)"(CLIB_OPT)/>");
		}
		else
		{
			if (ptpf->m_launchPerl)
				strcpy(ptpf->m_redirect, (char *)"<");
			else
				strcpy(ptpf->m_redirect, (char *)"(CLIB_OPT)/<");
		}
		strcat(ptpf->m_redirect, ptpf->m_fileName);

		if (ptpf->m_launchPerl)
		{
			char tbuf[15] = {'\0'};
			sprintf(tbuf, (char *)" -{%x", ptpf->m_perlSynchSemaphore);
			strcat(ptpf->m_redirect, tbuf);
		}

		strcpy(ptpf->m_argv[dindex], (char*) ptpf->m_redirect);
		dindex++;
	}

	if (dindex < (ptpf->m_pipeCommand->m_argc + 1))
	{
		if(ptpf->m_argv[dindex])
		{
			free(ptpf->m_argv[dindex]);
			ptpf->m_argv[dindex] = NULL;	// NULL termination - required for  spawnvp  call.
		}
	}

	ptpf->m_argv_len = dindex;		// Length of the argv array  OR  number of argv string values.
	ptpf->m_argv[ptpf->m_argv_len] = NULL;	// NULL termination - required for  spawnvp  call.


	return TRUE;
}


/*============================================================================================

 Function		:	fnPipeFileOpen

 Description	:	This function opens the pipe file.

 Parameters 	:	ptpf	(IN)	-	Input structure.
					command	(IN)	-	Input command string.
					mode	(IN)	-	Mode of opening.

 Returns		:	File pointer.

==============================================================================================*/

FILE* fnPipeFileOpen(PTEMPPIPEFILE ptpf, char* command, char* mode)
{
	int i=0, j=0;

	char tempName[_MAX_PATH] = {'\0'};


	ptpf->m_fileName = (char *) malloc(_MAX_PATH * sizeof(char));
	if(ptpf->m_fileName == NULL)
		return NULL;

	// The char array is emptied so that there is no junk characters.
	strncpy(ptpf->m_fileName, "", (_MAX_PATH * sizeof(char)));
	

	// Save off stuff
	//
	if(strchr(mode,'r') != 0)
		ptpf->m_mode = FALSE;	// Read mode
	else if(strchr(mode,'w') != 0)
		ptpf->m_mode = TRUE;	// Write mode
	else
	{
		if(ptpf->m_fileName != NULL)
		{
//			if (strlen(ptpf->m_fileName))
			if (ptpf->m_fileName)
				unlink(ptpf->m_fileName);

			free(ptpf->m_fileName);
			ptpf->m_fileName = NULL;
		}

		return NULL;
	}


	ptpf->m_pipeCommand = (PCOMMANDLINEPARSER) malloc(sizeof(COMMANDLINEPARSER));
	if (!ptpf->m_pipeCommand)
	{
//		if (strlen(ptpf->m_fileName))
		if (ptpf->m_fileName)
			unlink(ptpf->m_fileName);

		free(ptpf->m_fileName);
		ptpf->m_fileName = NULL;

		return NULL;
	}

	// Initialise the variables
	ptpf->m_pipeCommand->m_isValid = TRUE;

/****
// Commented since these are not being used.  Still retained here.
// To be removed once things are proved to be working fine to a good confident level,

	ptpf->m_pipeCommand->m_redirInName = NULL;
	ptpf->m_pipeCommand->m_redirOutName = NULL;
	ptpf->m_pipeCommand->m_redirErrName = NULL;
	ptpf->m_pipeCommand->m_redirBothName = NULL;
	ptpf->m_pipeCommand->nextarg = NULL;
****/

	ptpf->m_pipeCommand->sSkippedToken = NULL;
	ptpf->m_pipeCommand->m_argv = NULL;
	ptpf->m_pipeCommand->new_argv = NULL;

	#ifdef MPK_ON
		ptpf->m_pipeCommand->m_qSemaphore = NULL;
	#else
		ptpf->m_pipeCommand->m_qSemaphore = 0L;
	#endif	//MPK_ON

	ptpf->m_pipeCommand->m_noScreen = 0;
	ptpf->m_pipeCommand->m_AutoDestroy = 0;
	ptpf->m_pipeCommand->m_argc = 0;
	ptpf->m_pipeCommand->m_argv_len = 1;


	ptpf->m_pipeCommand->m_argv = (char **) malloc(ptpf->m_pipeCommand->m_argv_len * sizeof(char *));
	if (ptpf->m_pipeCommand->m_argv == NULL)
	{
		free(ptpf->m_pipeCommand);
		ptpf->m_pipeCommand = NULL;

//		if (strlen(ptpf->m_fileName))
		if (ptpf->m_fileName)
			unlink(ptpf->m_fileName);

		free(ptpf->m_fileName);
		ptpf->m_fileName = NULL;

		return NULL;
	}
	ptpf->m_pipeCommand->m_argv[0] = (char *) malloc(MAX_DN_BYTES * sizeof(char));
	if (ptpf->m_pipeCommand->m_argv[0] == NULL)
	{
		for(j=0; j<i; j++)
		{
			if(ptpf->m_pipeCommand->m_argv[j])
			{
				free(ptpf->m_pipeCommand->m_argv[j]);
				ptpf->m_pipeCommand->m_argv[j]=NULL;
			}
		}
		free(ptpf->m_pipeCommand->m_argv);
		ptpf->m_pipeCommand->m_argv=NULL;

		free(ptpf->m_pipeCommand);
		ptpf->m_pipeCommand = NULL;

//		if (strlen(ptpf->m_fileName))
		if (ptpf->m_fileName)
			unlink(ptpf->m_fileName);

		free(ptpf->m_fileName);
		ptpf->m_fileName = NULL;

		return NULL;
	}


	ptpf->m_redirect = (char *) malloc(MAX_DN_BYTES * sizeof(char));
	if (ptpf->m_redirect == NULL)
	{
		for(i=0; i<ptpf->m_pipeCommand->m_argv_len; i++)
		{
			if(ptpf->m_pipeCommand->m_argv[i] != NULL)
			{
				free(ptpf->m_pipeCommand->m_argv[i]);
				ptpf->m_pipeCommand->m_argv[i] = NULL;
			}
		}

		free(ptpf->m_pipeCommand->m_argv);
		ptpf->m_pipeCommand->m_argv = NULL;

		free(ptpf->m_pipeCommand);
		ptpf->m_pipeCommand = NULL;


//		if (strlen(ptpf->m_fileName))
		if (ptpf->m_fileName)
			unlink(ptpf->m_fileName);

		free(ptpf->m_fileName);
		ptpf->m_fileName = NULL;

		return NULL;
	}

	// The char array is emptied.
	// If it is not done so, then it could contain some junk values and the string length in that case
	// will not be zero.  This causes erroneous results in  fnPipeFileMakeArgv()  function
	// where  strlen(ptpf->m_redirect)  is used as a check for incrementing the parameter count and
	// it will wrongly get incremented in such cases.
	strncpy(ptpf->m_redirect, "", (MAX_DN_BYTES * sizeof(char)));

	// Parse the parameters.
	fnCommandLineParser(ptpf->m_pipeCommand, (char *)command, TRUE);
	if (!ptpf->m_pipeCommand->m_isValid)
	{
		fnTempPipeFileReleaseMemory(ptpf);
		return NULL;
	}


	// Create a temporary file name
	//
	strncpy ( tempName, fnNwGetEnvironmentStr((char *)"TEMP", NWDEFPERLTEMP), (_MAX_PATH - 20) );
	tempName[_MAX_PATH-20] = '\0';
	strcat(tempName, (char *)"\\plXXXXXX.tmp");
	if (!fnMy_MkTemp(tempName))
	{
		fnTempPipeFileReleaseMemory(ptpf);
		return NULL;
	}

	// create a temporary place-holder file
	fclose(fopen(tempName, (char *)"w"));
	strcpy(ptpf->m_fileName, tempName);


	// Make the argument array
	if(!fnPipeFileMakeArgv(ptpf))
	{
		fnTempPipeFileReleaseMemory(ptpf);

		// Release additional memory
		if(ptpf->m_argv != NULL)
		{
			for(i=0; i<ptpf->m_argv_len; i++)
			{
				if(ptpf->m_argv[i] != NULL)
				{
					free(ptpf->m_argv[i]);
					ptpf->m_argv[i] = NULL;
				}
			}

			free(ptpf->m_argv);
			ptpf->m_argv = NULL;
		}

		return NULL;
	}


	// Open the temp file in the appropriate way...
	//
	if (!ptpf->m_mode)	// If Read mode?
	{
		// we wish to spawn a command, intercept its output,
		// and then get that output
		//
		if (!ptpf->m_argv[0])
		{
			fnTempPipeFileReleaseMemory(ptpf);

			// Release additional memory
			if(ptpf->m_argv != NULL)
			{
				for(i=0; i<ptpf->m_argv_len; i++)
				{
					if(ptpf->m_argv[i] != NULL)
					{
						free(ptpf->m_argv[i]);
						ptpf->m_argv[i] = NULL;
					}
				}

				free(ptpf->m_argv);
				ptpf->m_argv = NULL;
			}

			return NULL;
		}

		if (ptpf->m_launchPerl)
			fnPipeFileDoPerlLaunch(ptpf);
		else
			if (ptpf->m_doPerlGlob)
				fnDoPerlGlob(ptpf->m_argv, ptpf->m_fileName);	// hack to do perl globbing
		else
			spawnvp(P_WAIT, ptpf->m_argv[0], ptpf->m_argv);

		ptpf->m_file = fopen (ptpf->m_fileName, (char *)"r");	// Get the Pipe file handle
	}
	else if (ptpf->m_mode)	// If Write mode?
	{
		// we wish to open the file for writing now and
		// do the command later
		//
		ptpf->m_file = fopen(ptpf->m_fileName, (char *)"w");
	}

	fnTempPipeFileReleaseMemory(ptpf);

	// Release additional memory
	if(ptpf->m_argv != NULL)
	{
		for(i=0; i<(ptpf->m_argv_len); i++)
		{
			if(ptpf->m_argv[i] != NULL)
			{
				free(ptpf->m_argv[i]);
				ptpf->m_argv[i] = NULL;
			}
		}

		free(ptpf->m_argv);
		ptpf->m_argv = NULL;
	}

		
	return ptpf->m_file;	// Return the Pipe file handle.
}


/*============================================================================================

 Function		:	fnPipeFileClose

 Description	:	This function closes the pipe file.

 Parameters 	:	ptpf	(IN)	-	Input structure.

 Returns		:	Nothing.

==============================================================================================*/

void fnPipeFileClose(PTEMPPIPEFILE ptpf)
{
	int i = 0;

	if (ptpf->m_mode)	// If Write mode?
	{
		// we wish to spawn a command using our temp file for
		// its input
		//
		if(ptpf->m_file != NULL)
		{
			fclose (ptpf->m_file);
			ptpf->m_file = NULL;
		}

		if (ptpf->m_launchPerl)
			fnPipeFileDoPerlLaunch(ptpf);
		else if (ptpf->m_argv)
			spawnvp(P_WAIT, ptpf->m_argv[0], ptpf->m_argv);
	}


	// Close the temporary Pipe File, if opened
	if (ptpf->m_file)
	{
		fclose(ptpf->m_file);
		ptpf->m_file = NULL;
	}
	// Delete the temporary Pipe Filename if still valid and free the memory associated with the file name.
	if(ptpf->m_fileName != NULL)
	{
//		if (strlen(ptpf->m_fileName))
		if (ptpf->m_fileName)
			unlink(ptpf->m_fileName);

		free(ptpf->m_fileName);
		ptpf->m_fileName = NULL;
	}

/**
	if(ptpf->m_argv != NULL)
	{
		for(i=0; i<(ptpf->m_argv_len); i++)
		{
			if(ptpf->m_argv[i] != NULL)
			{
				free(ptpf->m_argv[i]);
				ptpf->m_argv[i] = NULL;
			}
		}

		free(ptpf->m_argv);
		ptpf->m_argv = NULL;
	}
**/

	if (ptpf->m_perlSynchSemaphore)
	{
		#ifdef MPK_ON
			kSemaphoreFree(ptpf->m_perlSynchSemaphore);
		#else
			CloseLocalSemaphore(ptpf->m_perlSynchSemaphore);
		#endif	//MPK_ON
	}


	return;
}


/*============================================================================================

 Function		:	fnPipeFileDoPerlLaunch

 Description	:	This function launches Perl.

 Parameters 	:	ptpf	(IN)	-	Input structure.

 Returns		:	Nothing.

==============================================================================================*/

void fnPipeFileDoPerlLaunch(PTEMPPIPEFILE ptpf)
{
	char curdir[_MAX_PATH] = {'\0'};
	char* pcwd = NULL;

	int i=0;


	// save off the current working directory to restore later
	// this is just a hack! these problems of synchronization and
	// restoring calling context need a much better solution!
	pcwd = (char *)getcwd(curdir, sizeof(curdir)-1);
	fnSystemCommand(ptpf->m_argv, ptpf->m_argv_len);
	if (ptpf->m_perlSynchSemaphore)
	{
		#ifdef MPK_ON
			kSemaphoreWait(ptpf->m_perlSynchSemaphore);
		#else
			WaitOnLocalSemaphore(ptpf->m_perlSynchSemaphore);
		#endif	//MPK_ON
	}

	if (pcwd)
		chdir(pcwd);

	return;
}


/*============================================================================================

 Function		:	fnTempPipeFile

 Description	:	This function initialises the variables of the structure passed in.

 Parameters 	:	ptpf	(IN)	-	Input structure.

 Returns		:	Nothing.

==============================================================================================*/

void fnTempPipeFile(PTEMPPIPEFILE ptpf)
{
	ptpf->m_fileName = NULL;

	ptpf->m_mode = FALSE;	// Default mode = Read mode.
	ptpf->m_file = NULL;
	ptpf->m_pipeCommand = NULL;
	ptpf->m_argv = NULL;

	ptpf->m_redirect = NULL;

	ptpf->m_launchPerl = FALSE;
	ptpf->m_doPerlGlob = FALSE;

	#ifdef MPK_ON
		ptpf->m_perlSynchSemaphore = NULL;
	#else
		ptpf->m_perlSynchSemaphore = 0L;
	#endif

	ptpf->m_argv_len = 0;

	return;
}


/*============================================================================================

 Function		:	fnTempPipeFileReleaseMemory

 Description	:	This function frees the memory allocated to various buffers.

 Parameters 	:	ptpf	(IN)	-	Input structure.

 Returns		:	Nothing.

==============================================================================================*/

void fnTempPipeFileReleaseMemory(PTEMPPIPEFILE ptpf)
{
	int i=0;


	if (ptpf->m_pipeCommand)
	{
		if(ptpf->m_pipeCommand->m_argv != NULL)
		{
			for(i=0; i<ptpf->m_pipeCommand->m_argv_len; i++)
			{
				if(ptpf->m_pipeCommand->m_argv[i] != NULL)
				{
					free(ptpf->m_pipeCommand->m_argv[i]);
					ptpf->m_pipeCommand->m_argv[i] = NULL;
				}
			}

			free(ptpf->m_pipeCommand->m_argv);
			ptpf->m_pipeCommand->m_argv = NULL;
		}

		if(ptpf->m_pipeCommand->sSkippedToken != NULL)
		{
			free(ptpf->m_pipeCommand->sSkippedToken);
			ptpf->m_pipeCommand->sSkippedToken = NULL;
		}
/****
// Commented since these are not being used.  Still retained here.
// To be removed once things are proved to be working fine to a good confident level,

		if(ptpf->m_pipeCommand->nextarg)
		{
			free(ptpf->m_pipeCommand->nextarg);
			ptpf->m_pipeCommand->nextarg = NULL;
		}

		if(ptpf->m_pipeCommand->m_redirInName)
		{
			free(ptpf->m_pipeCommand->m_redirInName);
			ptpf->m_pipeCommand->m_redirInName = NULL;
		}
		if(ptpf->m_pipeCommand->m_redirOutName)
		{
			free(ptpf->m_pipeCommand->m_redirOutName);
			ptpf->m_pipeCommand->m_redirOutName = NULL;
		}
		if(ptpf->m_pipeCommand->m_redirErrName)
		{
			free(ptpf->m_pipeCommand->m_redirErrName);
			ptpf->m_pipeCommand->m_redirErrName = NULL;
		}
		if(ptpf->m_pipeCommand->m_redirBothName)
		{
			free(ptpf->m_pipeCommand->m_redirBothName);
			ptpf->m_pipeCommand->m_redirBothName = NULL;
		}
****/

		if(ptpf->m_pipeCommand != NULL)
		{
			free(ptpf->m_pipeCommand);
			ptpf->m_pipeCommand = NULL;
		}
	}

	if(ptpf->m_redirect != NULL)
	{
		free(ptpf->m_redirect);
		ptpf->m_redirect = NULL;
	}

	return;
}