TProcess

Archives Forums/MacOS X Discussion/TProcess

MacSven

(Posted 2012) [#1]

TProcess makes me freaky under MacOS X

if i use the TProcess with this it should not work:

temp_proc:tproc = CreateProc("./avrdude -q -patmega1284p -cusbasp -Uflash:w:"+chr$(34)+"/Volumes/MacOS X/Applications/BlitzMax/SourceFiles/CocoaExt/LunaAVR Test/Examples/BitAccess.hex"+chr$(34)+":a",1)

This is the error:

avrdude: AVR device initialized and ready to accept instructions
avrdude: Device signature = 0x1e9705
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file ""/Volumes/MacOS"
avrdude: error opening "/Volumes/MacOS: No such file or directory
avrdude: input file "/Volumes/MacOS auto detected as invalid format
avrdude: can't open input file "/Volumes/MacOS: No such file or directory
avrdude: write to file '"/Volumes/MacOS' failed

It is a problem with spaces in the filename. If i use the same command in the Terminal.app it works fine:

localhost:LunaAVR Test Sven$ avrdude -q -patmega1284p -cusbasp -Uflash:w:"/Volumes/MacOS X/Applications/BlitzMax/SourceFiles/CocoaExt/LunaAVR Test/Examples/BitAccess.hex":a

avrdude: AVR device initialized and ready to accept instructions
avrdude: Device signature = 0x1e9705
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "/Volumes/MacOS X/Applications/BlitzMax/SourceFiles/CocoaExt/LunaAVR Test/Examples/BitAccess.hex"
avrdude: input file /Volumes/MacOS X/Applications/BlitzMax/SourceFiles/CocoaExt/LunaAVR Test/Examples/BitAccess.hex auto detected as Intel Hex
avrdude: writing flash (2624 bytes):
avrdude: 2624 bytes of flash written
avrdude: verifying flash memory against /Volumes/MacOS X/Applications/BlitzMax/SourceFiles/CocoaExt/LunaAVR Test/Examples/BitAccess.hex:
avrdude: load data flash data from input file /Volumes/MacOS X/Applications/BlitzMax/SourceFiles/CocoaExt/LunaAVR Test/Examples/BitAccess.hex:
avrdude: input file /Volumes/MacOS X/Applications/BlitzMax/SourceFiles/CocoaExt/LunaAVR Test/Examples/BitAccess.hex auto detected as Intel Hex
avrdude: input file /Volumes/MacOS X/Applications/BlitzMax/SourceFiles/CocoaExt/LunaAVR Test/Examples/BitAccess.hex contains 2624 bytes
avrdude: reading on-chip flash data:
avrdude: verifying ...
avrdude: 2624 bytes of flash verified

Are the TProcess and the Terminal Command different!

skidracer

(Posted 2012) [#2]

Yes, CreateProcess will have problems with quotes used inside arguments. You will need to modify the makeargv code in freeprocess.c to get the above to work.

MacSven

(Posted 2012) [#3]

Ok,

But how, my c-programing is not so good as i realy want!

Yasha

(Posted 2012) [#4]

I've made no attempt at all to test this (written on a Windows box, ha!), but here's my off-the-top-of-my-head suggested change:

freeprocess.c

// freeprocess.c

#include <brl.mod/blitz.mod/blitz.h>

#include <stdio.h>
#include <stdbool.h>

#define HIDECONSOLE 1

#if __APPLE__ || __linux

#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/wait.h>

int fdClose(int fd) {return close(fd);}
int fdRead(int fd,char *buffer,int count) {return read(fd,buffer,count);}
int fdWrite(int fd,char *buffer,int count) {return write(fd,buffer,count);}
int fdAvail(int fd) {int avail;if (ioctl(fd,FIONREAD,&avail)) avail=avail;return avail;}
int fdFlush(int fd) {}//flush(fd);}

///return 1 for running, 0 for finished
//
int fdProcessStatus( int pid ){

	int status=0;
	return !waitpid( pid,&status,WNOHANG );
}

//returns 0 for success, -1 for error
//
int fdTerminateProcess(int pid){

	if( !killpg( pid,SIGTERM ) ){
		int status=0;
		waitpid( pid,&status,0 );
		return 0;
	}
	return -1;
}

static char **makeargv( const char *cmd ){
	int n;//,c;
	char *p;
	static char *args,**argv;
	
	if( args ) free( args );
	if( argv ) free( argv );
	
	int cmdlen = strlen(cmd);
	args = /*(char*)*/ malloc( cmdlen+1 );
	strcpy( args,cmd );
	
	char * temp_argv[cmdlen / 2]; // Max poss no. args if all 1 char
	
	n=0;
	p=args;
	while(*p) {
		int skipQ = 0;
		if( *p != ' ' ) {
			temp_argv[n] = p;
			bool inQ = false, esc = false;
			while (*p) {
				if (esc == false && (*p == '\'' || *p == '\"')) {
					inQ = !inQ; skipQ ++;
				} else {
					if (*p == '\\') {
						esc = !esc; 
					} else {
						if (esc == false && inQ == false && *p == ' ') { break; }
						esc = false;
					}
					if (skipQ) { p[- skipQ] = *p; }
				}
				p ++;
			}
			++n;
		}
		if (p[- skipQ]) { p[- skipQ] = 0; ++p; }
	}
	
	argv=/*(char**)*/malloc( (n+1)/* *sizeof(char*)*/ );
	
	int a;
	for (a = 0; a < n; a ++) {
		argv[a] = temp_argv[a];
	}
	argv[n] = NULL;
	
	return argv;
}

#define PIPEREAD 0
#define PIPEWRITE 1

static int in[2],out[2],errfd[2];

int fdProcess( BBString *bbcmd,int *procin,int *procout,int *procerr,int flags)
{
	char 	*const*argv;
	int   	procid;
	
	const char *cmd=bbTmpUTF8String(bbcmd);
	
	//Set-up interprocess communication
	if (pipe(in)) return 0;
  	if (pipe(out)) return 0;
  	if (pipe(errfd)) return 0;
	
	//Fork process (returned value used to distinguish between child and parent process)
	procid=vfork();	//vfork() avoids memory overhead of fork()
	
	//Child process
	if (procid==0)
	{
		#if __linux
			setsid(); //Linux doesn't mind setsid()
		#else
			setpgid(0,0);	//but OS X doesn't like it, therefore resort to using setpgid().
		#endif
		
		dup2(out[PIPEREAD],STDIN_FILENO);
		close(out[PIPEWRITE]);
		
		dup2(in[PIPEWRITE],STDOUT_FILENO);
		close(in[PIPEREAD]);
		
		dup2(errfd[PIPEWRITE],STDERR_FILENO);		
		close(errfd[PIPEREAD]);
		
		argv=makeargv(cmd);
		execvp(argv[0],argv);
		
		_exit( -1 );
		
		return 0;	//Supposedly, we need this for some compilers.
		
	}
	
	//Parent process
	
	if(procid==-1) return 0;	//Return if child process couldn't be started.
	
	close(out[PIPEREAD]);		//Close the end of the pipes in that the child
	close(in[PIPEWRITE]);		//process is using.
	close(errfd[PIPEWRITE]);
	
	*procin=in[PIPEREAD];		//And return the end of the pipes that we should
	*procout=out[PIPEWRITE];	//be using.
	*procerr=errfd[PIPEREAD];
	
	return procid;
}

#endif

#ifdef _WIN32

extern int _bbusew;

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tlhelp32.h>

int TerminateProcessGroup(HANDLE prochandle,int procid)
{
	HANDLE snapshot,child;
	PROCESSENTRY32 procinfo;
	int gotinfo,res;

	snapshot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
	if (snapshot!=INVALID_HANDLE_VALUE)
	{
		procinfo.dwSize=sizeof(procinfo);
		gotinfo=Process32First(snapshot,&procinfo);
		while (gotinfo)
		{
			if (procinfo.th32ParentProcessID==procid)
			{
//				printf("process=%x parent=%x module=%x path=%s\n",procinfo.th32ProcessID,procinfo.th32ParentProcessID,procinfo.th32ModuleID,procinfo.szExeFile);
				child=OpenProcess(PROCESS_ALL_ACCESS,0,procinfo.th32ProcessID);
				if (child)
				{
					res=TerminateProcess(child,-1);
					CloseHandle(child);
				}
			}
			gotinfo=Process32Next(snapshot,&procinfo);
		}
		CloseHandle(snapshot);
	}
	res=TerminateProcess(prochandle,-1);
	return res;
}

int fdClose(int fd)
{
	return CloseHandle((HANDLE)fd);
}

int fdRead(int fd,char *buffer,int bytes)
{
	int		res; 
	long	count;
	res=ReadFile((HANDLE)fd,buffer,bytes,&count,0);
	if (res) return count;
	return 0;
}

int fdWrite(int fd,char *buffer,int bytes)
{
	int		res;
	long	count;
	res=WriteFile((HANDLE)fd,buffer,bytes,&count,0);
	if (res) return count;
	return 0;
}

int fdFlush(int fd)
{
	int		res;
	res=FlushFileBuffers((HANDLE)fd);
	return res;
}

int fdAvail(int fd) 
{
	int		res;
	long	avail;
	res=PeekNamedPipe((HANDLE)fd,0,0,0,&avail,0);
	if (res) return avail;
	return 0;
}

//returns 1 for running, 0 for finished
int fdProcessStatus( int pid ){

	PROCESS_INFORMATION *pi=(PROCESS_INFORMATION *)pid;
	
	long exitcode;
	
	if( GetExitCodeProcess( pi->hProcess,&exitcode ) ){

		if( exitcode==STILL_ACTIVE ) return 1;
		
		CloseHandle( pi->hProcess );
		free( pi );
	}
	return 0;
}

//returns 0 for success
int fdTerminateProcess( int pid ){

	PROCESS_INFORMATION *pi=(PROCESS_INFORMATION *)pid;
	
	int res=TerminateProcessGroup( pi->hProcess,pi->dwProcessId );
	
	CloseHandle( pi->hProcess );
	free( pi );

	return res;
}

int fdProcess( BBString *cmd,int *procin,int *procout,int *procerr,int flags)
{
	int res;
	int pflags=CREATE_NEW_PROCESS_GROUP;
	PROCESS_INFORMATION *pi;
	SECURITY_ATTRIBUTES sa={sizeof(sa),0,1};
	HANDLE istr,p_ostr;	//our in-stream, process out-stream
	HANDLE ostr,p_istr;	//our out-stream, process in-stream
	HANDLE estr,p_estr;			//our errin-stream, process errout-stream

	if( !CreatePipe( &istr,&p_ostr,&sa,0 ) ){
		//unable to create pipe
		return 0;
	}

	if( !CreatePipe( &p_istr,&ostr,&sa,0 ) ){
		CloseHandle( istr );
		CloseHandle( p_ostr );
		//ditto
		return 0;
	}

	if (!CreatePipe(&estr,&p_estr,&sa,0)) {
		CloseHandle( istr );
		CloseHandle( p_ostr );
		CloseHandle( ostr );
		CloseHandle( p_istr );
		//unable to create pipe
		return 0;
	}

	pi=(PROCESS_INFORMATION*)calloc(1,sizeof(PROCESS_INFORMATION));
	
	if( _bbusew ){
		STARTUPINFOW si={sizeof(si)};

		si.dwFlags=STARTF_USESTDHANDLES;
		si.wShowWindow=SW_HIDE;
		si.hStdInput=p_istr;
		si.hStdOutput=p_ostr;
		si.hStdError=p_estr;
		if (flags&HIDECONSOLE) {
			si.dwFlags|=STARTF_USESHOWWINDOW;
			si.wShowWindow=SW_HIDE;
		}
		else {
			pflags|=DETACHED_PROCESS;
		}
		res=CreateProcessW( 0,bbTmpWString(cmd),0,0,-1,pflags,0,0,&si,pi );
	}else{
		STARTUPINFO si={sizeof(si)};

		si.dwFlags=STARTF_USESTDHANDLES;
		si.wShowWindow=SW_HIDE;
		si.hStdInput=p_istr;
		si.hStdOutput=p_ostr;
		si.hStdError=p_estr;
		if (flags&HIDECONSOLE) {
			si.dwFlags|=STARTF_USESHOWWINDOW;
			si.wShowWindow=SW_HIDE;
		}
		else {
			pflags|=DETACHED_PROCESS;
		}
		res=CreateProcess( 0,bbTmpCString(cmd),0,0,-1,pflags,0,0,&si,pi );
	}
	
	if( !res ){
		CloseHandle( istr );
		CloseHandle( ostr );
		CloseHandle( estr );
		CloseHandle( p_istr );
		CloseHandle( p_ostr );
		CloseHandle( p_estr );
		return 0;
	}
	
	CloseHandle( pi->hThread );
	
	*procin=(int)istr;
	*procout=(int)ostr;
	*procerr=(int)estr;

	CloseHandle( p_istr );
	CloseHandle( p_ostr );
	CloseHandle( p_estr );
	
	return (int)pi;
}

#endif

Changes are really just to makeargv, but it needs an extra #include so I pasted the whole thing.

In theory it should allow backslash escaped spaces and quotes, doublequoted and singlequoted substrings in arguments, and strip out the quotes before passing on the arg vector as expected by a command line. Makes no attempt to actually do backslash substitution though.

As warned above, I have not even tested to see if this so much as compiles correctly. Use at own risk.

Last edited 2012

MacSven

(Posted 2012) [#5]

Hi Yasha,

Replaces the code and try to build, i get this error:

/Applications/BlitzMax/mod/pub.mod/freeprocess.mod/freeprocess.c:84: error: 'for' loop initial declaration used outside C99 mode

The GCC Compiler does not supported the C99 mode. Any other idea?

MacSven

(Posted 2012) [#6]

Problem Solved:
Use this in you code it works fine on macos x

	argv=/*(char**)*/malloc( (n+1)/* *sizeof(char*)*/ );
	int a;
	for (a = 0; a < n; a ++) {
		argv[a] = temp_argv[a];
	}
	argv[n] = NULL;

Thanx you saved my life!

Yasha

(Posted 2012) [#7]

Ha, I was just pasting that change into the above codebox at the same time you were finding it.

It's odd, that code uses three or four much more interesting C99 features and it chooses to complain about that? For instance, technically I think your solution is actually a C99 feature as well (ANSI C required all variables to be defined at the top of the function!).

(In general, you can tell GCC to shut up with --std=c99 or even --std=c11, but in this case you'd need to modify the BlitzMax build process to make that change.)

Last edited 2012