autocommit (a941f148) · Commits · Software / OSDI20 Artifacts / mariadb

client/mysqltest.c

+6 −3

Original line number	Diff line number	Diff line
		@@ -4516,8 +4516,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.

		@@ -4608,9 +4607,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.