#define MTEST_VERSION "3.3"

#include "client_priv.h"

#include "my_default.h"

#include <mysql_version.h>

#include <mysqld_error.h>

#include <sql_common.h>

#include <m_ctype.h>

#include <my_dir.h>

#include <hash.h>

#include <stdarg.h>

#include <violite.h>

#include "my_regex.h" /* Our own version of regex */

#ifdef HAVE_SYS_WAIT_H

#include <sys/wait.h>

#endif

#ifdef __WIN__

#include <direct.h>

#endif

#include <signal.h>

#include <my_stacktrace.h>

#include <welcome_copyright_notice.h> // ORACLE_WELCOME_COPYRIGHT_NOTICE

#include <algorithm>

using std::min;

using std::max;

#ifdef __WIN__

#include <crtdbg.h>

#define SIGNAL_FMT "exception 0x%x"

#else

#define SIGNAL_FMT "signal %d"

#endif

#if MYSQL_VERSION_ID < 50000

#define USE_CYGWIN

#endif

#define MAX_VAR_NAME_LENGTH 256

#define MAX_COLUMNS 256

#define MAX_EMBEDDED_SERVER_ARGS 64

#define MAX_DELIMITER_LENGTH 16

#define DEFAULT_MAX_CONN 128

#define QUERY_SEND_FLAG 1

#define QUERY_REAP_FLAG 2

#ifndef HAVE_SETENV

static int setenv(const char *name, const char *value, int overwrite);

#endif

C_MODE_START

static sig_handler signal_handler(int sig);

static my_bool get_one_option(int optid, const struct my_option *,

char *argument);

C_MODE_END

enum {

OPT_PS_PROTOCOL=OPT_MAX_CLIENT_OPTION, OPT_SP_PROTOCOL,

OPT_CURSOR_PROTOCOL, OPT_VIEW_PROTOCOL, OPT_MAX_CONNECT_RETRIES,

OPT_MAX_CONNECTIONS, OPT_MARK_PROGRESS, OPT_LOG_DIR,

OPT_TAIL_LINES, OPT_RESULT_FORMAT_VERSION, OPT_TRACE_PROTOCOL,

OPT_EXPLAIN_PROTOCOL, OPT_JSON_EXPLAIN_PROTOCOL

};

static int record= 0, opt_sleep= -1;

static char *opt_db= 0, *opt_pass= 0;

const char *opt_user= 0, *opt_host= 0, *unix_sock= 0, *opt_basedir= "./";

static char *shared_memory_base_name=0;

const char *opt_logdir= "";

const char *opt_include= 0, *opt_charsets_dir;

static int opt_port= 0;

static int opt_max_connect_retries;

static int opt_result_format_version;

static int opt_max_connections= DEFAULT_MAX_CONN;

static my_bool opt_compress= 0, silent= 0, verbose= 0;

static my_bool debug_info_flag= 0, debug_check_flag= 0;

static my_bool tty_password= 0;

static my_bool opt_mark_progress= 0;

static my_bool ps_protocol= 0, ps_protocol_enabled= 0;

static my_bool sp_protocol= 0, sp_protocol_enabled= 0;

static my_bool view_protocol= 0, view_protocol_enabled= 0;

static my_bool opt_trace_protocol= 0, opt_trace_protocol_enabled= 0;

static my_bool explain_protocol= 0, explain_protocol_enabled= 0;

static my_bool json_explain_protocol= 0, json_explain_protocol_enabled= 0;

static my_bool cursor_protocol= 0, cursor_protocol_enabled= 0;

static my_bool parsing_disabled= 0;

static my_bool display_result_vertically= FALSE, display_result_lower= FALSE,

display_metadata= FALSE, display_result_sorted= FALSE;

static my_bool disable_query_log= 0, disable_result_log= 0;

static my_bool disable_connect_log= 1;

static my_bool disable_warnings= 0;

static my_bool disable_info= 1;

static my_bool abort_on_error= 1;

static my_bool server_initialized= 0;

static my_bool is_windows= 0;

static char **default_argv;

static const char *load_default_groups[]= { "mysqltest", "client", 0 };

static char line_buffer[MAX_DELIMITER_LENGTH], *line_buffer_pos= line_buffer;

#if !defined(HAVE_YASSL)

static const char *opt_server_public_key= 0;

#endif

static my_bool can_handle_expired_passwords= TRUE;

struct property {

};

static struct property prop_list[] = {

{ &abort_on_error, 0, 1, 0, "$ENABLED_ABORT_ON_ERROR" },

{ &disable_connect_log, 0, 1, 1, "$ENABLED_CONNECT_LOG" },

{ &disable_info, 0, 1, 1, "$ENABLED_INFO" },

{ &display_metadata, 0, 0, 0, "$ENABLED_METADATA" },

{ &ps_protocol_enabled, 0, 0, 0, "$ENABLED_PS_PROTOCOL" },

{ &disable_query_log, 0, 0, 1, "$ENABLED_QUERY_LOG" },

{ &disable_result_log, 0, 0, 1, "$ENABLED_RESULT_LOG" },

{ &disable_warnings, 0, 0, 1, "$ENABLED_WARNINGS" }

};

static my_bool once_property= FALSE;

enum enum_prop {

};

static uint start_lineno= 0; /* Start line of current command */

static uint my_end_arg= 0;

static uint opt_tail_lines= 0;

static uint opt_connect_timeout= 0;

static char delimiter[MAX_DELIMITER_LENGTH]= ";";

static uint delimiter_length= 1;

static char TMPDIR[FN_REFLEN];

enum block_cmd {

};

struct st_block

};

static struct st_block block_stack[32];

static struct st_block *cur_block, *block_stack_end;

struct st_test_file

};

static struct st_test_file file_stack[16];

static struct st_test_file* cur_file;

static struct st_test_file* file_stack_end;

static CHARSET_INFO *charset_info= &my_charset_latin1; /* Default charset */

static const char *embedded_server_groups[]=

{

"server",

"embedded",

"mysqltest_SERVER",

NullS

};

static int embedded_server_arg_count=0;

static char *embedded_server_args[MAX_EMBEDDED_SERVER_ARGS];

static char *timer_file = NULL;

static ulonglong timer_start;

static void timer_output(void);

static ulonglong timer_now(void);

static ulong connection_retry_sleep= 100000; /* Microseconds */

static char *opt_plugin_dir= 0;

static my_regex_t ps_re; /* the query can be run using PS protocol */

static my_regex_t sp_re; /* the query can be run as a SP */

static my_regex_t view_re; /* the query can be run as a view*/

static my_regex_t opt_trace_re;

static my_regex_t explain_re;/* the query can be converted to EXPLAIN */

static void init_re(void);

static int match_re(my_regex_t *, char *);

static void free_re(void);

#ifndef EMBEDDED_LIBRARY

static uint opt_protocol= 0;

#endif

DYNAMIC_ARRAY q_lines;

#include "sslopt-vars.h"

struct Parser

{

int read_lines,current_line;

} parser;

struct MasterPos

} master_pos;

const char *result_file_name= 0;

typedef struct

{

char *name;

int name_len;

char *str_val;

int str_val_len;

int int_val;

int alloced_len;

bool int_dirty; /* do not update string if int is updated until first read */

bool is_int;

bool alloced;

} VAR;

VAR var_reg[10];

HASH var_hash;

struct st_connection

};

struct st_connection *connections= NULL;

struct st_connection* cur_con= NULL, *next_con, *connections_end;

enum enum_commands {

};

const char *command_names[]=

{

"connection",

"query",

"connect",

"sleep",

"real_sleep",

"inc",

"dec",

"source",

"disconnect",

"let",

"echo",

"while",

"end",

"system",

"result",

"require",

"save_master_pos",

"sync_with_master",

"sync_slave_with_master",

"error",

"send",

"reap",

"dirty_close",

"replace_result",

"replace_column",

"ping",

"eval",

"eval_result",

/* Enable/disable that the _query_ is logged to result file */

"enable_query_log",

"disable_query_log",

/* Enable/disable that the _result_ from a query is logged to result file */

"enable_result_log",

"disable_result_log",

"enable_connect_log",

"disable_connect_log",

"wait_for_slave_to_stop",

"enable_warnings",

"disable_warnings",

"enable_info",

"disable_info",

"enable_metadata",

"disable_metadata",

"exec",

"execw",

"delimiter",

"disable_abort_on_error",

"enable_abort_on_error",

"vertical_results",

"horizontal_results",

"query_vertical",

"query_horizontal",

"sorted_result",

"lowercase_result",

"start_timer",

"end_timer",

"character_set",

"disable_ps_protocol",

"enable_ps_protocol",

"disable_reconnect",

"enable_reconnect",

"if",

"disable_parsing",

"enable_parsing",

"replace_regex",

"remove_file",

"file_exists",

"write_file",

"copy_file",

"perl",

"die",

/* Don't execute any more commands, compare result */

"exit",

"skip",

"chmod",

"append_file",

"cat_file",

"diff_files",

"send_quit",

"change_user",

"mkdir",

"rmdir",

"list_files",

"list_files_write_file",

"list_files_append_file",

"send_shutdown",

"shutdown_server",

"result_format",

"move_file",

"remove_files_wildcard",

"send_eval",

0

};

enum match_err_type

};

struct st_match_err

};

struct st_expected_errors

};

static struct st_expected_errors saved_expected_errors;

struct st_command

};

TYPELIB command_typelib= {array_elements(command_names),"",

command_names, 0};

DYNAMIC_STRING ds_res;

DYNAMIC_STRING *ds_warn= 0;

struct st_command *curr_command= 0;

char builtin_echo[FN_REFLEN];

struct st_replace_regex

};

struct st_replace_regex *glob_replace_regex= 0;

struct st_replace;

struct st_replace *glob_replace= 0;

void replace_strings_append(struct st_replace *rep, DYNAMIC_STRING* ds,

const char *from, int len);

static void cleanup_and_exit(int exit_code) MY_ATTRIBUTE((noreturn));

void die(const char *fmt, ...)

ATTRIBUTE_FORMAT(printf, 1, 2) MY_ATTRIBUTE((noreturn));

void abort_not_supported_test(const char *fmt, ...)

ATTRIBUTE_FORMAT(printf, 1, 2) MY_ATTRIBUTE((noreturn));

void verbose_msg(const char *fmt, ...)

ATTRIBUTE_FORMAT(printf, 1, 2);

void log_msg(const char *fmt, ...)

ATTRIBUTE_FORMAT(printf, 1, 2);

VAR* var_from_env(const char *, const char *);

VAR* var_init(VAR* v, const char *name, int name_len, const char *val,

int val_len);

VAR* var_get(const char *var_name, const char** var_name_end,

my_bool raw, my_bool ignore_not_existing);

void eval_expr(VAR* v, const char *p, const char** p_end,

bool open_end=false, bool do_eval=true);

my_bool match_delimiter(int c, const char *delim, uint length);

void dump_result_to_reject_file(char *buf, int size);

void dump_warning_messages();

void do_eval(DYNAMIC_STRING *query_eval, const char *query,

const char *query_end, my_bool pass_through_escape_chars);

void str_to_file(const char *fname, char *str, int size);

void str_to_file2(const char *fname, char *str, int size, my_bool append);

void fix_win_paths(const char *val, int len);

const char *get_errname_from_code (uint error_code);

int multi_reg_replace(struct st_replace_regex* r,char* val);

#ifdef __WIN__

void free_tmp_sh_file();

void free_win_path_patterns();

#endif

static char *replace_column[MAX_COLUMNS];

static uint max_replace_column= 0;

void do_get_replace_column(struct st_command*);

void free_replace_column();

void do_get_replace(struct st_command *command);

void free_replace();

void do_get_replace_regex(struct st_command *command);

void free_replace_regex();

void check_eol_junk_line(const char *eol);

void free_all_replace(){

}

class LogFile {

};

LogFile log_file;

LogFile progress_file;

void replace_dynstr_append_mem(DYNAMIC_STRING *ds, const char *val,

int len);

void replace_dynstr_append(DYNAMIC_STRING *ds, const char *val);

void replace_dynstr_append_uint(DYNAMIC_STRING *ds, uint val);

void dynstr_append_sorted(DYNAMIC_STRING* ds, DYNAMIC_STRING* ds_input);

static int match_expected_error(struct st_command *command,

unsigned int err_errno,

const char *err_sqlstate);

void handle_error(struct st_command*,

unsigned int err_errno, const char *err_error,

const char *err_sqlstate, DYNAMIC_STRING *ds);

void handle_no_error(struct st_command*);

void revert_properties();

#ifdef EMBEDDED_LIBRARY

#define EMB_SEND_QUERY 1

#define EMB_READ_QUERY_RESULT 2

#define EMB_END_CONNECTION 3

pthread_attr_t cn_thd_attrib;

pthread_handler_t connection_thread(void *arg)

}

static void wait_query_thread_done(struct st_connection *con)

}

static void signal_connection_thd(struct st_connection *cn, int command)

}

static int do_send_query(struct st_connection *cn, const char *q, int q_len)

}

static int do_read_query_result(struct st_connection *cn)

}

static void emb_close_connection(struct st_connection *cn)

}

static void init_connection_thd(struct st_connection *cn)

}

#else /*EMBEDDED_LIBRARY*/

#define do_send_query(cn,q,q_len) mysql_send_query(&cn->mysql, q, q_len)

#define do_read_query_result(cn) mysql_read_query_result(&cn->mysql)

#endif /*EMBEDDED_LIBRARY*/

void do_eval(DYNAMIC_STRING *query_eval, const char *query,

}