xref: /dports/editors/e93/e93/xgui/tasks.c

// Routines to allow tasks to run under the editor
// Copyright (C) 2000 Core Technologies.

// This file is part of e93.
//
// e93 is free software; you can redistribute it and/or modify
// it under the terms of the e93 LICENSE AGREEMENT.
//
// e93 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// e93 LICENSE AGREEMENT for more details.
//
// You should have received a copy of the e93 LICENSE AGREEMENT
// along with e93; see the file "LICENSE.TXT".

#include	"includes.h"

enum
{
	NO_TASK,
	STDIN_CLOSED,
	WRITE_FAILED
};

static const char *errorDescriptions[]=
{
	"No current task",
	"Task's stdin is closed",
	"Write failed"
};

static bool OpenTaskPipes(EDITOR_TASK *task)
// Create pipes that will connect us to a task
// If there is a problem, SetError, return false
{
	int
		flags;

	if(pipe(&(task->fdin[0]))==0)
	{
		if(pipe(&(task->fdout[0]))==0)
		{
			flags=fcntl(task->fdout[0],F_GETFL,0);
			flags|=O_NDELAY;						// turn off blocking on read or tasks stdout
			fcntl(task->fdout[0],F_SETFL,flags);

			task->closedStdin=false;				// have not closed the input to the task
			return(true);
		}
		else
		{
			SetStdCLibError();
		}
		close(task->fdin[0]);
		close(task->fdin[1]);
	}
	else
	{
		SetStdCLibError();
	}
	return(false);
}

static void CloseUnusedParentPipes(EDITOR_TASK *task)
// Close the half of the pipes that are not needed on the parent side
{
	close(task->fdin[0]);
	close(task->fdout[1]);
}

static void CloseUnusedChildPipes(EDITOR_TASK *task)
// Close the half of the pipes that are not needed on the child side
{
	close(task->fdin[1]);
	close(task->fdout[0]);
}

static void CloseRemainingPipes(EDITOR_TASK *task)
// Once the child is gone, this is used to close any pipes that remain open
{
	if(!task->closedStdin)						// this part of the pipe can be closed before we get here, if an EOF has been sent to the task
	{
		close(task->fdin[1]);
	}
	close(task->fdout[0]);
}

static void CloseTaskPipes(EDITOR_TASK *task)
// close pipes opened by OpenTaskPipes
{
	close(task->fdin[0]);
	close(task->fdin[1]);
	close(task->fdout[0]);
	close(task->fdout[1]);
}

static bool SpawnTask(EDITOR_BUFFER *buffer,UINT8 *data)
// Spawn off a task return true if it spawned
// SetError, and return false if there was a problem
{
	int
		forkResult;

	if((buffer->task=(EDITOR_TASK *)MNewPtr(sizeof(EDITOR_TASK))))	// create task record
	{
		buffer->taskBytes=0;
		if(OpenTaskPipes(buffer->task))					// open pipes to the task
		{
			if((forkResult=fork()))						// parent process gets child ID back
			{
				if(forkResult>0)
				{
					CloseUnusedParentPipes(buffer->task);	// close the half of the pipes which are meaningless to us
					buffer->task->pid=forkResult;		// set the process ID
					return(true);
				}
				else
				{
					SetStdCLibError();
				}
			}
			else										// child process gets 0 back
			{
				CloseUnusedChildPipes(buffer->task);	// close the half of the pipes which are meaningless to us
				setsid();								// make a process group with this as the leader
				dup2(buffer->task->fdin[0],0);			// create stdin
				dup2(buffer->task->fdout[1],1);			// create stdout
				dup2(buffer->task->fdout[1],2);			// create stderr

				execl("/bin/sh","sh","-c",data,NULL);	// start the shell running in the child fork (if this works, we're done)
				_exit(-1);								// our task did not start, so bail out (use _exit to avoid flushing twice)
			}
			CloseTaskPipes(buffer->task);				// failed to fork, close down pipes
		}
		MDisposePtr(buffer->task);
	}
	buffer->task=NULL;
	return(false);
}

bool WriteBufferTaskData(EDITOR_BUFFER *buffer,UINT8 *data,UINT32 numBytes)
// Send numBytes to the standard input of the task running in buffer.
// If no task is running in buffer, send data to execl, starting
// a task.
// If there is a problem writing data, SetError, return false.
{
	int
		result;

	if(buffer->task)								// task??
	{
		if(!buffer->task->closedStdin)				// make sure it has not been closed
		{
			result=write(buffer->task->fdin[1],data,numBytes);	// write data to "stdin" of task
			if(result>=0)
			{
				return(true);
			}
			else
			{
				SetError(errorDescriptions[WRITE_FAILED]);
			}
		}
		else
		{
			SetError(errorDescriptions[STDIN_CLOSED]);
		}
	}
	else
	{
		if(SpawnTask(buffer,data))					// start the task
		{
			if(buffer->window)
			{
				AdjustDocumentWindowStatus(buffer->window);	// status bar needs updating now
			}
			return(true);
		}
	}
	return(false);
}

bool SendEOFToBufferTask(EDITOR_BUFFER *buffer)
// Send an EOF to the input of the task running in buffer
// If no task is running in buffer, or there
// is some other problem, SetError, return false
{
	if(buffer->task)
	{
		if(!buffer->task->closedStdin)				// if closed already, complain
		{
			close(buffer->task->fdin[1]);			// close the side of the tasks stdin pipe that we write into, this will send an EOF to the task
			buffer->task->closedStdin=true;
			return(true);
		}
		else
		{
			SetError(errorDescriptions[STDIN_CLOSED]);
		}
	}
	else
	{
		SetError(errorDescriptions[NO_TASK]);
	}
	return(false);
}

#define	TASK_DATA_BUFFER_SIZE	8192

static char
	taskData[TASK_DATA_BUFFER_SIZE];

static bool ReadTaskData(EDITOR_BUFFER *buffer,bool *didUpdate)
// See if the task in buffer has any output it wants to send,
// If so, dump it into buffer
// Return didUpdate=true if output was placed into buffer
// If there is a problem, SetError, return false
// NOTE: the test for errno==EWOULDBLOCK is needed, because
// read does not want to return the fact that it read 0 bytes in
// non-blocking mode, If it did return 0, we might think it hit EOF.
{
	int
		numRead;

	*didUpdate=false;
	if(((numRead=read(buffer->task->fdout[0],&(taskData[0]),TASK_DATA_BUFFER_SIZE))>=0)||errno==EWOULDBLOCK)
	{
		if(numRead>0)
		{
			buffer->taskBytes+=numRead;
			InsertBufferTaskData(buffer,(UINT8 *)&(taskData[0]),numRead);
			*didUpdate=true;
		}
		return(true);
	}
	else
	{
		SetStdCLibError();
	}
	return(false);
}

void DisconnectBufferTask(EDITOR_BUFFER *buffer)
// Disconnect ourselves from any task that is running in buffer
// If no task is running, do nothing
// NOTE: this does not need to kill the task, and it is usually desirable
// NOT to kill the task
{
	if(buffer->task)
	{
		CloseRemainingPipes(buffer->task);
		MDisposePtr(buffer->task);
		buffer->task=NULL;
		if(buffer->window)
		{
			AdjustDocumentWindowStatus(buffer->window);	// status bar needs updating now
		}
	}
}

bool UpdateBufferTask(EDITOR_BUFFER *buffer,bool *didUpdate)
// See if there is a task connected to buffer
// If so, update the task by reading data from it, and adding
// it to buffer
// Return didUpdate set true if the task provided some data, false otherwise
// If there is a problem, SetError, and return false
{
	int
		pid;
	int
		statusp;
	bool
		hadUpdate,
		readOk;

	waitpid(-1,&statusp,WNOHANG);				// get info about any of our children who have died (this will allow children that were started (but since, closed the pipes to) to die, and not lie around <defunct>)

	*didUpdate=false;
	if(buffer->task)							// see if there is a task active in this buffer if not, complain
	{
		pid=waitpid(buffer->task->pid,&statusp,WNOHANG);	// check status of the task
		if(pid==0)								// if status 0, it is still running
		{
			return(ReadTaskData(buffer,didUpdate));	// inhale some data from the task
		}
		else
		{
			while((readOk=ReadTaskData(buffer,&hadUpdate))&&hadUpdate)	// inhale any data left in the pipeline
			{
				*didUpdate=true;
			}
			DisconnectBufferTask(buffer);		// no more task associated with this buffer
			return(readOk);
		}
	}
	else
	{
		SetError(errorDescriptions[NO_TASK]);
	}
	return(false);
}

bool UpdateBufferTasks()
// Run through all the buffers, see if any has a task that has
// data to be placed into its buffer, if so do it
// If there is a problem, ignore it!
// return true if something was updated, false otherwise
// NOTE: this is never called from the high-level part of the editor
// it is just here as a convenience to event handler.
{
	EDITOR_BUFFER
		*buffer;
	bool
		hadUpdate,
		didUpdate;

	didUpdate=hadUpdate=false;
	buffer=EditorGetFirstBuffer();
	while(buffer)
	{
		if(buffer->task)
		{
			UpdateBufferTask(buffer,&hadUpdate);
			if(hadUpdate)
			{
				didUpdate=true;
			}
		}
		buffer=EditorGetNextBuffer(buffer);
	}
	return(didUpdate);
}

bool KillBufferTask(EDITOR_BUFFER *buffer)
// Signal the task that is running in buffer to quit
// If no task is running, SetError, return false
{
	if(buffer->task)
	{
		kill(-(buffer->task->pid),SIGHUP);		// be nice, just send HUP, don't go for the total SIGKILL
		return(true);
	}
	else
	{
		SetError(errorDescriptions[NO_TASK]);
	}
	return(false);
}