/*
 * CINELERRA
 * Copyright (C) 1997-2014 Adam Williams <broadcast at earthling dot net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "bcsignals.h"
#include "bcwindowbase.h"
#include "bckeyboard.h"

#include <ctype.h>
#include <dirent.h>
#include <execinfo.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
#include <sys/types.h>

BC_Signals* BC_Signals::global_signals = 0;
static int signal_done = 0;
static int table_id = 0;

static bc_locktrace_t* new_bc_locktrace(void *ptr,
	const char *title,
	const char *location)
{
	bc_locktrace_t *result = (bc_locktrace_t*)malloc(sizeof(bc_locktrace_t));
	result->ptr = ptr;
	result->title = title;
	result->location = location;
	result->is_owner = 0;
	result->id = table_id++;
	result->tid = pthread_self();
	return result;
}


static struct sigaction old_segv = {0, }, old_intr = {0, };
static void handle_dump(int n, siginfo_t * info, void *sc);

const char *BC_Signals::trap_path = 0;
void *BC_Signals::trap_data = 0;
void (*BC_Signals::trap_hook)(FILE *fp, void *data) = 0;
bool BC_Signals::trap_sigsegv = false;
bool BC_Signals::trap_sigintr = false;

static void uncatch_sig(int sig, struct sigaction &old)
{
	struct sigaction act;
	sigaction(sig, &old, &act);
	old.sa_handler = 0;
}

static void catch_sig(int sig, struct sigaction &old)
{
	struct sigaction act;
	memset(&act, 0, sizeof(act));
	act.sa_sigaction = handle_dump;
	act.sa_flags = SA_SIGINFO;
	sigaction(sig, &act, (!old.sa_handler ? &old : 0));
}

static void uncatch_intr() { uncatch_sig(SIGINT, old_intr); }
static void catch_intr() { catch_sig(SIGINT, old_intr); }
static void uncatch_segv() { uncatch_sig(SIGSEGV, old_segv); }
static void catch_segv() { catch_sig(SIGSEGV, old_segv); }

void BC_Signals::set_trap_path(const char *path)
{
	trap_path = path;
}

void BC_Signals::set_trap_hook(void (*hook)(FILE *fp, void *vp), void *data)
{
	trap_data = data;
	trap_hook = hook;
}

void BC_Signals::set_catch_segv(bool v) {
	if( v == trap_sigsegv ) return;
	if( v ) catch_segv();
	else uncatch_segv();
	v = trap_sigsegv;
}

void BC_Signals::set_catch_intr(bool v) {
	if( v == trap_sigintr ) return;
	if( v ) catch_intr();
	else uncatch_intr();
	v = trap_sigintr;
}

typedef struct
{
	int size;
	void *ptr;
	const char *location;
} bc_buffertrace_t;

static bc_buffertrace_t* new_bc_buffertrace(int size, void *ptr, const char *location)
{
	bc_buffertrace_t *result = (bc_buffertrace_t*)malloc(sizeof(bc_buffertrace_t));
	result->size = size;
	result->ptr = ptr;
	result->location = location;
	return result;
}

static void bc_copy_textfile(FILE *ofp, const char *fmt,...)
{
	va_list ap;    va_start(ap, fmt);
	char bfr[BCTEXTLEN];  vsnprintf(bfr, sizeof(bfr), fmt, ap);
	va_end(ap);
	FILE *ifp = fopen(bfr,"r");
	if( !ifp ) return;
	while( fgets(bfr,sizeof(bfr),ifp) ) fputs(bfr,ofp);
	fclose(ifp);
}


// Need our own table to avoid recursion with the memory manager
typedef struct
{
	void **values;
	int size;
	int allocation;
// This points to the next value to replace if the table wraps around
	int current_value;
} bc_table_t;

static void* append_table(bc_table_t *table, void *ptr)
{
	if(table->allocation <= table->size)
	{
		if(table->allocation)
		{
			int new_allocation = table->allocation * 2;
			void **new_values = (void**)calloc(new_allocation, sizeof(void*));
			memcpy(new_values, table->values, sizeof(void*) * table->size);
			free(table->values);
			table->values = new_values;
			table->allocation = new_allocation;
		}
		else
		{
			table->allocation = 4096;
			table->values = (void**)calloc(table->allocation, sizeof(void*));
		}
	}

	table->values[table->size++] = ptr;
	return ptr;
}

// Replace item in table pointed to by current_value and advance
// current_value
static void* overwrite_table(bc_table_t *table, void *ptr)
{
	free(table->values[table->current_value]);
	table->values[table->current_value++] = ptr;
	if(table->current_value >= table->size) table->current_value = 0;
	return 0;
}

static void clear_table(bc_table_t *table, int delete_objects)
{
	if(delete_objects)
	{
		for(int i = 0; i < table->size; i++)
		{
			free(table->values[i]);
		}
	}
	table->size = 0;
}

static void clear_table_entry(bc_table_t *table, int number, int delete_object)
{
	if(delete_object) free(table->values[number]);
	for(int i = number; i < table->size - 1; i++)
	{
		table->values[i] = table->values[i + 1];
	}
	table->size--;
}

// Table of functions currently running.
static bc_table_t execution_table = { 0, 0, 0, 0 };

// Table of locked positions
static bc_table_t lock_table = { 0, 0, 0, 0 };

// Table of buffers
static bc_table_t memory_table = { 0, 0, 0, 0 };

static bc_table_t temp_files = { 0, 0, 0, 0 };

// Can't use Mutex because it would be recursive
static pthread_mutex_t *lock = 0;
static pthread_mutex_t *handler_lock = 0;
// incase lock set after task ends
static pthread_t last_lock_thread = 0;
static const char *last_lock_title = 0;
static const char *last_lock_location = 0;
// Don't trace memory until this is true to avoid initialization
static int trace_memory = 0;


static const char* signal_titles[] =
{
	"NULL",
	"SIGHUP",
	"SIGINT",
	"SIGQUIT",
	"SIGILL",
	"SIGTRAP",
	"SIGABRT",
	"SIGBUS",
	"SIGFPE",
	"SIGKILL",
	"SIGUSR1",
	"SIGSEGV",
	"SIGUSR2",
	"SIGPIPE",
	"SIGALRM",
	"SIGTERM"
};

void BC_Signals::dump_stack(FILE *fp)
{
	void *buffer[256];
	int total = backtrace (buffer, 256);
	char **result = backtrace_symbols (buffer, total);
	fprintf(fp, "BC_Signals::dump_stack\n");
	for(int i = 0; i < total; i++)
	{
		fprintf(fp, "%s\n", result[i]);
	}
}

// Kill subprocesses
void BC_Signals::kill_subs()
{
// List /proc directory
	DIR *dirstream;
	struct dirent64 *new_filename;
	struct stat ostat;
	char path[BCTEXTLEN];
	char string[BCTEXTLEN];

	dirstream = opendir("/proc");
	if(!dirstream) return;

	while( (new_filename = readdir64(dirstream)) != 0 )
	{
// All digits are numbers
		char *ptr = new_filename->d_name;
		int got_alpha = 0;
		while(*ptr)
		{
			if(*ptr == '.' || isalpha(*ptr++))
			{
				got_alpha = 1;
				break;
			}
		}

		if(got_alpha) continue;

// Must be a directory
		sprintf(path, "/proc/%s", new_filename->d_name);
		if(!stat(path, &ostat))
		{
			if(S_ISDIR(ostat.st_mode))
			{
// Read process stat
				strcat(path, "/stat");
//printf("kill_subs %d %s\n", __LINE__, path);
				FILE *fd = fopen(path, "r");

// Must search forwards because the file is 0 length
				if(fd)
				{
					while(!feof(fd))
					{
						char c = fgetc(fd);
//printf("kill_subs %d %d\n", __LINE__, c);
						if(c == ')')
						{
// Search for 2 spaces
							int spaces = 0;
							while(!feof(fd) && spaces < 2)
							{
								c = fgetc(fd);
								if(c == ' ')
									spaces++;
							}

// Read in parent process
							ptr = string;
							while(!feof(fd))
							{
								*ptr = fgetc(fd);
								if(*ptr == ' ')
								{
									*ptr = 0;
									break;
								}
								ptr++;
							}

// printf("kill_subs %d process=%d getpid=%d parent_process=%d\n",
// __LINE__,
// atoi(new_filename->d_name),
// getpid(),
// atoi(string));
							int parent_process = atoi(string);
							int child_process = atoi(new_filename->d_name);

// Kill if we're the parent
							if(getpid() == parent_process)
							{
//printf("kill_subs %d: process=%d\n", __LINE__, atoi(new_filename->d_name));
								kill(child_process, SIGKILL);
							}
						}
					}

					fclose(fd);
				}
			}
		}
	}
}

static void signal_entry(int signum)
{
	signal(signum, SIG_DFL);

	pthread_mutex_lock(handler_lock);
	if(signal_done)
	{
		pthread_mutex_unlock(handler_lock);
		exit(0);
	}

	signal_done = 1;
	pthread_mutex_unlock(handler_lock);


	printf("signal_entry: got %s my pid=%d execution table size=%d:\n",
		signal_titles[signum],
		getpid(),
		execution_table.size);

	BC_Signals::kill_subs();
	BC_Signals::dump_traces();
	BC_Signals::dump_locks();
	BC_Signals::dump_buffers();
	BC_Signals::delete_temps();

// Call user defined signal handler
	BC_Signals::global_signals->signal_handler(signum);

	abort();
}

static void signal_entry_recoverable(int signum)
{
	printf("signal_entry_recoverable: got %s my pid=%d\n",
		signal_titles[signum],
		getpid());
}

// used to terminate child processes when program terminates
static void handle_exit(int signum)
{
//printf("child %d exit\n", getpid());
	exit(0);
}

void BC_Signals::set_sighup_exit(int enable)
{
	if( enable ) {
// causes SIGHUP to be generated when parent dies
		signal(SIGHUP, handle_exit);
		prctl(PR_SET_PDEATHSIG, SIGHUP, 0,0,0);
// prevents ^C from signalling child when attached to gdb
		setpgid(0, 0);
		if( isatty(0) ) ioctl(0, TIOCNOTTY, 0);
	}
	else {
		signal(SIGHUP, signal_entry);
		prctl(PR_SET_PDEATHSIG, 0,0,0,0);
	}
}

BC_Signals::BC_Signals()
{
}

void BC_Signals::dump_traces(FILE *fp)
{
// Dump trace table
	if(execution_table.size)
	{
		for(int i = execution_table.current_value; i < execution_table.size; i++)
			fprintf(fp,"    %s\n", (char*)execution_table.values[i]);
		for(int i = 0; i < execution_table.current_value; i++)
			fprintf(fp,"    %s\n", (char*)execution_table.values[i]);
	}

}

void BC_Signals::dump_locks(FILE *fp)
{
// Dump lock table
#ifdef TRACE_LOCKS
	fprintf(fp,"signal_entry: lock table size=%d\n", lock_table.size);
	for(int i = 0; i < lock_table.size; i++)
	{
		bc_locktrace_t *table = (bc_locktrace_t*)lock_table.values[i];
		fprintf(fp,"    %p %s %s %p%s\n", table->ptr,
			table->title, table->location, (void*)table->tid,
			table->is_owner ? " *" : "");
	}
#endif
}

void BC_Signals::dump_buffers(FILE *fp)
{
#ifdef TRACE_MEMORY
	pthread_mutex_lock(lock);
// Dump buffer table
	fprintf(fp,"BC_Signals::dump_buffers: buffer table size=%d\n", memory_table.size);
	for(int i = 0; i < memory_table.size; i++)
	{
		bc_buffertrace_t *entry = (bc_buffertrace_t*)memory_table.values[i];
		fprintf(fp,"    %d %p %s\n", entry->size, entry->ptr, entry->location);
	}
	pthread_mutex_unlock(lock);
#endif
}

void BC_Signals::delete_temps()
{
	pthread_mutex_lock(lock);
	if(temp_files.size) printf("BC_Signals::delete_temps: deleting %d temp files\n", temp_files.size);
	for(int i = 0; i < temp_files.size; i++)
	{
		printf("    %s\n", (char*)temp_files.values[i]);
		remove((char*)temp_files.values[i]);
	}
	pthread_mutex_unlock(lock);
}

void BC_Signals::reset_locks()
{
	pthread_mutex_unlock(lock);
}

void BC_Signals::set_temp(char *string)
{
	char *new_string = strdup(string);
	append_table(&temp_files, new_string);
}

void BC_Signals::unset_temp(char *string)
{
	for(int i = 0; i < temp_files.size; i++)
	{
		if(!strcmp((char*)temp_files.values[i], string))
		{
			clear_table_entry(&temp_files, i, 1);
			break;
		}
	}
}


int BC_Signals::x_error_handler(Display *display, XErrorEvent *event)
{
	char string[1024];
	XGetErrorText(event->display, event->error_code, string, 1024);
	fprintf(stderr, "BC_Signals::x_error_handler: error_code=%d opcode=%d,%d %s\n",
		event->error_code, event->request_code, event->minor_code, string);
	return 0;
}


void BC_Signals::initialize()
{
	BC_Signals::global_signals = this;
	lock = (pthread_mutex_t*)calloc(1, sizeof(pthread_mutex_t));
	handler_lock = (pthread_mutex_t*)calloc(1, sizeof(pthread_mutex_t));
	pthread_mutex_init(lock, 0);
	pthread_mutex_init(handler_lock, 0);
	old_err_handler = XSetErrorHandler(x_error_handler);
	initialize2();
}

void BC_Signals::terminate()
{
	BC_Signals::global_signals = 0;
	uncatch_segv();  uncatch_intr();
	signal(SIGHUP, SIG_DFL);
	signal(SIGINT, SIG_DFL);
	signal(SIGQUIT, SIG_DFL);
	signal(SIGTERM, SIG_DFL);
	signal(SIGFPE, SIG_DFL);
	signal(SIGPIPE, SIG_DFL);
	signal(SIGUSR2, SIG_DFL);
	XSetErrorHandler(old_err_handler);
}

// callable from debugger
extern "C"
void dump()
{
	BC_Signals::dump_traces();
	BC_Signals::dump_locks();
	BC_Signals::dump_buffers();
}

// kill SIGUSR2
void BC_Signals::signal_dump(int signum)
{
	BC_KeyboardHandler::kill_grabs();
	dump();
	signal(SIGUSR2, signal_dump);
}






void BC_Signals::initialize2()
{
	signal(SIGHUP, signal_entry);
	signal(SIGINT, signal_entry);
	signal(SIGQUIT, signal_entry);
	// SIGKILL cannot be stopped
	// signal(SIGKILL, signal_entry);
	catch_segv();
	signal(SIGTERM, signal_entry);
	signal(SIGFPE, signal_entry);
	signal(SIGPIPE, signal_entry_recoverable);
	signal(SIGUSR2, signal_dump);
}


void BC_Signals::signal_handler(int signum)
{
printf("BC_Signals::signal_handler\n");
//	exit(0);
}

const char* BC_Signals::sig_to_str(int number)
{
	return signal_titles[number];
}

#define TOTAL_TRACES 16

void BC_Signals::new_trace(const char *text)
{
	if(!global_signals) return;
	pthread_mutex_lock(lock);

// Wrap around
	if(execution_table.size >= TOTAL_TRACES)
	{
		overwrite_table(&execution_table, strdup(text));
//		clear_table(&execution_table, 1);
	}
	else
	{
		append_table(&execution_table, strdup(text));
	}
	pthread_mutex_unlock(lock);
}

void BC_Signals::new_trace(const char *file, const char *function, int line)
{
	char string[BCTEXTLEN];
	snprintf(string, BCTEXTLEN, "%s: %s: %d", file, function, line);
	new_trace(string);
}

void BC_Signals::delete_traces()
{
	if(!global_signals) return;
	pthread_mutex_lock(lock);
	clear_table(&execution_table, 0);
	pthread_mutex_unlock(lock);
}

// no canceling with lock held
void BC_Signals::lock_locks(const char *s)
{
	pthread_mutex_lock(lock);
	last_lock_thread = pthread_self();
	last_lock_title = s;
	last_lock_location = 0;
}

void BC_Signals::unlock_locks()
{
	pthread_mutex_unlock(lock);
}

#define TOTAL_LOCKS 256

int BC_Signals::set_lock(void *ptr,
	const char *title,
	const char *location)
{
	if(!global_signals) return 0;
	bc_locktrace_t *table = 0;
	int id_return = 0;

	pthread_mutex_lock(lock);
	last_lock_thread = pthread_self();
	last_lock_title = title;
	last_lock_location = location;
	if(lock_table.size >= TOTAL_LOCKS)
		clear_table(&lock_table, 0);

// Put new lock entry
	table = new_bc_locktrace(ptr, title, location);
	append_table(&lock_table, table);
	id_return = table->id;

	pthread_mutex_unlock(lock);
	return id_return;
}

void BC_Signals::set_lock2(int table_id)
{
	if(!global_signals) return;

	bc_locktrace_t *table = 0;
	pthread_mutex_lock(lock);
	for(int i = lock_table.size - 1; i >= 0; i--)
	{
		table = (bc_locktrace_t*)lock_table.values[i];
// Got it.  Hasn't been unlocked/deleted yet.
		if(table->id == table_id)
		{
			table->is_owner = 1;
			table->tid = pthread_self();
			pthread_mutex_unlock(lock);
			return;
		}
	}
	pthread_mutex_unlock(lock);
}

void BC_Signals::unset_lock2(int table_id)
{
	if(!global_signals) return;

	bc_locktrace_t *table = 0;
	pthread_mutex_lock(lock);
	for(int i = lock_table.size - 1; i >= 0; i--)
	{
		table = (bc_locktrace_t*)lock_table.values[i];
		if(table->id == table_id)
		{
			clear_table_entry(&lock_table, i, 1);
			break;
		}
	}
	pthread_mutex_unlock(lock);
}

void BC_Signals::unset_lock(void *ptr)
{
	if(!global_signals) return;

	bc_locktrace_t *table = 0;
	pthread_mutex_lock(lock);

// Take off currently held entry
	for(int i = 0; i < lock_table.size; i++)
	{
		table = (bc_locktrace_t*)lock_table.values[i];
		if(table->ptr == ptr)
		{
			if(table->is_owner)
			{
				clear_table_entry(&lock_table, i, 1);
				break;
			}
		}
	}

	pthread_mutex_unlock(lock);
}


void BC_Signals::unset_all_locks(void *ptr)
{
	if(!global_signals) return;
	pthread_mutex_lock(lock);
// Take off previous lock entry
	for(int i = 0; i < lock_table.size; )
	{
		bc_locktrace_t *table = (bc_locktrace_t*)lock_table.values[i];
		if(table->ptr == ptr)
		{
			clear_table_entry(&lock_table, i, 1);
			continue;
		}
		++i;
	}
	pthread_mutex_unlock(lock);
}

void BC_Signals::clear_locks_tid(pthread_t tid)
{
	if(!global_signals) return;
	pthread_mutex_lock(lock);
// Take off previous lock entry
	for(int i = 0; i < lock_table.size; )
	{
		bc_locktrace_t *table = (bc_locktrace_t*)lock_table.values[i];
		if(table->tid == tid)
		{
			clear_table_entry(&lock_table, i, 1);
			continue;
		}
		++i;
	}
	pthread_mutex_unlock(lock);
}


void BC_Signals::enable_memory()
{
	trace_memory = 1;
}

void BC_Signals::disable_memory()
{
	trace_memory = 0;
}


void BC_Signals::set_buffer(int size, void *ptr, const char* location)
{
	if(!global_signals) return;
	if(!trace_memory) return;

//printf("BC_Signals::set_buffer %p %s\n", ptr, location);
	pthread_mutex_lock(lock);
	append_table(&memory_table, new_bc_buffertrace(size, ptr, location));
	pthread_mutex_unlock(lock);
}

int BC_Signals::unset_buffer(void *ptr)
{
	if(!global_signals) return 0;
	if(!trace_memory) return 0;

	int ret = 1;
	pthread_mutex_lock(lock);
	for(int i = 0; i < memory_table.size; i++)
	{
		if(((bc_buffertrace_t*)memory_table.values[i])->ptr == ptr)
		{
//printf("BC_Signals::unset_buffer %p\n", ptr);
			clear_table_entry(&memory_table, i, 1);
			ret = 0;
			break;
		}
	}

	pthread_mutex_unlock(lock);
//	fprintf(stderr, "BC_Signals::unset_buffer buffer %p not found.\n", ptr);
	return ret;
}


#include <ucontext.h>
#include <sys/wait.h>
#include "thread.h"

#if __i386__
#define IP eip
#endif
#if __x86_64__
#define IP rip
#endif
#ifndef IP
#error gotta have IP
#endif


static void handle_dump(int n, siginfo_t * info, void *sc)
{
	uncatch_segv();  uncatch_intr();
	signal(SIGSEGV, SIG_DFL);
	signal(SIGINT, SIG_DFL);
	// gotta be root, or the dump is worthless
	int uid = getuid();
	if( uid != 0 ) return;
	ucontext_t *uc = (ucontext_t *)sc;
	int pid = getpid(), tid = gettid();
	struct sigcontext *c = (struct sigcontext *)&uc->uc_mcontext;
	fprintf(stderr,"** %s at %p in pid %d, tid %d\n",
		n==SIGSEGV? "segv" : n==SIGINT? "intr" : "trap",
		(void*)c->IP, pid, tid);
	FILE *fp = 0;
	char fn[PATH_MAX];
	if( BC_Signals::trap_path ) {
		snprintf(fn, sizeof(fn), BC_Signals::trap_path, pid);
		fp = fopen(fn,"w");
	}
	if( fp ) {
		fprintf(stderr,"writing debug data to %s\n", fn);
		fprintf(fp,"** %s at %p in pid %d, tid %d\n",
			n==SIGSEGV? "segv" : n==SIGINT? "intr" : "trap",
			(void*)c->IP, pid, tid);
	}
	else {
		strcpy(fn, "stdout");
		fp = stdout;
	}
	time_t t;  time(&t);
	fprintf(fp,"created on %s", ctime(&t));
	struct passwd *pw = getpwuid(uid);
	if( pw ) {
		fprintf(fp,"        by %d:%d %s(%s)\n",
			pw->pw_uid, pw->pw_gid, pw->pw_name, pw->pw_gecos);
	}
	fprintf(fp,"\nTHREADS:\n");  Thread::dump_threads(fp);
	fprintf(fp,"\nTRACES:\n");   BC_Signals::dump_traces(fp);
	fprintf(fp,"\nLOCKS:\n");    BC_Signals::dump_locks(fp);
	fprintf(fp,"\nBUFFERS:\n");  BC_Signals::dump_buffers(fp);
	if( BC_Signals::trap_hook ) {
		fprintf(fp,"\nMAIN HOOK:\n");
		BC_Signals::trap_hook(fp, BC_Signals::trap_data);
	}
	fprintf(fp,"\nVERSION:\n");  bc_copy_textfile(fp,"/proc/version");
	fprintf(fp,"\nMEMINFO:\n");  bc_copy_textfile(fp,"/proc/meminfo");
	fprintf(fp,"\nMAPS:\n");     bc_copy_textfile(fp,"/proc/%d/maps",pid);
	fprintf(fp,"\n\n");
	if( fp != stdout ) fclose(fp);
	char cmd[1024], *cp = cmd;
	cp += sprintf(cp, "exec gdb /proc/%d/exe -p %d --batch --quiet "
		"-ex \"thread apply all info registers\" "
		"-ex \"thread apply all bt full\" "
		"-ex \"quit\"", pid, pid);
	if( fp != stdout )
		cp += sprintf(cp," >> \"%s\"", fn);
	cp += sprintf(cp," 2>&1");
//printf("handle_dump:: pid=%d, cmd='%s'  fn='%s'\n",pid,cmd,fn);
        pid = vfork();
        if( pid < 0 ) {
		fprintf(stderr,"** can't start gdb, dump abondoned\n");
		return;
	}
	if( pid > 0 ) {
		waitpid(pid,0,0);
		fprintf(stderr,"** dump complete\n");
		return;
	}
        char *const argv[4] = { (char*) "/bin/sh", (char*) "-c", cmd, 0 };
        execvp(argv[0], &argv[0]);
}





#ifdef TRACE_MEMORY

// void* operator new(size_t size)
// {
// //printf("new 1 %d\n", size);
//     void *result = malloc(size);
// 	BUFFER(size, result, "new");
// //printf("new 2 %d\n", size);
// 	return result;
// }
//
// void* operator new[](size_t size)
// {
// //printf("new [] 1 %d\n", size);
//     void *result = malloc(size);
// 	BUFFER(size, result, "new []");
// //printf("new [] 2 %d\n", size);
// 	return result;
// }
//
// void operator delete(void *ptr)
// {
// //printf("delete 1 %p\n", ptr);
// 	UNBUFFER(ptr);
// //printf("delete 2 %p\n", ptr);
//     free(ptr);
// }
//
// void operator delete[](void *ptr)
// {
// //printf("delete [] 1 %p\n", ptr);
// 	UNBUFFER(ptr);
//     free(ptr);
// //printf("delete [] 2 %p\n", ptr);
// }


#endif