Merge mysql.com:/home/wax/mysql/mysql-4.1 (716e3a57) · Commits · Software / OSDI20 Artifacts / mariadb

client/mysqltest.c

+21 −15

Original line number	Diff line number	Diff line
		@@ -181,9 +181,9 @@ typedef struct
		int alloced;
		} VAR;

		#ifdef __NETWARE__
		#if defined(__NETWARE__) \|\| defined(__WIN__)
		/*
		Netware doesn't proved environment variable substitution that is done
		Netware and Windows don't proved environment variable substitution that is done
		by the shell in unix environments. We do this in the following function:
		*/

		@@ -480,7 +480,7 @@ static void free_used_memory()
		free_defaults(default_argv);
		mysql_server_end();
		my_end(MY_CHECK_ERROR);
		DBUG_VOID_RETURN;
		// DBUG_VOID_RETURN;
		}

		static void die(const char* fmt, ...)
		@@ -852,8 +852,8 @@ int do_exec(struct st_query* q)
		char buf[1024];
		FILE *res_file;
		char *cmd= q->first_argument;
		DBUG_ENTER("do_exec");

		DBUG_ENTER("do_exec");
		while (cmd && my_isspace(charset_info, cmd))
		cmd++;
		if (!*cmd)
		@@ -902,8 +902,11 @@ int do_exec(struct st_query* q)
		if (ds == &ds_tmp)
		dynstr_free(&ds_tmp);
		}
		#ifndef __WIN__
		pclose(res_file);

		#else
		_pclose(res_file);
		#endif
		DBUG_RETURN(error);
		}

		@@ -1484,8 +1487,8 @@ void init_manager()
		die("Failed in mysql_manager_init()");
		if (!mysql_manager_connect(manager,manager_host,manager_user,
		manager_pass,manager_port))
		die("Could not connect to MySQL manager: %s(%d)",manager->last_error,
		manager->last_errno);
		die("Could not connect to MySQL manager: %s(%d) %d",manager->last_error,
		manager->last_errno, manager_port);

		}
		#endif
		@@ -1585,8 +1588,8 @@ int do_connect(struct st_query* q)
		if ((safe_connect(&next_con->mysql, con_host,
		con_user, con_pass,
		con_db, con_port, con_sock ? con_sock: 0)))
		die("Could not open connection '%s': %s", con_name,
		mysql_error(&next_con->mysql));
		die("Could not open connection '%s': %s %d", con_name,
		mysql_error(&next_con->mysql),con_port);

		if (!(next_con->name = my_strdup(con_name, MYF(MY_WME))))
		die(NullS);
		@@ -3670,8 +3673,7 @@ static void get_replace_column(struct st_query *q)
		my_free(start, MYF(0));
		}

		#ifdef __NETWARE__

		#if defined(__NETWARE__) \|\| defined(__WIN__)
		/*
		Substitute environment variables with text.

		@@ -3762,9 +3764,13 @@ FILE my_popen(const char cmd, const char *mode __attribute__((unused)))
		FILE *res_file;

		subst_cmd= subst_env_var(cmd);
		#ifndef __WIN__
		res_file= popen(subst_cmd, "r0");
		#else
		res_file= _popen(subst_cmd, "r0");
		#endif
		my_free(subst_cmd, MYF(0));
		return res_file;
		}

		#endif /* __NETWARE__ */
		#endif /* __NETWARE__ or __WIN__*/

mysql-test/Makefile.am

+5 −0

Original line number	Diff line number	Diff line
		@@ -36,6 +36,11 @@ test_SCRIPTS = mysql-test-run install_test_db
		test_DATA = std_data/client-key.pem std_data/client-cert.pem std_data/cacert.pem
		CLEANFILES = $(test_SCRIPTS) $(test_DATA)

		INCLUDES = -I$(srcdir)/../include -I../include -I..
		bin_PROGRAMS = mysql_test_run
		mysql_test_run_SOURCES= mysql_test_run.c my_manage.c


		dist-hook:
		mkdir -p $(distdir)/t $(distdir)/r $(distdir)/include \
		$(distdir)/std_data

mysql-test/my_manage.c

0 → 100644

+860 −0

Original line number	Diff line number	Diff line
		/*
		Copyright (c) 2003 Novell, Inc. All Rights Reserved.

		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 <stdio.h>
		#include <errno.h>
		#ifndef __WIN__
		#include <dirent.h>
		#endif
		#include <string.h>
		#ifdef __NETWARE__
		#include <screen.h>
		#include <proc.h>
		#else
		#include <sys/types.h>
		#ifndef __WIN__
		#include <sys/wait.h>
		#include <unistd.h>
		#else
		#include <direct.h>
		#include <stdlib.h>
		#include <stdio.h>
		#endif
		#endif
		#include <ctype.h>
		#include <sys/stat.h>
		#include <fcntl.h>
		#include <assert.h>

		#include "my_manage.h"

		#ifndef __NETWARE__
		#define ASSERT assert
		extern char **environ;
		#endif



		/******************************************************************************

		macros

		******************************************************************************/

		/******************************************************************************

		global variables

		******************************************************************************/

		/******************************************************************************

		functions

		******************************************************************************/

		/******************************************************************************

		init_args()

		Init an argument list.

		******************************************************************************/
		void init_args(arg_list_t *al)
		{
		ASSERT(al != NULL);

		al->argc = 0;
		al->size = ARG_BUF;
		al->argv = malloc(al->size * sizeof(char *));
		ASSERT(al->argv != NULL);

		return;
		}

		/******************************************************************************

		add_arg()

		Add an argument to a list.

		******************************************************************************/
		void add_arg(arg_list_t al, const char format, ...)
		{
		va_list ap;
		char temp[PATH_MAX];

		ASSERT(al != NULL);

		// increase size
		if (al->argc >= (int)al->size)
		{
		al->size += ARG_BUF;
		al->argv = realloc(al->argv, al->size * sizeof(char *));
		ASSERT(al->argv != NULL);
		}

		if (format)
		{
		va_start(ap, format);
		vsprintf(temp, format, ap);
		va_end(ap);

		al->argv[al->argc] = malloc(strlen(temp)+1);
		ASSERT(al->argv[al->argc] != NULL);
		strcpy(al->argv[al->argc], temp);

		++(al->argc);
		}
		else
		{
		al->argv[al->argc] = NULL;
		}

		return;
		}

		/******************************************************************************

		free_args()

		Free an argument list.

		******************************************************************************/
		void free_args(arg_list_t *al)
		{
		int i;

		ASSERT(al != NULL);

		for(i = 0; i < al->argc; i++)
		{
		ASSERT(al->argv[i] != NULL);
		free(al->argv[i]);
		al->argv[i] = NULL;
		}

		free(al->argv);
		al->argc = 0;
		al->argv = NULL;

		return;
		}

		/******************************************************************************

		sleep_until_file_deleted()

		Sleep until the given file is no longer found.

		******************************************************************************/
		#ifndef __WIN__
		int sleep_until_file_deleted(char *pid_file)
		#else
		int sleep_until_file_deleted(HANDLE pid_file)
		#endif
		{
		int err;
		#ifndef __WIN__
		struct stat buf;
		int i;

		for(i = 0; (i < TRY_MAX) && (err = !stat(pid_file, &buf)); i++) sleep(1);

		if (err != 0) err = errno;
		#else
		err= (WaitForSingleObject(pid_file, TRY_MAX*1000) == WAIT_TIMEOUT);
		#endif
		return err;
		}

		/******************************************************************************

		sleep_until_file_exists()

		Sleep until the given file exists.

		******************************************************************************/
		#ifndef __WIN__
		int sleep_until_file_exists(char *pid_file)
		#else
		int sleep_until_file_exists(HANDLE pid_file)
		#endif
		{
		int err;
		#ifndef __WIN__
		struct stat buf;
		int i;

		for(i = 0; (i < TRY_MAX) && (err = stat(pid_file, &buf)); i++) sleep(1);

		if (err != 0) err = errno;
		#else
		err= (WaitForSingleObject(pid_file, TRY_MAX*1000) == WAIT_TIMEOUT);
		#endif
		return err;
		}

		/******************************************************************************

		wait_for_server_start()

		Wait for the server on the given port to start.

		******************************************************************************/
		int wait_for_server_start(char bin_dir, char mysqladmin_file, char user, char password, int port,char *tmp_dir)
		{
		arg_list_t al;
		int err, i;
		char trash[PATH_MAX];

		// mysqladmin file
		snprintf(trash, PATH_MAX, "%s/trash.out",tmp_dir);

		// args
		init_args(&al);
		add_arg(&al, "%s", mysqladmin_file);
		add_arg(&al, "--no-defaults");
		add_arg(&al, "--port=%u", port);
		add_arg(&al, "--user=%s", user);
		add_arg(&al, "--password=%s", password);
		add_arg(&al, "--silent");

		//#ifdef NOT_USED
		#ifndef __NETWARE__
		add_arg(&al, "-O");
		add_arg(&al, "connect_timeout=10");
		add_arg(&al, "-w");
		#endif

		add_arg(&al, "--host=localhost");
		#ifndef __NETWARE__
		add_arg(&al, "--protocol=tcp");
		#endif
		add_arg(&al, "ping");

		// NetWare does not support the connect timeout in the TCP/IP stack
		// -- we will try the ping multiple times
		#ifndef __WIN__
		for(i = 0; (i < TRY_MAX)
		&& (err = spawn(mysqladmin_file, &al, TRUE, NULL,
		trash, NULL, NULL)); i++) sleep(1);
		#else
		err = spawn(mysqladmin_file, &al, TRUE, NULL,trash, NULL, NULL);
		#endif

		// free args
		free_args(&al);

		return err;
		}

		/******************************************************************************

		spawn()

		Spawn the given path with the given arguments.

		******************************************************************************/
		#ifdef __NETWARE__
		int spawn(char path, arg_list_t al, int join, char *input,
		char output, char error, char *pid_file)
		{
		pid_t pid;
		int result = 0;
		wiring_t wiring = { FD_UNUSED, FD_UNUSED, FD_UNUSED };
		unsigned long flags = PROC_CURRENT_SPACE \| PROC_INHERIT_CWD;

		// open wiring
		if (input)
		wiring.infd = open(input, O_RDONLY);

		if (output)
		wiring.outfd = open(output, O_WRONLY \| O_CREAT \| O_TRUNC);

		if (error)
		wiring.errfd = open(error, O_WRONLY \| O_CREAT \| O_TRUNC);

		// procve requires a NULL
		add_arg(al, NULL);

		// go
		pid = procve(path, flags, NULL, &wiring, NULL, NULL, 0,
		NULL, (const char **)al->argv);

		// close wiring
		if (wiring.infd != -1)
		close(wiring.infd);

		if (wiring.outfd != -1)
		close(wiring.outfd);

		if (wiring.errfd != -1)
		close(wiring.errfd);

		return result;
		}
		#elif __WIN__

		int spawn(char path, arg_list_t al, int join, char *input,
		char output, char error, HANDLE *pid)
		{
		intptr_t result;
		int i;
		STARTUPINFO startup_info;
		PROCESS_INFORMATION process_information;
		DWORD exit_code;
		char win_args[1024]= "";
		char command_line[1024]= "";

		/*
		Skip the first parameter
		*/
		for(i = 1; i < al->argc; i++)
		{
		ASSERT(al->argv[i] != NULL);
		strcat(win_args,al->argv[i]);
		strcat(win_args," ");
		}

		memset(&startup_info,0,sizeof(STARTUPINFO));
		startup_info.cb = sizeof(STARTUPINFO);

		if (input)
		freopen(input, "rb", stdin);

		if (output)
		freopen(output, "wb", stdout);

		if (error)
		freopen(error, "wb", stderr);

		result= CreateProcess(
		path,
		(LPSTR)&win_args,
		NULL,
		NULL,
		TRUE,
		0,
		NULL,
		NULL,
		&startup_info,
		&process_information
		);

		if (result && process_information.hProcess)
		{
		if (join)
		{
		if (WaitForSingleObject(process_information.hProcess, mysqld_timeout) == WAIT_TIMEOUT)
		{
		exit_code= -1;
		}
		else
		{
		GetExitCodeProcess(process_information.hProcess, &exit_code);
		}
		CloseHandle(process_information.hProcess);
		}
		else
		{
		exit_code= 0;
		}
		if (pid != NULL)
		*pid= process_information.hProcess;
		}
		else
		{
		exit_code= -1;
		}
		if (input)
		freopen("CONIN$","rb",stdin);
		if (output)
		freopen("CONOUT$","wb",stdout);
		if (error)
		freopen("CONOUT$","wb",stderr);

		return exit_code;
		}
		#else
		int spawn(char path, arg_list_t al, int join, char *input,
		char output, char error, char *pid_file)
		{
		pid_t pid;
		int res_exec = 0;
		int result = 0;

		pid = fork();

		if (pid == -1)
		{
		fprintf(stderr, "fork was't created\n");
		/*
		We can't create the fork...exit with error
		*/
		return EXIT_FAILURE;
		}

		if (pid > 0)
		{
		/*
		The parent process is waiting for child process if join is not zero
		*/
		if (join)
		{
		waitpid(pid, &result, 0);
		if (WIFEXITED(result) != 0)
		{
		result = WEXITSTATUS(result);
		}
		else
		{
		result = EXIT_FAILURE;
		}
		}
		}
		else
		{

		/*
		Child process
		*/

		add_arg(al, NULL);


		/*
		Reassign streams
		*/
		if (input)
		freopen(input, "r", stdin);


		if (output)
		freopen(output, "w", stdout);


		if (error)
		freopen(error, "w", stderr);

		/* Spawn the process */
		if ((res_exec = execve(path, al->argv, environ)) < 0)
		{
		exit(EXIT_FAILURE);
		}

		/*
		Restore streams
		*/
		if (input)
		freopen("/dev/tty", "r", stdin);

		if (output)
		freopen("/dev/tty", "w", stdout);

		if (error)
		freopen("/dev/tty", "w", stderr);

		exit(0);
		}

		return result;
		}
		#endif
		/******************************************************************************

		stop_server()

		Stop the server with the given port and pid file.

		******************************************************************************/
		#ifndef __WIN__
		int stop_server(char bin_dir, char mysqladmin_file, char user, char password, int port,
		char pid_file,char tmp_dir)
		#else
		int stop_server(char bin_dir, char mysqladmin_file, char user, char password, int port,
		HANDLE pid_file,char *tmp_dir)
		#endif
		{
		arg_list_t al;
		int err = 0;
		char trash[PATH_MAX];

		snprintf(trash, PATH_MAX, "%s/trash.out",tmp_dir);

		// args
		init_args(&al);
		add_arg(&al, "%s", mysqladmin_file);
		add_arg(&al, "--no-defaults");
		add_arg(&al, "--port=%u", port);
		add_arg(&al, "--user=%s", user);
		add_arg(&al, "--password=%s", password);
		add_arg(&al, "-O");
		add_arg(&al, "shutdown_timeout=20");
		#ifndef __NETWARE__
		add_arg(&al, "--protocol=tcp");
		#endif
		add_arg(&al, "shutdown");

		// spawn
		if ((err = spawn(mysqladmin_file, &al, TRUE, NULL,
		trash, NULL, NULL)) == 0)
		{
		sleep_until_file_deleted(pid_file);
		}
		else
		{
		#ifndef __WIN__
		pid_t pid = get_server_pid(pid_file);

		// shutdown failed - kill server
		kill_server(pid);

		sleep(TRY_MAX);

		// remove pid file if possible
		err = remove(pid_file);
		#else
		TerminateProcess(pid_file,err);
		#endif
		}

		// free args
		free_args(&al);

		return err;
		}

		/******************************************************************************

		get_server_pid()

		Get the VM id with the given pid file.

		******************************************************************************/
		#ifndef __WIN__
		pid_t get_server_pid(char *pid_file)
		{
		char buf[PATH_MAX];
		int fd, err;
		char *p;
		pid_t id = 0;

		// discover id
		fd = open(pid_file, O_RDONLY);

		err = read(fd, buf, PATH_MAX);

		close(fd);

		if (err > 0)
		{
		// terminate string
		if ((p = strchr(buf, '\n')) != NULL)
		{
		*p = '\0';

		// check for a '\r'
		if ((p = strchr(buf, '\r')) != NULL)
		{
		*p = '\0';
		}
		}
		else
		{
		buf[err] = '\0';
		}

		id = strtol(buf, NULL, 0);
		}

		return id;
		}

		/******************************************************************************

		kill_server()

		Force a kill of the server with the given pid.

		******************************************************************************/
		void kill_server(pid_t pid)
		{
		if (pid > 0)
		{
		#if !defined(__NETWARE__)
		/* Send SIGTERM to pid */
		kill(pid, SIGTERM);
		#else /* __NETWARE__ */
		/* destroy vm */
		NXVmDestroy(pid);
		#endif
		}
		}
		#endif
		/******************************************************************************

		del_tree()

		Delete the directory and subdirectories.

		******************************************************************************/
		void del_tree(char *dir)
		{
		#ifndef __WIN__
		DIR *parent = opendir(dir);
		struct dirent *entry;
		char temp[PATH_MAX];

		if (parent == NULL)
		{
		return;
		}

		while((entry = readdir(parent)) != NULL)
		{
		// create long name
		snprintf(temp, PATH_MAX, "%s/%s", dir, entry->d_name);

		if (entry->d_name[0] == '.')
		{
		// Skip
		}
		else
		if (S_ISDIR(entry->d_type))
		{
		// delete subdirectory
		del_tree(temp);
		}
		else
		{
		// remove file
		remove(temp);
		}
		}
		// remove directory
		rmdir(dir);
		#else
		struct _finddata_t parent;
		intptr_t handle;
		char temp[PATH_MAX];
		char mask[PATH_MAX];

		snprintf(mask,MAX_PATH,"%s/.",dir);

		if ((handle=_findfirst(mask,&parent)) == -1L)
		{
		return;
		}

		do
		{
		// create long name
		snprintf(temp, PATH_MAX, "%s/%s", dir, parent.name);
		if (parent.name[0] == '.')
		{
		// Skip
		}
		else
		if (parent.attrib & _A_SUBDIR)
		{
		// delete subdirectory
		del_tree(temp);
		}
		else
		{
		// remove file
		remove(temp);
		}
		} while (_findnext(handle,&parent) == 0);

		_findclose(handle);

		// remove directory
		_rmdir(dir);
		#endif
		}

		/******************************************************************************

		removef()

		******************************************************************************/
		int removef(const char *format, ...)
		{
		#ifdef __NETWARE__
		va_list ap;
		char path[PATH_MAX];

		va_start(ap, format);

		vsnprintf(path, PATH_MAX, format, ap);

		va_end(ap);
		return remove(path);

		#eldef __WIN__
		{
		va_list ap;
		char path[PATH_MAX];
		struct _finddata_t parent;
		intptr_t handle;
		char temp[PATH_MAX];
		char *p;

		va_start(ap, format);

		vsnprintf(path, PATH_MAX, format, ap);

		va_end(ap);

		p = path + strlen(path);
		while (p != '\\' && p != '/' && p > path) p--;

		if ((handle=_findfirst(path,&parent)) == -1L)
		{
		/*
		if there is not files....it's ok.
		*/
		return 0;
		}

		*p = '\0';

		do
		{
		if (! (parent.attrib & _A_SUBDIR))
		{
		snprintf(temp, PATH_MAX, "%s/%s", path, parent.name);
		remove(temp);
		}
		}while (_findnext(handle,&parent) == 0);

		_findclose(handle);
		}
		#else
		DIR *parent;
		struct dirent *entry;
		char temp[PATH_MAX];
		va_list ap;
		char path[PATH_MAX];
		char *p;
		/*
		Get path with mask
		*/
		va_start(ap, format);

		vsnprintf(path, PATH_MAX, format, ap);

		va_end(ap);

		p = path + strlen(path);
		while (p != '\\' && p != '/' && p > path) p--;
		*p = '\0';
		p++;

		parent = opendir(path);

		if (parent == NULL)
		{
		return;
		}

		while((entry = readdir(parent)) != NULL)
		{
		/*
		entry is not directory and entry matches with mask
		*/
		if (!S_ISDIR(entry->d_type) && !fnmatch(p, entry->d_name,0))
		{
		// create long name
		snprintf(temp, PATH_MAX, "%s/%s", path, entry->d_name);
		// Delete only files
		remove(temp);
		}
		}
		#endif
		return 0;
		}

		/******************************************************************************

		get_basedir()

		******************************************************************************/
		void get_basedir(char argv0, char basedir)
		{
		char temp[PATH_MAX];
		char *p;
		int position;

		ASSERT(argv0 != NULL);
		ASSERT(basedir != NULL);

		strcpy(temp, strlwr(argv0));
		while((p = strchr(temp, '\\')) != NULL) *p = '/';

		if ((position = strinstr(temp, "/bin/")) != 0)
		{
		p = temp + position;
		*p = '\0';
		strcpy(basedir, temp);
		}
		}

		#if !defined(__NETWARE__) && !defined(__WIN__)
		char strlwr(const char s)
		{
		return s;
		}
		#endif

		uint strinstr(reg1 const char str,reg4 const char search)
		{
		reg2 my_string i,j;
		my_string start = (my_string) str;

		skipp:
		while (*str != '\0')
		{
		if (str++ == search)
		{
		i=(my_string) str; j= (my_string) search+1;
		while (*j)
		if (i++ != j++) goto skipp;
		return ((uint) (str - start));
		}
		}
		return (0);
		}

		/******************************************************************************

		remove_empty_file()

		******************************************************************************/
		void remove_empty_file(const char *file_name)
		{
		struct stat file;

		if (!stat(file_name,&file))
		{
		if (!file.st_size)
		remove(file_name);
		}
		}

mysql-test/my_manage.h

0 → 100644

+135 −0

Original line number	Diff line number	Diff line
		/*
		Copyright (c) 2002 Novell, Inc. All Rights Reserved.

		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
		*/

		#ifndef _MY_MANAGE
		#define _MY_MANAGE

		/******************************************************************************

		includes

		******************************************************************************/

		#include <stdlib.h>
		#ifndef __WIN__
		#include <unistd.h>
		#endif
		#ifndef __NETWARE__
		#include <string.h>
		#include <my_global.h>
		#include <m_string.h>

		#ifndef __WIN__
		#define strnicmp strncasecmp
		char strlwr(const char s);
		#else
		int my_vsnprintf_(char to, size_t n, const char value, ...);
		#endif
		#endif

		/******************************************************************************

		macros

		******************************************************************************/

		#define ARG_BUF 10
		#define TRY_MAX 5

		#ifdef __WIN__
		#define PATH_MAX _MAX_PATH
		#define NAME_MAX _MAX_FNAME
		#define kill(A,B) TerminateProcess((HANDLE)A,0)
		#define NOT_NEED_PID 0
		#define MASTER_PID 1
		#define SLAVE_PID 2
		#define mysqld_timeout 60000

		int pid_mode;
		bool run_server;
		bool skip_first_param;

		#define snprintf _snprintf
		#define vsnprintf _vsnprintf
		#endif


		/******************************************************************************

		structures

		******************************************************************************/

		typedef struct
		{

		int argc;
		char **argv;

		size_t size;

		} arg_list_t;

		#ifdef __WIN__
		typedef int pid_t;
		#endif
		/******************************************************************************

		global variables

		******************************************************************************/

		/******************************************************************************

		prototypes

		******************************************************************************/

		void init_args(arg_list_t *);
		void add_arg(arg_list_t , const char , ...);
		void free_args(arg_list_t *);

		#ifndef __WIN__
		int sleep_until_file_exists(char *);
		int sleep_until_file_deleted(char *);
		#else
		int sleep_until_file_exists(HANDLE);
		int sleep_until_file_deleted(HANDLE);
		#endif
		int wait_for_server_start(char , char , char , char , int,char *);

		#ifndef __WIN__
		int spawn(char , arg_list_t , int, char , char , char , char );
		#else
		int spawn(char , arg_list_t , int , char , char , char , HANDLE );
		#endif

		#ifndef __WIN__
		int stop_server(char , char , char , char , int, char ,char );
		pid_t get_server_pid(char *);
		void kill_server(pid_t pid);
		#else
		int stop_server(char , char , char , char , int, HANDLE,char *);
		#endif
		void del_tree(char *);
		int removef(const char *, ...);

		void get_basedir(char , char );
		void remove_empty_file(const char *file_name);

		#endif /* _MY_MANAGE */

mysql-test/mysql_test_run.c

0 → 100644

+1728 −0

File added.

Preview size limit exceeded, changes collapsed.