mysqltest.cc 264 KB
Newer Older
1
/* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
2

3 4
   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
5
   the Free Software Foundation; version 2 of the License.
6

7 8 9 10
   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.
11

12 13 14 15
   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 */

16 17
/*
  mysqltest
18

19
  Tool used for executing a .test file
20

21 22
  See the "MySQL Test framework manual" for more information
  http://dev.mysql.com/doc/mysqltest/en/index.html
23

24 25
  Please keep the test framework tools identical in all versions!

26 27 28 29 30
  Written by:
  Sasha Pachev <sasha@mysql.com>
  Matt Wagner  <matt@mysql.com>
  Monty
  Jani
31
  Holyfoot
32
*/
33

34
#define MTEST_VERSION "3.3"
35

36
#include "client_priv.h"
37
#include <mysql_version.h>
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
38
#include <mysqld_error.h>
39
#include <sql_common.h>
40 41
#include <m_ctype.h>
#include <my_dir.h>
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
42
#include <hash.h>
43
#include <stdarg.h>
44
#include <violite.h>
45
#include "my_regex.h" /* Our own version of regex */
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
46
#ifdef HAVE_SYS_WAIT_H
47
#include <sys/wait.h>
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
48
#endif
49 50 51
#ifdef __WIN__
#include <direct.h>
#endif
52
#include <signal.h>
53
#include <my_stacktrace.h>
54

55 56
#include <welcome_copyright_notice.h> // ORACLE_WELCOME_COPYRIGHT_NOTICE

57 58 59 60 61 62
#ifdef __WIN__
#include <crtdbg.h>
#define SIGNAL_FMT "exception 0x%x"
#else
#define SIGNAL_FMT "signal %d"
#endif
63

64 65 66 67 68
/* Use cygwin for --exec and --system before 5.0 */
#if MYSQL_VERSION_ID < 50000
#define USE_CYGWIN
#endif

69 70 71 72
#define MAX_VAR_NAME_LENGTH    256
#define MAX_COLUMNS            256
#define MAX_EMBEDDED_SERVER_ARGS 64
#define MAX_DELIMITER_LENGTH 16
73
#define DEFAULT_MAX_CONN       128
74 75 76 77 78

/* Flags controlling send and reap */
#define QUERY_SEND_FLAG  1
#define QUERY_REAP_FLAG  2

79
#ifndef HAVE_SETENV
80
static int setenv(const char *name, const char *value, int overwrite);
81 82
#endif

83 84 85 86 87 88
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

89
enum {
90 91 92 93
  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
94
};
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
95

96
static int record= 0, opt_sleep= -1;
97 98
static char *opt_db= 0, *opt_pass= 0;
const char *opt_user= 0, *opt_host= 0, *unix_sock= 0, *opt_basedir= "./";
99
static char *shared_memory_base_name=0;
100
const char *opt_logdir= "";
101
const char *opt_include= 0, *opt_charsets_dir;
102
static int opt_port= 0;
103
static int opt_max_connect_retries;
104
static int opt_result_format_version;
105
static int opt_max_connections= DEFAULT_MAX_CONN;
106
static my_bool opt_compress= 0, silent= 0, verbose= 0;
107
static my_bool debug_info_flag= 0, debug_check_flag= 0;
108 109 110 111 112 113 114
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 cursor_protocol= 0, cursor_protocol_enabled= 0;
static my_bool parsing_disabled= 0;
115
static my_bool display_result_vertically= FALSE, display_result_lower= FALSE,
116
  display_metadata= FALSE, display_result_sorted= FALSE;
117
static my_bool disable_query_log= 0, disable_result_log= 0;
118
static my_bool disable_connect_log= 1;
119
static my_bool disable_warnings= 0;
120 121
static my_bool disable_info= 1;
static my_bool abort_on_error= 1;
122
static my_bool server_initialized= 0;
123
static my_bool is_windows= 0;
124 125 126
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;
127

128
static uint start_lineno= 0; /* Start line of current command */
129
static uint my_end_arg= 0;
130

131 132 133
/* Number of lines of the result to include in failure report */
static uint opt_tail_lines= 0;

134 135
static uint opt_connect_timeout= 0;

136 137 138 139 140 141 142 143 144 145
static char delimiter[MAX_DELIMITER_LENGTH]= ";";
static uint delimiter_length= 1;

static char TMPDIR[FN_REFLEN];

/* Block stack */
enum block_cmd {
  cmd_none,
  cmd_if,
  cmd_while
146 147
};

148
struct st_block
149
{
150 151 152
  int             line; /* Start line of block */
  my_bool         ok;   /* Should block be executed */
  enum block_cmd  cmd;  /* Command owning the block */
153
  char            delim[MAX_DELIMITER_LENGTH];  /* Delimiter before block */
154
};
155

156 157
static struct st_block block_stack[32];
static struct st_block *cur_block, *block_stack_end;
158

159 160
/* Open file stack */
struct st_test_file
161 162
{
  FILE* file;
163
  char *file_name;
164 165
  uint lineno; /* Current line in file */
};
166

167 168 169
static struct st_test_file file_stack[16];
static struct st_test_file* cur_file;
static struct st_test_file* file_stack_end;
170

171

kent@mysql.com's avatar
kent@mysql.com committed
172
static CHARSET_INFO *charset_info= &my_charset_latin1; /* Default charset */
173

174 175 176 177 178 179 180
static const char *embedded_server_groups[]=
{
  "server",
  "embedded",
  "mysqltest_SERVER",
  NullS
};
181

182 183
static int embedded_server_arg_count=0;
static char *embedded_server_args[MAX_EMBEDDED_SERVER_ARGS];
184

185 186 187 188
/*
  Timer related variables
  See the timer_output() definition for details
*/
kent@mysql.com's avatar
kent@mysql.com committed
189 190 191 192 193
static char *timer_file = NULL;
static ulonglong timer_start;
static void timer_output(void);
static ulonglong timer_now(void);

194

195 196
static ulong connection_retry_sleep= 100000; /* Microseconds */

197 198
static char *opt_plugin_dir= 0;

199 200 201 202 203 204 205 206
/* Precompiled re's */
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 void init_re(void);
static int match_re(my_regex_t *, char *);
static void free_re(void);
207

208 209
static uint opt_protocol=0;

210 211
DYNAMIC_ARRAY q_lines;

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
212 213
#include "sslopt-vars.h"

214
struct Parser
215 216
{
  int read_lines,current_line;
217
} parser;
218

219
struct MasterPos
220 221 222 223
{
  char file[FN_REFLEN];
  ulong pos;
} master_pos;
224

225
/* if set, all results are concated and compared against this file */
226
const char *result_file_name= 0;
227

228
typedef struct
229
{
230
  char *name;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
231
  int name_len;
232
  char *str_val;
233 234 235
  int str_val_len;
  int int_val;
  int alloced_len;
236 237 238
  bool int_dirty; /* do not update string if int is updated until first read */
  bool is_int;
  bool alloced;
239 240 241
} VAR;

/*Perl/shell-like variable registers */
242
VAR var_reg[10];
243

244
HASH var_hash;
245

246 247 248 249 250 251
struct st_connection
{
  MYSQL mysql;
  /* Used when creating views and sp, to avoid implicit commit */
  MYSQL* util_mysql;
  char *name;
252
  size_t name_len;
253
  MYSQL_STMT* stmt;
254 255
  /* Set after send to disallow other queries before reap */
  my_bool pending;
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
256

257
#ifdef EMBEDDED_LIBRARY
258
  pthread_t tid;
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
259 260
  const char *cur_query;
  int cur_query_len;
261 262 263 264 265
  int command, result;
  pthread_mutex_t query_mutex;
  pthread_cond_t query_cond;
  pthread_mutex_t result_mutex;
  pthread_cond_t result_cond;
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
266
  int query_done;
267
  my_bool has_thread;
268
#endif /*EMBEDDED_LIBRARY*/
269
};
270 271

struct st_connection *connections= NULL;
272
struct st_connection* cur_con= NULL, *next_con, *connections_end;
273

274 275 276 277 278
/*
  List of commands in mysqltest
  Must match the "command_names" array
  Add new commands before Q_UNKNOWN!
*/
279
enum enum_commands {
280 281 282 283 284 285 286 287 288 289 290 291 292 293
  Q_CONNECTION=1,     Q_QUERY,
  Q_CONNECT,	    Q_SLEEP, Q_REAL_SLEEP,
  Q_INC,		    Q_DEC,
  Q_SOURCE,	    Q_DISCONNECT,
  Q_LET,		    Q_ECHO,
  Q_WHILE,	    Q_END_BLOCK,
  Q_SYSTEM,	    Q_RESULT,
  Q_REQUIRE,	    Q_SAVE_MASTER_POS,
  Q_SYNC_WITH_MASTER,
  Q_SYNC_SLAVE_WITH_MASTER,
  Q_ERROR,
  Q_SEND,		    Q_REAP,
  Q_DIRTY_CLOSE,	    Q_REPLACE, Q_REPLACE_COLUMN,
  Q_PING,		    Q_EVAL,
Konstantin Osipov's avatar
Konstantin Osipov committed
294
  Q_EVAL_RESULT,
295 296
  Q_ENABLE_QUERY_LOG, Q_DISABLE_QUERY_LOG,
  Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,
297
  Q_ENABLE_CONNECT_LOG, Q_DISABLE_CONNECT_LOG,
298 299 300 301 302 303 304
  Q_WAIT_FOR_SLAVE_TO_STOP,
  Q_ENABLE_WARNINGS, Q_DISABLE_WARNINGS,
  Q_ENABLE_INFO, Q_DISABLE_INFO,
  Q_ENABLE_METADATA, Q_DISABLE_METADATA,
  Q_EXEC, Q_DELIMITER,
  Q_DISABLE_ABORT_ON_ERROR, Q_ENABLE_ABORT_ON_ERROR,
  Q_DISPLAY_VERTICAL_RESULTS, Q_DISPLAY_HORIZONTAL_RESULTS,
305
  Q_QUERY_VERTICAL, Q_QUERY_HORIZONTAL, Q_SORTED_RESULT,
306
  Q_LOWERCASE,
307 308 309 310 311 312
  Q_START_TIMER, Q_END_TIMER,
  Q_CHARACTER_SET, Q_DISABLE_PS_PROTOCOL, Q_ENABLE_PS_PROTOCOL,
  Q_DISABLE_RECONNECT, Q_ENABLE_RECONNECT,
  Q_IF,
  Q_DISABLE_PARSING, Q_ENABLE_PARSING,
  Q_REPLACE_REGEX, Q_REMOVE_FILE, Q_FILE_EXIST,
313
  Q_WRITE_FILE, Q_COPY_FILE, Q_PERL, Q_DIE, Q_EXIT, Q_SKIP,
314
  Q_CHMOD_FILE, Q_APPEND_FILE, Q_CAT_FILE, Q_DIFF_FILES,
315
  Q_SEND_QUIT, Q_CHANGE_USER, Q_MKDIR, Q_RMDIR,
Sven Sandberg's avatar
Sven Sandberg committed
316
  Q_LIST_FILES, Q_LIST_FILES_WRITE_FILE, Q_LIST_FILES_APPEND_FILE,
317
  Q_SEND_SHUTDOWN, Q_SHUTDOWN_SERVER,
318
  Q_RESULT_FORMAT_VERSION,
319
  Q_MOVE_FILE, Q_REMOVE_FILES_WILDCARD, Q_SEND_EVAL,
320 321
  Q_UNKNOWN,			       /* Unknown command.   */
  Q_COMMENT,			       /* Comments, ignored. */
322 323
  Q_COMMENT_WITH_COMMAND,
  Q_EMPTY_LINE
324 325
};

326

327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
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",
347
  "sync_slave_with_master",
348 349 350 351 352
  "error",
  "send",
  "reap",
  "dirty_close",
  "replace_result",
353
  "replace_column",
354 355 356
  "ping",
  "eval",
  "eval_result",
357
  /* Enable/disable that the _query_ is logged to result file */
358 359
  "enable_query_log",
  "disable_query_log",
360
  /* Enable/disable that the _result_ from a query is logged to result file */
361 362
  "enable_result_log",
  "disable_result_log",
363 364
  "enable_connect_log",
  "disable_connect_log",
365
  "wait_for_slave_to_stop",
366 367 368
  "enable_warnings",
  "disable_warnings",
  "enable_info",
369
  "disable_info",
370 371
  "enable_metadata",
  "disable_metadata",
372
  "exec",
373
  "delimiter",
374 375
  "disable_abort_on_error",
  "enable_abort_on_error",
376
  "vertical_results",
377
  "horizontal_results",
378
  "query_vertical",
379
  "query_horizontal",
380
  "sorted_result",
381
  "lowercase_result",
kent@mysql.com's avatar
kent@mysql.com committed
382 383
  "start_timer",
  "end_timer",
kent@mysql.com's avatar
kent@mysql.com committed
384
  "character_set",
385 386
  "disable_ps_protocol",
  "enable_ps_protocol",
387 388
  "disable_reconnect",
  "enable_reconnect",
389
  "if",
390 391 392 393 394 395 396 397 398
  "disable_parsing",
  "enable_parsing",
  "replace_regex",
  "remove_file",
  "file_exists",
  "write_file",
  "copy_file",
  "perl",
  "die",
399
               
400 401
  /* Don't execute any more commands, compare result */
  "exit",
402
  "skip",
403
  "chmod",
404
  "append_file",
405
  "cat_file",
406
  "diff_files",
407
  "send_quit",
408
  "change_user",
409 410
  "mkdir",
  "rmdir",
411 412 413
  "list_files",
  "list_files_write_file",
  "list_files_append_file",
414 415
  "send_shutdown",
  "shutdown_server",
416
  "result_format",
417
  "move_file",
418
  "remove_files_wildcard",
419
  "send_eval",
420

jcole@tetra.spaceapes.com's avatar
jcole@tetra.spaceapes.com committed
421
  0
422 423
};

424 425 426 427 428 429 430 431 432

/*
  The list of error codes to --error are stored in an internal array of
  structs. This struct can hold numeric SQL error codes, error names or
  SQLSTATE codes as strings. The element next to the last active element
  in the list is set to type ERR_EMPTY. When an SQL statement returns an
  error, we use this list to check if this is an expected error.
*/
enum match_err_type
433
{
434 435 436 437
  ERR_EMPTY= 0,
  ERR_ERRNO,
  ERR_SQLSTATE
};
438

439 440 441 442 443 444 445 446 447
struct st_match_err
{
  enum match_err_type type;
  union
  {
    uint errnum;
    char sqlstate[SQLSTATE_LENGTH+1];  /* \0 terminated string */
  } code;
};
448

449 450 451 452 453 454
struct st_expected_errors
{
  struct st_match_err err[10];
  uint count;
};
static struct st_expected_errors saved_expected_errors;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
455

456 457 458
struct st_command
{
  char *query, *query_buf,*first_argument,*last_argument,*end;
459
  DYNAMIC_STRING content;
460
  int first_word_len, query_len;
461
  my_bool abort_on_error, used_replace;
462
  struct st_expected_errors expected_errors;
463
  char require_file[FN_REFLEN];
464 465
  enum enum_commands type;
};
466

467 468
TYPELIB command_typelib= {array_elements(command_names),"",
			  command_names, 0};
469

470
DYNAMIC_STRING ds_res;
471

472 473
char builtin_echo[FN_REFLEN];

474 475
static void cleanup_and_exit(int exit_code) __attribute__((noreturn));

476
void die(const char *fmt, ...)
477
  ATTRIBUTE_FORMAT(printf, 1, 2) __attribute__((noreturn));
478
void abort_not_supported_test(const char *fmt, ...)
479
  ATTRIBUTE_FORMAT(printf, 1, 2) __attribute__((noreturn));
480
void verbose_msg(const char *fmt, ...)
481
  ATTRIBUTE_FORMAT(printf, 1, 2);
482 483
void log_msg(const char *fmt, ...)
  ATTRIBUTE_FORMAT(printf, 1, 2);
484 485 486 487 488 489

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);
490
void eval_expr(VAR* v, const char *p, const char** p_end,
Bjorn Munch's avatar
Bjorn Munch committed
491
               bool open_end=false, bool backtick=true);
492
my_bool match_delimiter(int c, const char *delim, uint length);
493 494
void dump_result_to_reject_file(char *buf, int size);
void dump_warning_messages();
495 496 497 498

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);
499
void str_to_file2(const char *fname, char *str, int size, my_bool append);
500

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

503 504 505 506
#ifdef __WIN__
void free_tmp_sh_file();
void free_win_path_patterns();
#endif
507 508


509 510 511 512 513 514 515 516
/* For replace_column */
static char *replace_column[MAX_COLUMNS];
static uint max_replace_column= 0;
void do_get_replace_column(struct st_command*);
void free_replace_column();

/* For replace */
void do_get_replace(struct st_command *command);
517
void free_replace();
518

519 520 521 522
/* For replace_regex */
void do_get_replace_regex(struct st_command *command);
void free_replace_regex();

523 524
/* Used by sleep */
void check_eol_junk_line(const char *eol);
525

526 527 528 529 530
void free_all_replace(){
  free_replace();
  free_replace_regex();
  free_replace_column();
}
531 532


533 534 535
class LogFile {
  FILE* m_file;
  char m_file_name[FN_REFLEN];
Magnus Svensson's avatar
Magnus Svensson committed
536
  size_t m_bytes_written;
537 538 539 540 541 542 543 544 545 546
public:
  LogFile() : m_file(NULL), m_bytes_written(0) {
    bzero(m_file_name, sizeof(m_file_name));
  }

  ~LogFile() {
    close();
  }

  const char* file_name() const { return m_file_name; }
Magnus Svensson's avatar
Magnus Svensson committed
547
  size_t bytes_written() const { return m_bytes_written; }
548 549 550 551

  void open(const char* dir, const char* name, const char* ext)
  {
    DBUG_ENTER("LogFile::open");
Magnus Svensson's avatar
Magnus Svensson committed
552 553
    DBUG_PRINT("enter", ("dir: '%s', name: '%s'",
                         dir, name));
554 555 556 557 558 559 560 561 562 563 564 565
    if (!name)
    {
      m_file= stdout;
      DBUG_VOID_RETURN;
    }

    fn_format(m_file_name, name, dir, ext,
              *dir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
              MY_REPLACE_EXT);

    DBUG_PRINT("info", ("file_name: %s", m_file_name));

566
    if ((m_file= fopen(m_file_name, "wb+")) == NULL)
567 568 569 570 571 572 573
      die("Failed to open log file %s, errno: %d", m_file_name, errno);

    DBUG_VOID_RETURN;
  }

  void close()
  {
574 575 576 577 578 579
    if (m_file) {
      if (m_file != stdout)
        fclose(m_file);
      else
        fflush(m_file);
    }
580 581 582 583 584 585
    m_file= NULL;
  }

  void flush()
  {
    if (m_file && m_file != stdout)
586 587 588 589
    {
      if (fflush(m_file))
        die("Failed to flush '%s', errno: %d", m_file_name, errno);
    }
590 591 592 593 594 595 596 597 598 599 600 601
  }

  void write(DYNAMIC_STRING* ds)
  {
    DBUG_ENTER("LogFile::write");
    DBUG_ASSERT(m_file);

    if (ds->length == 0)
      DBUG_VOID_RETURN;
    DBUG_ASSERT(ds->str);

    if (fwrite(ds->str, 1, ds->length, m_file) != ds->length)
Magnus Svensson's avatar
Magnus Svensson committed
602 603
      die("Failed to write %lu bytes to '%s', errno: %d",
          (unsigned long)ds->length, m_file_name, errno);
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
    m_bytes_written+= ds->length;
    DBUG_VOID_RETURN;
  }

  void show_tail(uint lines) {
    DBUG_ENTER("LogFile::show_tail");

    if (!m_file || m_file == stdout)
      DBUG_VOID_RETURN;

    if (lines == 0)
      DBUG_VOID_RETURN;
    lines++;

    int show_offset= 0;
    char buf[256];
    size_t bytes;
    bool found_bof= false;

    /* Search backward in file until "lines" newline has been found */
    while (lines && !found_bof)
    {
      show_offset-= sizeof(buf);
      while(fseek(m_file, show_offset, SEEK_END) != 0 && show_offset < 0)
      {
        found_bof= true;
        // Seeking before start of file
        show_offset++;
      }

      if ((bytes= fread(buf, 1, sizeof(buf), m_file)) <= 0)
      {
636 637 638 639 640
	// ferror=0 will happen here if no queries executed yet
	if (ferror(m_file))
	  fprintf(stderr,
	          "Failed to read from '%s', errno: %d, feof:%d, ferror:%d\n",
	          m_file_name, errno, feof(m_file), ferror(m_file));
641 642 643
        DBUG_VOID_RETURN;
      }

Magnus Svensson's avatar
Magnus Svensson committed
644 645
      DBUG_PRINT("info", ("Read %lu bytes from file, buf: %s",
                          (unsigned long)bytes, buf));
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705

      char* show_from= buf + bytes;
      while(show_from > buf && lines > 0 )
      {
        show_from--;
        if (*show_from == '\n')
          lines--;
      }
      if (show_from != buf)
      {
        // The last new line was found in this buf, adjust offset
        show_offset+= (show_from - buf) + 1;
        DBUG_PRINT("info", ("adjusted offset to %d", show_offset));
      }
      DBUG_PRINT("info", ("show_offset: %d", show_offset));
    }

    fprintf(stderr, "\nThe result from queries just before the failure was:\n");

    DBUG_PRINT("info", ("show_offset: %d", show_offset));
    if (!lines)
    {
      fprintf(stderr, "< snip >\n");

      if (fseek(m_file, show_offset, SEEK_END) != 0)
      {
        fprintf(stderr, "Failed to seek to position %d in '%s', errno: %d",
                show_offset, m_file_name, errno);
        DBUG_VOID_RETURN;
      }

    }
    else {
      DBUG_PRINT("info", ("Showing the whole file"));
      if (fseek(m_file, 0L, SEEK_SET) != 0)
      {
        fprintf(stderr, "Failed to seek to pos 0 in '%s', errno: %d",
                m_file_name, errno);
        DBUG_VOID_RETURN;
      }
    }

    while ((bytes= fread(buf, 1, sizeof(buf), m_file)) > 0)
      fwrite(buf, 1, bytes, stderr);

    if (!lines)
    {
      fprintf(stderr,
              "\nMore results from queries before failure can be found in %s\n",
              m_file_name);
    }
    fflush(stderr);

    DBUG_VOID_RETURN;
  }
};

LogFile log_file;
LogFile progress_file;

706 707 708 709
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);
710
void dynstr_append_sorted(DYNAMIC_STRING* ds, DYNAMIC_STRING* ds_input);
711

712 713 714
static int match_expected_error(struct st_command *command,
                                unsigned int err_errno,
                                const char *err_sqlstate);
715 716 717 718 719
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*);

720
#ifdef EMBEDDED_LIBRARY
721

722 723 724 725
#define EMB_SEND_QUERY 1
#define EMB_READ_QUERY_RESULT 2
#define EMB_END_CONNECTION 3

726 727 728
/* attributes of the query thread */
pthread_attr_t cn_thd_attrib;

729

730
/*
731 732 733 734
  This procedure represents the connection and actually
  runs queries when in the EMBEDDED-SERVER mode.
  The run_query_normal() just sends request for running
  mysql_send_query and mysql_read_query_result() here.
735
*/
736 737

pthread_handler_t connection_thread(void *arg)
738
{
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
739
  struct st_connection *cn= (struct st_connection*)arg;
740 741

  mysql_thread_init();
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
  while (cn->command != EMB_END_CONNECTION)
  {
    if (!cn->command)
    {
      pthread_mutex_lock(&cn->query_mutex);
      while (!cn->command)
        pthread_cond_wait(&cn->query_cond, &cn->query_mutex);
      pthread_mutex_unlock(&cn->query_mutex);
    }
    switch (cn->command)
    {
      case EMB_END_CONNECTION:
        goto end_thread;
      case EMB_SEND_QUERY:
        cn->result= mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len);
        break;
      case EMB_READ_QUERY_RESULT:
        cn->result= mysql_read_query_result(&cn->mysql);
        break;
      default:
        DBUG_ASSERT(0);
    }
    cn->command= 0;
    pthread_mutex_lock(&cn->result_mutex);
    cn->query_done= 1;
    pthread_cond_signal(&cn->result_cond);
    pthread_mutex_unlock(&cn->result_mutex);
  }
770

771
end_thread:
772
  cn->query_done= 1;
773
  mysql_thread_end();
774 775 776 777
  pthread_exit(0);
  return 0;
}

778
static void wait_query_thread_done(struct st_connection *con)
779
{
Bjorn Munch's avatar
Bjorn Munch committed
780
  DBUG_ASSERT(con->has_thread);
781 782 783 784 785 786 787 788
  if (!con->query_done)
  {
    pthread_mutex_lock(&con->result_mutex);
    while (!con->query_done)
      pthread_cond_wait(&con->result_cond, &con->result_mutex);
    pthread_mutex_unlock(&con->result_mutex);
  }
}
789

790

791
static void signal_connection_thd(struct st_connection *cn, int command)
792
{
Bjorn Munch's avatar
Bjorn Munch committed
793
  DBUG_ASSERT(cn->has_thread);
794
  cn->query_done= 0;
795 796 797 798 799
  cn->command= command;
  pthread_mutex_lock(&cn->query_mutex);
  pthread_cond_signal(&cn->query_cond);
  pthread_mutex_unlock(&cn->query_mutex);
}
800 801


802 803 804
/*
  Sometimes we try to execute queries when the connection is closed.
  It's done to make sure it was closed completely.
Bjorn Munch's avatar
Bjorn Munch committed
805
  So that if our connection is closed (cn->has_thread == 0), we just return
806 807
  the mysql_send_query() result which is an error in this case.
*/
808

809 810
static int do_send_query(struct st_connection *cn, const char *q, int q_len)
{
Bjorn Munch's avatar
Bjorn Munch committed
811
  if (!cn->has_thread)
812
    return mysql_send_query(&cn->mysql, q, q_len);
813 814
  cn->cur_query= q;
  cn->cur_query_len= q_len;
815
  signal_connection_thd(cn, EMB_SEND_QUERY);
816 817 818
  return 0;
}

819
static int do_read_query_result(struct st_connection *cn)
820
{
Bjorn Munch's avatar
Bjorn Munch committed
821
  DBUG_ASSERT(cn->has_thread);
822 823 824 825 826 827 828 829 830 831
  wait_query_thread_done(cn);
  signal_connection_thd(cn, EMB_READ_QUERY_RESULT);
  wait_query_thread_done(cn);

  return cn->result;
}


static void emb_close_connection(struct st_connection *cn)
{
Bjorn Munch's avatar
Bjorn Munch committed
832
  if (!cn->has_thread)
833 834 835 836
    return;
  wait_query_thread_done(cn);
  signal_connection_thd(cn, EMB_END_CONNECTION);
  pthread_join(cn->tid, NULL);
Bjorn Munch's avatar
Bjorn Munch committed
837
  cn->has_thread= FALSE;
838 839 840 841
  pthread_mutex_destroy(&cn->query_mutex);
  pthread_cond_destroy(&cn->query_cond);
  pthread_mutex_destroy(&cn->result_mutex);
  pthread_cond_destroy(&cn->result_cond);
842 843
}

844 845 846 847 848 849 850 851 852 853 854

static void init_connection_thd(struct st_connection *cn)
{
  cn->query_done= 1;
  cn->command= 0;
  if (pthread_mutex_init(&cn->query_mutex, NULL) ||
      pthread_cond_init(&cn->query_cond, NULL) ||
      pthread_mutex_init(&cn->result_mutex, NULL) ||
      pthread_cond_init(&cn->result_cond, NULL) ||
      pthread_create(&cn->tid, &cn_thd_attrib, connection_thread, (void*)cn))
    die("Error in the thread library");
Bjorn Munch's avatar
Bjorn Munch committed
855
  cn->has_thread=TRUE;
856 857
}

858 859
#else /*EMBEDDED_LIBRARY*/

860 861
#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)
862 863

#endif /*EMBEDDED_LIBRARY*/
864 865 866

void do_eval(DYNAMIC_STRING *query_eval, const char *query,
             const char *query_end, my_bool pass_through_escape_chars)
867
{
868
  const char *p;
869
  register char c, next_c;
870
  register int escaped = 0;
871
  VAR *v;
monty@mysql.com's avatar
monty@mysql.com committed
872
  DBUG_ENTER("do_eval");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
873

874
  for (p= query; (c= *p) && p < query_end; ++p)
875 876 877 878 879
  {
    switch(c) {
    case '$':
      if (escaped)
      {
880
	escaped= 0;
881 882 883 884
	dynstr_append_mem(query_eval, p, 1);
      }
      else
      {
885
	if (!(v= var_get(p, &p, 0, 0)))
886 887 888 889 890
	  die("Bad variable in eval");
	dynstr_append_mem(query_eval, v->str_val, v->str_val_len);
      }
      break;
    case '\\':
891
      next_c= *(p+1);
892 893
      if (escaped)
      {
894
	escaped= 0;
895 896
	dynstr_append_mem(query_eval, p, 1);
      }
897 898 899 900 901 902 903 904 905 906 907
      else if (next_c == '\\' || next_c == '$' || next_c == '"')
      {
        /* Set escaped only if next char is \, " or $ */
	escaped= 1;

        if (pass_through_escape_chars)
        {
          /* The escape char should be added to the output string. */
          dynstr_append_mem(query_eval, p, 1);
        }
      }
908
      else
909
	dynstr_append_mem(query_eval, p, 1);
910 911
      break;
    default:
912
      escaped= 0;
913 914
      dynstr_append_mem(query_eval, p, 1);
      break;
915
    }
916
  }
917 918 919
#ifdef __WIN__
    fix_win_paths(query_eval->str, query_eval->length);
#endif
monty@mysql.com's avatar
monty@mysql.com committed
920
  DBUG_VOID_RETURN;
921
}
922

923

924
/*
925
  Run query and dump the result to stderr in vertical format
926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988

  NOTE! This function should be safe to call when an error
  has occured and thus any further errors will be ignored(although logged)

  SYNOPSIS
  show_query
  mysql - connection to use
  query - query to run

*/

static void show_query(MYSQL* mysql, const char* query)
{
  MYSQL_RES* res;
  DBUG_ENTER("show_query");

  if (!mysql)
    DBUG_VOID_RETURN;

  if (mysql_query(mysql, query))
  {
    log_msg("Error running query '%s': %d %s",
            query, mysql_errno(mysql), mysql_error(mysql));
    DBUG_VOID_RETURN;
  }

  if ((res= mysql_store_result(mysql)) == NULL)
  {
    /* No result set returned */
    DBUG_VOID_RETURN;
  }

  {
    MYSQL_ROW row;
    unsigned int i;
    unsigned int row_num= 0;
    unsigned int num_fields= mysql_num_fields(res);
    MYSQL_FIELD *fields= mysql_fetch_fields(res);

    fprintf(stderr, "=== %s ===\n", query);
    while ((row= mysql_fetch_row(res)))
    {
      unsigned long *lengths= mysql_fetch_lengths(res);
      row_num++;

      fprintf(stderr, "---- %d. ----\n", row_num);
      for(i= 0; i < num_fields; i++)
      {
        fprintf(stderr, "%s\t%.*s\n",
                fields[i].name,
                (int)lengths[i], row[i] ? row[i] : "NULL");
      }
    }
    for (i= 0; i < strlen(query)+8; i++)
      fprintf(stderr, "=");
    fprintf(stderr, "\n\n");
  }
  mysql_free_result(res);

  DBUG_VOID_RETURN;
}


989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
/*
  Show any warnings just before the error. Since the last error
  is added to the warning stack, only print @@warning_count-1 warnings.

  NOTE! This function should be safe to call when an error
  has occured and this any further errors will be ignored(although logged)

  SYNOPSIS
  show_warnings_before_error
  mysql - connection to use

*/

static void show_warnings_before_error(MYSQL* mysql)
{
  MYSQL_RES* res;
  const char* query= "SHOW WARNINGS";
  DBUG_ENTER("show_warnings_before_error");

  if (!mysql)
    DBUG_VOID_RETURN;

  if (mysql_query(mysql, query))
  {
    log_msg("Error running query '%s': %d %s",
            query, mysql_errno(mysql), mysql_error(mysql));
    DBUG_VOID_RETURN;
  }

  if ((res= mysql_store_result(mysql)) == NULL)
  {
    /* No result set returned */
    DBUG_VOID_RETURN;
  }

  if (mysql_num_rows(res) <= 1)
  {
    /* Don't display the last row, it's "last error" */
  }
  else
  {
    MYSQL_ROW row;
    unsigned int row_num= 0;
    unsigned int num_fields= mysql_num_fields(res);

    fprintf(stderr, "\nWarnings from just before the error:\n");
    while ((row= mysql_fetch_row(res)))
    {
      unsigned int i;
      unsigned long *lengths= mysql_fetch_lengths(res);

      if (++row_num >= mysql_num_rows(res))
      {
        /* Don't display the last row, it's "last error" */
        break;
      }

      for(i= 0; i < num_fields; i++)
      {
msvensson@pilot.(none)'s avatar
msvensson@pilot.(none) committed
1048
        fprintf(stderr, "%.*s ", (int)lengths[i],
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
                row[i] ? row[i] : "NULL");
      }
      fprintf(stderr, "\n");
    }
  }
  mysql_free_result(res);

  DBUG_VOID_RETURN;
}


1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
enum arg_type
{
  ARG_STRING,
  ARG_REST
};

struct command_arg {
  const char *argname;       /* Name of argument   */
  enum arg_type type;        /* Type of argument   */
  my_bool required;          /* Argument required  */
  DYNAMIC_STRING *ds;        /* Storage for argument */
  const char *description;   /* Description of the argument */
};


void check_command_args(struct st_command *command,
                        const char *arguments,
                        const struct command_arg *args,
                        int num_args, const char delimiter_arg)
{
  int i;
  const char *ptr= arguments;
  const char *start;
  DBUG_ENTER("check_command_args");
  DBUG_PRINT("enter", ("num_args: %d", num_args));
1085

1086 1087 1088
  for (i= 0; i < num_args; i++)
  {
    const struct command_arg *arg= &args[i];
1089
    char delimiter;
1090

1091
    switch (arg->type) {
1092 1093 1094 1095 1096 1097
      /* A string */
    case ARG_STRING:
      /* Skip leading spaces */
      while (*ptr && *ptr == ' ')
        ptr++;
      start= ptr;
1098 1099 1100 1101 1102 1103 1104 1105 1106
      delimiter = delimiter_arg;
      /* If start of arg is ' ` or " search to matching quote end instead */
      if (*ptr && strchr ("'`\"", *ptr))
      {
	delimiter= *ptr;
	start= ++ptr;
      }
      /* Find end of arg, terminated by "delimiter" */
      while (*ptr && *ptr != delimiter)
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
        ptr++;
      if (ptr > start)
      {
        init_dynamic_string(arg->ds, 0, ptr-start, 32);
        do_eval(arg->ds, start, ptr, FALSE);
      }
      else
      {
        /* Empty string */
        init_dynamic_string(arg->ds, "", 0, 0);
      }
1118 1119 1120 1121 1122
      /* Find real end of arg, terminated by "delimiter_arg" */
      /* This will do nothing if arg was not closed by quotes */
      while (*ptr && *ptr != delimiter_arg)
        ptr++;      

1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
      command->last_argument= (char*)ptr;

      /* Step past the delimiter */
      if (*ptr && *ptr == delimiter_arg)
        ptr++;
      DBUG_PRINT("info", ("val: %s", arg->ds->str));
      break;

      /* Rest of line */
    case ARG_REST:
      start= ptr;
      init_dynamic_string(arg->ds, 0, command->query_len, 256);
      do_eval(arg->ds, start, command->end, FALSE);
      command->last_argument= command->end;
      DBUG_PRINT("info", ("val: %s", arg->ds->str));
      break;

    default:
      DBUG_ASSERT("Unknown argument type");
      break;
    }

    /* Check required arg */
    if (arg->ds->length == 0 && arg->required)
      die("Missing required argument '%s' to command '%.*s'", arg->argname,
          command->first_word_len, command->query);

  }
1151 1152
  /* Check for too many arguments passed */
  ptr= command->last_argument;
1153
  while(ptr <= command->end && *ptr != '#')
1154 1155 1156 1157 1158 1159
  {
    if (*ptr && *ptr != ' ')
      die("Extra argument '%s' passed to '%.*s'",
          ptr, command->first_word_len, command->query);
    ptr++;
  }
1160 1161 1162 1163 1164 1165 1166 1167 1168
  DBUG_VOID_RETURN;
}

void handle_command_error(struct st_command *command, uint error)
{
  DBUG_ENTER("handle_command_error");
  DBUG_PRINT("enter", ("error: %d", error));
  if (error != 0)
  {
1169
    int i;
1170 1171 1172 1173

    if (command->abort_on_error)
      die("command \"%.*s\" failed with error %d",
          command->first_word_len, command->query, error);
1174 1175 1176 1177

    i= match_expected_error(command, error, NULL);

    if (i >= 0)
1178
    {
1179 1180 1181
      DBUG_PRINT("info", ("command \"%.*s\" failed with expected error: %d",
                          command->first_word_len, command->query, error));
      DBUG_VOID_RETURN;
1182
    }
1183 1184 1185
    if (command->expected_errors.count > 0)
      die("command \"%.*s\" failed with wrong error: %d",
          command->first_word_len, command->query, error);
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
  }
  else if (command->expected_errors.err[0].type == ERR_ERRNO &&
           command->expected_errors.err[0].code.errnum != 0)
  {
    /* Error code we wanted was != 0, i.e. not an expected success */
    die("command \"%.*s\" succeeded - should have failed with errno %d...",
        command->first_word_len, command->query,
        command->expected_errors.err[0].code.errnum);
  }
  DBUG_VOID_RETURN;
}


void close_connections()
1200
{
1201 1202
  DBUG_ENTER("close_connections");
  for (--next_con; next_con >= connections; --next_con)
1203
  {
1204 1205 1206
#ifdef EMBEDDED_LIBRARY
    emb_close_connection(next_con);
#endif
1207 1208 1209
    if (next_con->stmt)
      mysql_stmt_close(next_con->stmt);
    next_con->stmt= 0;
1210
    mysql_close(&next_con->mysql);
1211 1212
    if (next_con->util_mysql)
      mysql_close(next_con->util_mysql);
1213
    my_free(next_con->name);
1214
  }
1215
  my_free(connections);
1216 1217 1218
  DBUG_VOID_RETURN;
}

1219

1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
void close_statements()
{
  struct st_connection *con;
  DBUG_ENTER("close_statements");
  for (con= connections; con < next_con; con++)
  {
    if (con->stmt)
      mysql_stmt_close(con->stmt);
    con->stmt= 0;
  }
  DBUG_VOID_RETURN;
}


1234
void close_files()
1235
{
1236
  DBUG_ENTER("close_files");
1237
  for (; cur_file >= file_stack; cur_file--)
1238
  {
1239
    if (cur_file->file && cur_file->file != stdin)
1240 1241
    {
      DBUG_PRINT("info", ("closing file: %s", cur_file->file_name));
1242
      fclose(cur_file->file);
1243
    }
1244
    my_free(cur_file->file_name);
1245
    cur_file->file_name= 0;
1246 1247
  }
  DBUG_VOID_RETURN;
1248 1249
}

1250

1251
void free_used_memory()
1252 1253 1254
{
  uint i;
  DBUG_ENTER("free_used_memory");
1255

1256 1257
  if (connections)
    close_connections();
1258
  close_files();
Konstantin Osipov's avatar
Konstantin Osipov committed
1259
  my_hash_free(&var_hash);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1260

1261
  for (i= 0 ; i < q_lines.elements ; i++)
1262
  {
1263
    struct st_command **q= dynamic_element(&q_lines, i, struct st_command**);
1264
    my_free((*q)->query_buf);
1265 1266
    if ((*q)->content.str)
      dynstr_free(&(*q)->content);
1267
    my_free((*q));
1268
  }
1269
  for (i= 0; i < 10; i++)
1270 1271
  {
    if (var_reg[i].alloced_len)
1272
      my_free(var_reg[i].str_val);
1273
  }
1274
  while (embedded_server_arg_count > 1)
1275
    my_free(embedded_server_args[--embedded_server_arg_count]);
1276 1277
  delete_dynamic(&q_lines);
  dynstr_free(&ds_res);
1278
  free_all_replace();
1279
  my_free(opt_pass);
1280
  free_defaults(default_argv);
1281 1282 1283 1284 1285
  free_re();
#ifdef __WIN__
  free_tmp_sh_file();
  free_win_path_patterns();
#endif
1286 1287 1288 1289 1290 1291 1292

  /* Only call mysql_server_end if mysql_server_init has been called */
  if (server_initialized)
    mysql_server_end();

  /* Don't use DBUG after mysql_server_end() */
  return;
1293 1294
}

1295

1296 1297 1298
static void cleanup_and_exit(int exit_code)
{
  free_used_memory();
1299
  my_end(my_end_arg);
1300

1301
  if (!silent) {
1302
    switch (exit_code) {
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320
    case 1:
      printf("not ok\n");
      break;
    case 0:
      printf("ok\n");
      break;
    case 62:
      printf("skipped\n");
    break;
    default:
      printf("unknown exit code: %d\n", exit_code);
      DBUG_ASSERT(0);
    }
  }

  exit(exit_code);
}

1321
void die(const char *fmt, ...)
1322
{
1323
  static int dying= 0;
1324
  va_list args;
1325
  DBUG_ENTER("die");
1326 1327
  DBUG_PRINT("enter", ("start_lineno: %d", start_lineno));

1328 1329 1330 1331 1332 1333 1334
  /*
    Protect against dying twice
    first time 'die' is called, try to write log files
    second time, just exit
  */
  if (dying)
    cleanup_and_exit(1);
1335
  dying= 1;
1336

1337
  /* Print the error message */
1338 1339 1340 1341 1342 1343
  fprintf(stderr, "mysqltest: ");
  if (cur_file && cur_file != file_stack)
    fprintf(stderr, "In included file \"%s\": ",
            cur_file->file_name);
  if (start_lineno > 0)
    fprintf(stderr, "At line %u: ", start_lineno);
1344 1345
  if (fmt)
  {
1346
    va_start(args, fmt);
1347
    vfprintf(stderr, fmt, args);
1348
    va_end(args);
1349
  }
1350 1351 1352 1353
  else
    fprintf(stderr, "unknown error");
  fprintf(stderr, "\n");
  fflush(stderr);
1354

1355
  log_file.show_tail(opt_tail_lines);
1356

1357 1358 1359 1360
  /*
    Help debugging by displaying any warnings that might have
    been produced prior to the error
  */
1361
  if (cur_con && !cur_con->pending)
1362 1363
    show_warnings_before_error(&cur_con->mysql);

1364
  cleanup_and_exit(1);
1365 1366
}

1367

1368
void abort_not_supported_test(const char *fmt, ...)
1369
{
1370 1371
  va_list args;
  struct st_test_file* err_file= cur_file;
1372
  DBUG_ENTER("abort_not_supported_test");
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396

  /* Print include filestack */
  fprintf(stderr, "The test '%s' is not supported by this installation\n",
          file_stack->file_name);
  fprintf(stderr, "Detected in file %s at line %d\n",
          err_file->file_name, err_file->lineno);
  while (err_file != file_stack)
  {
    err_file--;
    fprintf(stderr, "included from %s at line %d\n",
            err_file->file_name, err_file->lineno);
  }

  /* Print error message */
  va_start(args, fmt);
  if (fmt)
  {
    fprintf(stderr, "reason: ");
    vfprintf(stderr, fmt, args);
    fprintf(stderr, "\n");
    fflush(stderr);
  }
  va_end(args);

1397
  cleanup_and_exit(62);
1398 1399
}

1400 1401 1402

void abort_not_in_this_version()
{
1403
  die("Not available in this version of mysqltest");
1404 1405 1406 1407
}


void verbose_msg(const char *fmt, ...)
1408 1409
{
  va_list args;
1410 1411 1412
  DBUG_ENTER("verbose_msg");
  if (!verbose)
    DBUG_VOID_RETURN;
1413 1414

  va_start(args, fmt);
1415
  fprintf(stderr, "mysqltest: ");
1416 1417 1418
  if (cur_file && cur_file != file_stack)
    fprintf(stderr, "In included file \"%s\": ",
            cur_file->file_name);
1419
  if (start_lineno != 0)
1420
    fprintf(stderr, "At line %u: ", start_lineno);
1421 1422 1423
  vfprintf(stderr, fmt, args);
  fprintf(stderr, "\n");
  va_end(args);
1424

1425
  DBUG_VOID_RETURN;
1426 1427
}

1428

1429 1430 1431
void log_msg(const char *fmt, ...)
{
  va_list args;
msvensson@shellback.(none)'s avatar
msvensson@shellback.(none) committed
1432
  char buff[1024];
1433 1434 1435 1436
  size_t len;
  DBUG_ENTER("log_msg");

  va_start(args, fmt);
1437
  len= my_vsnprintf(buff, sizeof(buff)-1, fmt, args);
1438 1439 1440 1441 1442 1443 1444 1445 1446
  va_end(args);

  dynstr_append_mem(&ds_res, buff, len);
  dynstr_append(&ds_res, "\n");

  DBUG_VOID_RETURN;
}


1447
/*
1448 1449 1450 1451 1452 1453 1454
  Read a file and append it to ds

  SYNOPSIS
  cat_file
  ds - pointer to dynamic string where to add the files content
  filename - name of the file to read

1455
*/
1456

1457
int cat_file(DYNAMIC_STRING* ds, const char* filename)
1458 1459
{
  int fd;
1460
  size_t len;
1461
  char buff[512];
1462

1463
  if ((fd= my_open(filename, O_RDONLY, MYF(0))) < 0)
1464
    return 1;
1465
  while((len= my_read(fd, (uchar*)&buff,
1466
                      sizeof(buff), MYF(0))) > 0)
1467
  {
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
    char *p= buff, *start= buff;
    while (p < buff+len)
    {
      /* Convert cr/lf to lf */
      if (*p == '\r' && *(p+1) && *(p+1)== '\n')
      {
        /* Add fake newline instead of cr and output the line */
        *p= '\n';
        p++; /* Step past the "fake" newline */
        dynstr_append_mem(ds, start, p-start);
        p++; /* Step past the "fake" newline */
        start= p;
      }
      else
        p++;
    }
    /* Output any chars that migh be left */
    dynstr_append_mem(ds, start, p-start);
1486
  }
1487
  my_close(fd, MYF(0));
1488
  return 0;
1489
}
1490

1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512

/*
  Run the specified command with popen

  SYNOPSIS
  run_command
  cmd - command to execute(should be properly quoted
  ds_res- pointer to dynamic string where to store the result

*/

static int run_command(char* cmd,
                       DYNAMIC_STRING *ds_res)
{
  char buf[512]= {0};
  FILE *res_file;
  int error;

  if (!(res_file= popen(cmd, "r")))
    die("popen(\"%s\", \"r\") failed", cmd);

  while (fgets(buf, sizeof(buf), res_file))
1513
  {
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
    DBUG_PRINT("info", ("buf: %s", buf));
    if(ds_res)
    {
      /* Save the output of this command in the supplied string */
      dynstr_append(ds_res, buf);
    }
    else
    {
      /* Print it directly on screen */
      fprintf(stdout, "%s", buf);
    }
1525
  }
1526

1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
  error= pclose(res_file);
  return WEXITSTATUS(error);
}


/*
  Run the specified tool with variable number of arguments

  SYNOPSIS
  run_tool
  tool_path - the name of the tool to run
  ds_res - pointer to dynamic string where to store the result
  ... - variable number of arguments that will be properly
        quoted and appended after the tool's name

*/

static int run_tool(const char *tool_path, DYNAMIC_STRING *ds_res, ...)
{
  int ret;
  const char* arg;
  va_list args;
  DYNAMIC_STRING ds_cmdline;

  DBUG_ENTER("run_tool");
  DBUG_PRINT("enter", ("tool_path: %s", tool_path));

  if (init_dynamic_string(&ds_cmdline, IF_WIN("\"", ""), FN_REFLEN, FN_REFLEN))
    die("Out of memory");

  dynstr_append_os_quoted(&ds_cmdline, tool_path, NullS);
  dynstr_append(&ds_cmdline, " ");

  va_start(args, ds_res);

  while ((arg= va_arg(args, char *)))
1563
  {
1564 1565 1566 1567 1568 1569
    /* Options should be os quoted */
    if (strncmp(arg, "--", 2) == 0)
      dynstr_append_os_quoted(&ds_cmdline, arg, NullS);
    else
      dynstr_append(&ds_cmdline, arg);
    dynstr_append(&ds_cmdline, " ");
1570
  }
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585

  va_end(args);

#ifdef __WIN__
  dynstr_append(&ds_cmdline, "\"");
#endif

  DBUG_PRINT("info", ("Running: %s", ds_cmdline.str));
  ret= run_command(ds_cmdline.str, ds_res);
  DBUG_PRINT("exit", ("ret: %d", ret));
  dynstr_free(&ds_cmdline);
  DBUG_RETURN(ret);
}


1586 1587 1588 1589
/*
  Test if diff is present.  This is needed on Windows systems
  as the OS returns 1 whether diff is successful or if it is
  not present.
1590

1591 1592 1593 1594 1595 1596
  We run diff -v and look for output in stdout.
  We don't redirect stderr to stdout to make for a simplified check
  Windows will output '"diff"' is not recognized... to stderr if it is
  not present.
*/

1597 1598 1599
#ifdef __WIN__

static int diff_check(const char *diff_name)
1600
{
1601
  FILE *res_file;
1602 1603
  char buf[128];
  int have_diff= 0;
1604

1605
  my_snprintf(buf, sizeof(buf), "%s -v", diff_name);
1606

1607 1608 1609 1610
  if (!(res_file= popen(buf, "r")))
    die("popen(\"%s\", \"r\") failed", buf);

  /* if diff is not present, nothing will be in stdout to increment have_diff */
1611
  if (fgets(buf, sizeof(buf), res_file))
1612 1613
    have_diff= 1;

1614
  pclose(res_file);
1615

1616
  return have_diff;
1617
}
1618

1619 1620 1621
#endif


1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
/*
  Show the diff of two files using the systems builtin diff
  command. If no such diff command exist, just dump the content
  of the two files and inform about how to get "diff"

  SYNOPSIS
  show_diff
  ds - pointer to dynamic string where to add the diff(may be NULL)
  filename1 - name of first file
  filename2 - name of second file

*/

void show_diff(DYNAMIC_STRING* ds,
               const char* filename1, const char* filename2)
{
  DYNAMIC_STRING ds_tmp;
1639
  const char *diff_name = 0;
1640 1641

  if (init_dynamic_string(&ds_tmp, "", 256, 256))
1642
    die("Out of memory");
1643

1644 1645 1646
  /* determine if we have diff on Windows
     needs special processing due to return values
     on that OS
1647 1648 1649
     This test is only done on Windows since it's only needed there
     in order to correctly detect non-availibility of 'diff', and
     the way it's implemented does not work with default 'diff' on Solaris.
1650
  */
Luis Soares's avatar
Luis Soares committed
1651
#ifdef __WIN__
1652 1653 1654 1655 1656 1657
  if (diff_check("diff"))
    diff_name = "diff";
  else if (diff_check("mtrdiff"))
    diff_name = "mtrdiff";
  else
    diff_name = 0;
Luis Soares's avatar
Luis Soares committed
1658
#else
hery's avatar
hery committed
1659
  diff_name = "diff";           /* Otherwise always assume it's called diff */
1660
#endif
1661

1662
  if (diff_name)
1663
  {
1664
    /* First try with unified diff */
1665
    if (run_tool(diff_name,
1666
                 &ds_tmp, /* Get output from diff in ds_tmp */
1667
                 "-u",
1668 1669 1670 1671
                 filename1,
                 filename2,
                 "2>&1",
                 NULL) > 1) /* Most "diff" tools return >1 if error */
1672
    {
1673 1674
      dynstr_set(&ds_tmp, "");

1675
      /* Fallback to context diff with "diff -c" */
1676
      if (run_tool(diff_name,
1677
                   &ds_tmp, /* Get output from diff in ds_tmp */
1678
                   "-c",
1679 1680 1681 1682 1683
                   filename1,
                   filename2,
                   "2>&1",
                   NULL) > 1) /* Most "diff" tools return >1 if error */
      {
Luis Soares's avatar
Luis Soares committed
1684 1685 1686
	dynstr_set(&ds_tmp, "");

	/* Fallback to simple diff with "diff" */
1687
	if (run_tool(diff_name,
Luis Soares's avatar
Luis Soares committed
1688 1689 1690 1691 1692 1693
		     &ds_tmp, /* Get output from diff in ds_tmp */
		     filename1,
		     filename2,
		     "2>&1",
		     NULL) > 1) /* Most "diff" tools return >1 if error */
	    {
1694
		diff_name= 0;
Luis Soares's avatar
Luis Soares committed
1695
	    }
1696 1697
      }
    }
Luis Soares's avatar
Luis Soares committed
1698
  }  
1699

1700
  if (! diff_name)
1701 1702 1703 1704 1705 1706 1707
  {
    /*
      Fallback to dump both files to result file and inform
      about installing "diff"
    */
	dynstr_append(&ds_tmp, "\n");
    dynstr_append(&ds_tmp,
1708 1709
"\n"
"The two files differ but it was not possible to execute 'diff' in\n"
1710 1711
"order to show only the difference. Instead the whole content of the\n"
"two files was shown for you to diff manually.\n\n"
1712 1713 1714 1715 1716 1717 1718
"To get a better report you should install 'diff' on your system, which you\n"
"for example can get from http://www.gnu.org/software/diffutils/diffutils.html\n"
#ifdef __WIN__
"or http://gnuwin32.sourceforge.net/packages/diffutils.htm\n"
#endif
"\n");

1719 1720 1721 1722 1723 1724 1725 1726 1727
    dynstr_append(&ds_tmp, " --- ");
    dynstr_append(&ds_tmp, filename1);
    dynstr_append(&ds_tmp, " >>>\n");
    cat_file(&ds_tmp, filename1);
    dynstr_append(&ds_tmp, "<<<\n --- ");
    dynstr_append(&ds_tmp, filename1);
    dynstr_append(&ds_tmp, " >>>\n");
    cat_file(&ds_tmp, filename2);
    dynstr_append(&ds_tmp, "<<<<\n");
1728
  }
1729 1730 1731 1732 1733 1734

  if (ds)
  {
    /* Add the diff to output */
    dynstr_append_mem(ds, ds_tmp.str, ds_tmp.length);
  }
1735 1736
  else
  {
1737
    /* Print diff directly to stdout */
1738
    fprintf(stderr, "%s\n", ds_tmp.str);
1739
  }
1740 1741
 
  dynstr_free(&ds_tmp);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1742

1743
}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1744 1745


1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
enum compare_files_result_enum {
   RESULT_OK= 0,
   RESULT_CONTENT_MISMATCH= 1,
   RESULT_LENGTH_MISMATCH= 2
};

/*
  Compare two files, given a fd to the first file and
  name of the second file

  SYNOPSIS
  compare_files2
  fd - Open file descriptor of the first file
  filename2 - Name of second file

  RETURN VALUES
  According to the values in "compare_files_result_enum"

*/

int compare_files2(File fd, const char* filename2)
{
  int error= RESULT_OK;
  File fd2;
1770
  size_t len, len2;
1771
  char buff[512], buff2[512];
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1772

1773 1774 1775
  if ((fd2= my_open(filename2, O_RDONLY, MYF(0))) < 0)
  {
    my_close(fd, MYF(0));
1776
    die("Failed to open second file: '%s'", filename2);
1777
  }
1778
  while((len= my_read(fd, (uchar*)&buff,
1779 1780
                      sizeof(buff), MYF(0))) > 0)
  {
1781
    if ((len2= my_read(fd2, (uchar*)&buff2,
1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
                       sizeof(buff2), MYF(0))) < len)
    {
      /* File 2 was smaller */
      error= RESULT_LENGTH_MISMATCH;
      break;
    }
    if (len2 > len)
    {
      /* File 1 was smaller */
      error= RESULT_LENGTH_MISMATCH;
      break;
    }
    if ((memcmp(buff, buff2, len)))
    {
      /* Content of this part differed */
      error= RESULT_CONTENT_MISMATCH;
      break;
    }
  }
1801
  if (!error && my_read(fd2, (uchar*)&buff2,
1802 1803 1804 1805 1806 1807 1808
                        sizeof(buff2), MYF(0)) > 0)
  {
    /* File 1 was smaller */
    error= RESULT_LENGTH_MISMATCH;
  }

  my_close(fd2, MYF(0));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1809

1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832
  return error;
}


/*
  Compare two files, given their filenames

  SYNOPSIS
  compare_files
  filename1 - Name of first file
  filename2 - Name of second file

  RETURN VALUES
  See 'compare_files2'

*/

int compare_files(const char* filename1, const char* filename2)
{
  File fd;
  int error;

  if ((fd= my_open(filename1, O_RDONLY, MYF(0))) < 0)
1833
    die("Failed to open first file: '%s'", filename1);
1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858

  error= compare_files2(fd, filename2);

  my_close(fd, MYF(0));

  return error;
}


/*
  Compare content of the string in ds to content of file fname

  SYNOPSIS
  dyn_string_cmp
  ds - Dynamic string containing the string o be compared
  fname - Name of file to compare with

  RETURN VALUES
  See 'compare_files2'
*/

int dyn_string_cmp(DYNAMIC_STRING* ds, const char *fname)
{
  int error;
  File fd;
1859
  char temp_file_path[FN_REFLEN];
1860 1861 1862 1863

  DBUG_ENTER("dyn_string_cmp");
  DBUG_PRINT("enter", ("fname: %s", fname));

1864
  if ((fd= create_temp_file(temp_file_path, TMPDIR,
1865 1866 1867 1868 1869
                            "tmp", O_CREAT | O_SHARE | O_RDWR,
                            MYF(MY_WME))) < 0)
    die("Failed to create temporary file for ds");

  /* Write ds to temporary file and set file pos to beginning*/
1870
  if (my_write(fd, (uchar *) ds->str, ds->length,
1871 1872 1873 1874 1875
               MYF(MY_FNABP | MY_WME)) ||
      my_seek(fd, 0, SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR)
  {
    my_close(fd, MYF(0));
    /* Remove the temporary file */
1876 1877
    my_delete(temp_file_path, MYF(0));
    die("Failed to write file '%s'", temp_file_path);
1878 1879 1880 1881 1882 1883
  }

  error= compare_files2(fd, fname);

  my_close(fd, MYF(0));
  /* Remove the temporary file */
1884
  my_delete(temp_file_path, MYF(0));
1885 1886

  DBUG_RETURN(error);
1887 1888
}

1889 1890

/*
1891
  Check the content of log against result file
1892 1893 1894 1895 1896 1897 1898 1899 1900

  SYNOPSIS
  check_result

  RETURN VALUES
  error - the function will not return

*/

1901
void check_result()
1902
{
1903 1904
  const char* mess= "Result content mismatch\n";

1905
  DBUG_ENTER("check_result");
1906
  DBUG_ASSERT(result_file_name);
1907
  DBUG_PRINT("enter", ("result_file_name: %s", result_file_name));
1908

1909
  switch (compare_files(log_file.file_name(), result_file_name)) {
1910
  case RESULT_OK:
1911
    break; /* ok */
1912
  case RESULT_LENGTH_MISMATCH:
1913 1914
    mess= "Result length mismatch\n";
    /* Fallthrough */
1915
  case RESULT_CONTENT_MISMATCH:
1916
  {
1917 1918 1919 1920
    /*
      Result mismatched, dump results to .reject file
      and then show the diff
    */
1921
    char reject_file[FN_REFLEN];
1922
    size_t reject_length;
1923
    dirname_part(reject_file, result_file_name, &reject_length);
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936

    if (access(reject_file, W_OK) == 0)
    {
      /* Result file directory is writable, save reject file there */
      fn_format(reject_file, result_file_name, NULL,
                ".reject", MY_REPLACE_EXT);
    }
    else
    {
      /* Put reject file in opt_logdir */
      fn_format(reject_file, result_file_name, opt_logdir,
                ".reject", MY_REPLACE_DIR | MY_REPLACE_EXT);
    }
1937

1938 1939 1940
    if (my_copy(log_file.file_name(), reject_file, MYF(0)) != 0)
      die("Failed to copy '%s' to '%s', errno: %d",
          log_file.file_name(), reject_file, errno);
1941 1942

    show_diff(NULL, result_file_name, reject_file);
1943
    die("%s", mess);
1944
    break;
1945
  }
1946 1947 1948
  default: /* impossible */
    die("Unknown error code from dyn_string_cmp()");
  }
1949 1950 1951 1952 1953

  DBUG_VOID_RETURN;
}


1954 1955 1956 1957 1958 1959
/*
  Check the content of ds against a require file
  If match fails, abort the test with special error code
  indicating that test is not supported

  SYNOPSIS
1960
  check_require
1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
  ds - content to be checked
  fname - name of file to check against

  RETURN VALUES
  error - the function will not return

*/

void check_require(DYNAMIC_STRING* ds, const char *fname)
{
  DBUG_ENTER("check_require");

  if (dyn_string_cmp(ds, fname))
  {
    char reason[FN_REFLEN];
    fn_format(reason, fname, "", "", MY_REPLACE_EXT | MY_REPLACE_DIR);
    abort_not_supported_test("Test requires: '%s'", reason);
  }
  DBUG_VOID_RETURN;
}


1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
/*
   Remove surrounding chars from string

   Return 1 if first character is found but not last
*/
static int strip_surrounding(char* str, char c1, char c2)
{
  char* ptr= str;

  /* Check if the first non space character is c1 */
  while(*ptr && my_isspace(charset_info, *ptr))
    ptr++;
  if (*ptr == c1)
  {
    /* Replace it with a space */
    *ptr= ' ';

    /* Last non space charecter should be c2 */
    ptr= strend(str)-1;
    while(*ptr && my_isspace(charset_info, *ptr))
      ptr--;
    if (*ptr == c2)
    {
      /* Replace it with \0 */
      *ptr= 0;
    }
    else
    {
      /* Mismatch detected */
      return 1;
    }
  }
  return 0;
}


static void strip_parentheses(struct st_command *command)
{
  if (strip_surrounding(command->first_argument, '(', ')'))
      die("%.*s - argument list started with '%c' must be ended with '%c'",
          command->first_word_len, command->query, '(', ')');
}


2027 2028
C_MODE_START

2029 2030
static uchar *get_var_key(const uchar* var, size_t *len,
                          my_bool __attribute__((unused)) t)
2031 2032 2033 2034
{
  register char* key;
  key = ((VAR*)var)->name;
  *len = ((VAR*)var)->name_len;
2035
  return (uchar*)key;
2036 2037 2038
}


2039 2040
static void var_free(void *v)
{
2041 2042 2043 2044
  VAR *var= (VAR*) v;
  my_free(var->str_val);
  if (var->alloced)
    my_free(var);
2045 2046 2047 2048
}

C_MODE_END

2049
void var_check_int(VAR *v)
2050 2051
{
  char *endptr;
2052 2053
  char *str= v->str_val;
  
2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065
  /* Initially assume not a number */
  v->int_val= 0;
  v->is_int= false;
  v->int_dirty= false;
  if (!str) return;
  
  v->int_val = (int) strtol(str, &endptr, 10);
  /* It is an int if strtol consumed something up to end/space/tab */
  if (endptr > str && (!*endptr || *endptr == ' ' || *endptr == '\t'))
    v->is_int= true;
}

2066

2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080
VAR *var_init(VAR *v, const char *name, int name_len, const char *val,
              int val_len)
{
  int val_alloc_len;
  VAR *tmp_var;
  if (!name_len && name)
    name_len = strlen(name);
  if (!val_len && val)
    val_len = strlen(val) ;
  val_alloc_len = val_len + 16; /* room to grow */
  if (!(tmp_var=v) && !(tmp_var = (VAR*)my_malloc(sizeof(*tmp_var)
                                                  + name_len+1, MYF(MY_WME))))
    die("Out of memory");

2081 2082 2083 2084 2085 2086 2087 2088 2089
  if (name != NULL)
  {
    tmp_var->name= reinterpret_cast<char*>(tmp_var) + sizeof(*tmp_var);
    memcpy(tmp_var->name, name, name_len);
    tmp_var->name[name_len]= 0;
  }
  else
    tmp_var->name= NULL;

2090 2091
  tmp_var->alloced = (v == 0);

2092
  if (!(tmp_var->str_val = (char*)my_malloc(val_alloc_len+1, MYF(MY_WME))))
2093 2094 2095 2096 2097 2098 2099
    die("Out of memory");

  if (val)
  {
    memcpy(tmp_var->str_val, val, val_len);
    tmp_var->str_val[val_len]= 0;
  }
2100
  var_check_int(tmp_var);
2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115
  tmp_var->name_len = name_len;
  tmp_var->str_val_len = val_len;
  tmp_var->alloced_len = val_alloc_len;
  return tmp_var;
}


VAR* var_from_env(const char *name, const char *def_val)
{
  const char *tmp;
  VAR *v;
  if (!(tmp = getenv(name)))
    tmp = def_val;

  v = var_init(0, name, strlen(name), tmp, strlen(tmp));
2116
  my_hash_insert(&var_hash, (uchar*)v);
2117
  return v;
2118 2119
}

2120

2121
VAR* var_get(const char *var_name, const char **var_name_end, my_bool raw,
2122
	     my_bool ignore_not_existing)
2123 2124
{
  int digit;
2125
  VAR *v;
2126
  DBUG_ENTER("var_get");
2127
  DBUG_PRINT("enter", ("var_name: %s",var_name));
2128 2129

  if (*var_name != '$')
2130
    goto err;
2131
  digit = *++var_name - '0';
serg@serg.mylan's avatar
serg@serg.mylan committed
2132
  if (digit < 0 || digit >= 10)
2133
  {
2134
    const char *save_var_name = var_name, *end;
2135
    uint length;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2136
    end = (var_name_end) ? *var_name_end : 0;
2137
    while (my_isvar(charset_info,*var_name) && var_name != end)
2138
      var_name++;
2139 2140 2141 2142
    if (var_name == save_var_name)
    {
      if (ignore_not_existing)
	DBUG_RETURN(0);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2143
      die("Empty variable");
2144
    }
2145
    length= (uint) (var_name - save_var_name);
2146
    if (length >= MAX_VAR_NAME_LENGTH)
2147
      die("Too long variable name: %s", save_var_name);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2148

Konstantin Osipov's avatar
Konstantin Osipov committed
2149 2150
    if (!(v = (VAR*) my_hash_search(&var_hash, (const uchar*) save_var_name,
                                    length)))
2151
    {
2152
      char buff[MAX_VAR_NAME_LENGTH+1];
serg@serg.mylan's avatar
serg@serg.mylan committed
2153
      strmake(buff, save_var_name, length);
2154
      v= var_from_env(buff, "");
2155
    }
2156
    var_name--;	/* Point at last character */
2157
  }
2158
  else
2159
    v = var_reg + digit;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2160

2161 2162 2163
  if (!raw && v->int_dirty)
  {
    sprintf(v->str_val, "%d", v->int_val);
2164
    v->int_dirty= false;
2165
    v->str_val_len = strlen(v->str_val);
2166
  }
2167
  if (var_name_end)
2168
    *var_name_end = var_name  ;
2169
  DBUG_RETURN(v);
2170 2171
err:
  if (var_name_end)
2172 2173
    *var_name_end = 0;
  die("Unsupported variable name: %s", var_name);
2174
  DBUG_RETURN(0);
2175 2176
}

2177 2178

VAR *var_obtain(const char *name, int len)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2179 2180
{
  VAR* v;
Konstantin Osipov's avatar
Konstantin Osipov committed
2181
  if ((v = (VAR*)my_hash_search(&var_hash, (const uchar *) name, len)))
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2182
    return v;
2183
  v = var_init(0, name, len, "", 0);
2184
  my_hash_insert(&var_hash, (uchar*)v);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2185 2186 2187
  return v;
}

2188 2189 2190 2191 2192 2193 2194 2195 2196

/*
  - if variable starts with a $ it is regarded as a local test varable
  - if not it is treated as a environment variable, and the corresponding
  environment variable will be updated
*/

void var_set(const char *var_name, const char *var_name_end,
             const char *var_val, const char *var_val_end)
2197
{
2198 2199
  int digit, env_var= 0;
  VAR *v;
2200 2201 2202 2203 2204 2205
  DBUG_ENTER("var_set");
  DBUG_PRINT("enter", ("var_name: '%.*s' = '%.*s' (length: %d)",
                       (int) (var_name_end - var_name), var_name,
                       (int) (var_val_end - var_val), var_val,
                       (int) (var_val_end - var_val)));

2206 2207 2208 2209 2210 2211 2212
  if (*var_name != '$')
    env_var= 1;
  else
    var_name++;

  digit= *var_name - '0';
  if (!(digit < 10 && digit >= 0))
2213
  {
2214
    v= var_obtain(var_name, (uint) (var_name_end - var_name));
2215
  }
2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
  else
    v= var_reg + digit;

  eval_expr(v, var_val, (const char**) &var_val_end);

  if (env_var)
  {
    if (v->int_dirty)
    {
      sprintf(v->str_val, "%d", v->int_val);
2226
      v->int_dirty=false;
2227 2228
      v->str_val_len= strlen(v->str_val);
    }
2229 2230 2231
    /* setenv() expects \0-terminated strings */
    DBUG_ASSERT(v->name[v->name_len] == 0);
    setenv(v->name, v->str_val, 1);
2232 2233 2234 2235
  }
  DBUG_VOID_RETURN;
}

2236 2237 2238 2239 2240 2241 2242 2243 2244 2245

void var_set_string(const char* name, const char* value)
{
  var_set(name, name + strlen(name), value, value + strlen(value));
}


void var_set_int(const char* name, int value)
{
  char buf[21];
2246
  my_snprintf(buf, sizeof(buf), "%d", value);
2247 2248 2249 2250
  var_set_string(name, buf);
}


2251 2252
/*
  Store an integer (typically the returncode of the last SQL)
2253
  statement in the mysqltest builtin variable $mysql_errno
2254 2255 2256 2257
*/

void var_set_errno(int sql_errno)
{
2258
  var_set_int("$mysql_errno", sql_errno);
2259 2260
}

2261

2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
/*
  Set variable from the result of a query

  SYNOPSIS
  var_query_set()
  var	        variable to set from query
  query       start of query string to execute
  query_end   end of the query string to execute


  DESCRIPTION
  let @<var_name> = `<query>`

  Execute the query and assign the first row of result to var as
  a tab separated strings

  Also assign each column of the result set to
  variable "$<var_name>_<column_name>"
  Thus the tab separated output can be read from $<var_name> and
  and each individual column can be read as $<var_name>_<col_name>

*/

void var_query_set(VAR *var, const char *query, const char** query_end)
{
2287
  char *end = (char*)((query_end && *query_end) ?
2288 2289 2290 2291
		      *query_end : query + strlen(query));
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL* mysql = &cur_con->mysql;
2292
  DYNAMIC_STRING ds_query;
2293 2294 2295
  DBUG_ENTER("var_query_set");
  LINT_INIT(res);

2296
  /* Only white space or ) allowed past ending ` */
2297
  while (end > query && *end != '`')
2298 2299 2300
  {
    if (*end && (*end != ' ' && *end != '\t' && *end != '\n' && *end != ')'))
      die("Spurious text after `query` expression");
2301
    --end;
2302 2303
  }

2304 2305 2306 2307
  if (query == end)
    die("Syntax error in query, missing '`'");
  ++query;

2308 2309 2310 2311
  /* Eval the query, thus replacing all environment variables */
  init_dynamic_string(&ds_query, 0, (end - query) + 32, 256);
  do_eval(&ds_query, query, end, FALSE);

2312
  if (mysql_real_query(mysql, ds_query.str, ds_query.length))
2313
    die("Error running query '%s': %d %s", ds_query.str,
2314
	mysql_errno(mysql), mysql_error(mysql));
2315 2316
  if (!(res= mysql_store_result(mysql)))
    die("Query '%s' didn't return a result set", ds_query.str);
2317
  dynstr_free(&ds_query);
2318

2319
  if ((row= mysql_fetch_row(res)) && row[0])
2320
  {
2321
    /*
2322 2323
      Concatenate all fields in the first row with tab in between
      and assign that string to the $variable
2324 2325 2326 2327 2328
    */
    DYNAMIC_STRING result;
    uint i;
    ulong *lengths;

2329
    init_dynamic_string(&result, "", 512, 512);
2330
    lengths= mysql_fetch_lengths(res);
2331
    for (i= 0; i < mysql_num_fields(res); i++)
2332
    {
2333
      if (row[i])
2334 2335 2336 2337 2338 2339 2340
      {
        /* Add column to tab separated string */
	dynstr_append_mem(&result, row[i], lengths[i]);
      }
      dynstr_append_mem(&result, "\t", 1);
    }
    end= result.str + result.length-1;
2341
    /* Evaluation should not recurse via backtick */
Bjorn Munch's avatar
Bjorn Munch committed
2342
    eval_expr(var, result.str, (const char**) &end, false, false);
2343
    dynstr_free(&result);
2344
  }
2345
  else
2346 2347 2348 2349 2350 2351 2352
    eval_expr(var, "", 0);

  mysql_free_result(res);
  DBUG_VOID_RETURN;
}


2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
static void
set_result_format_version(ulong new_version)
{
  switch (new_version){
  case 1:
    /* The first format */
    break;
  case 2:
    /* New format that also writes comments and empty lines
       from test file to result */
    break;
  default:
    die("Version format %lu has not yet been implemented", new_version);
    break;
  }
  opt_result_format_version= new_version;
}


/*
  Set the result format version to use when generating
  the .result file
*/

static void
do_result_format_version(struct st_command *command)
{
  long version;
  static DYNAMIC_STRING ds_version;
  const struct command_arg result_format_args[] = {
2383
    {"version", ARG_STRING, TRUE, &ds_version, "Version to use"}
2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405
  };

  DBUG_ENTER("do_result_format_version");

  check_command_args(command, command->first_argument,
                     result_format_args,
                     sizeof(result_format_args)/sizeof(struct command_arg),
                     ',');

  /* Convert version  number to int */
  if (!str2int(ds_version.str, 10, (long) 0, (long) INT_MAX, &version))
    die("Invalid version number: '%s'", ds_version.str);

  set_result_format_version(version);

  dynstr_append(&ds_res, "result_format: ");
  dynstr_append_mem(&ds_res, ds_version.str, ds_version.length);
  dynstr_append(&ds_res, "\n");
  dynstr_free(&ds_version);
}


2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
/*
  Set variable from the result of a field in a query

  This function is useful when checking for a certain value
  in the output from a query that can't be restricted to only
  return some values. A very good example of that is most SHOW
  commands.

  SYNOPSIS
  var_set_query_get_value()

  DESCRIPTION
  let $variable= query_get_value(<query to run>,<column name>,<row no>);

  <query to run> -    The query that should be sent to the server
  <column name> -     Name of the column that holds the field be compared
                      against the expected value
  <row no> -          Number of the row that holds the field to be
                      compared against the expected value

*/

void var_set_query_get_value(struct st_command *command, VAR *var)
{
2430
  long row_no;
2431 2432 2433 2434 2435 2436 2437 2438
  int col_no= -1;
  MYSQL_RES* res;
  MYSQL* mysql= &cur_con->mysql;

  static DYNAMIC_STRING ds_query;
  static DYNAMIC_STRING ds_col;
  static DYNAMIC_STRING ds_row;
  const struct command_arg query_get_value_args[] = {
2439 2440 2441
    {"query", ARG_STRING, TRUE, &ds_query, "Query to run"},
    {"column name", ARG_STRING, TRUE, &ds_col, "Name of column"},
    {"row number", ARG_STRING, TRUE, &ds_row, "Number for row"}
2442 2443 2444
  };

  DBUG_ENTER("var_set_query_get_value");
2445
  LINT_INIT(res);
2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501

  strip_parentheses(command);
  DBUG_PRINT("info", ("query: %s", command->query));
  check_command_args(command, command->first_argument, query_get_value_args,
                     sizeof(query_get_value_args)/sizeof(struct command_arg),
                     ',');

  DBUG_PRINT("info", ("query: %s", ds_query.str));
  DBUG_PRINT("info", ("col: %s", ds_col.str));

  /* Convert row number to int */
  if (!str2int(ds_row.str, 10, (long) 0, (long) INT_MAX, &row_no))
    die("Invalid row number: '%s'", ds_row.str);
  DBUG_PRINT("info", ("row: %s, row_no: %ld", ds_row.str, row_no));
  dynstr_free(&ds_row);

  /* Remove any surrounding "'s from the query - if there is any */
  if (strip_surrounding(ds_query.str, '"', '"'))
    die("Mismatched \"'s around query '%s'", ds_query.str);

  /* Run the query */
  if (mysql_real_query(mysql, ds_query.str, ds_query.length))
    die("Error running query '%s': %d %s", ds_query.str,
	mysql_errno(mysql), mysql_error(mysql));
  if (!(res= mysql_store_result(mysql)))
    die("Query '%s' didn't return a result set", ds_query.str);

  {
    /* Find column number from the given column name */
    uint i;
    uint num_fields= mysql_num_fields(res);
    MYSQL_FIELD *fields= mysql_fetch_fields(res);

    for (i= 0; i < num_fields; i++)
    {
      if (strcmp(fields[i].name, ds_col.str) == 0 &&
          strlen(fields[i].name) == ds_col.length)
      {
        col_no= i;
        break;
      }
    }
    if (col_no == -1)
    {
      mysql_free_result(res);
      die("Could not find column '%s' in the result of '%s'",
          ds_col.str, ds_query.str);
    }
    DBUG_PRINT("info", ("Found column %d with name '%s'",
                        i, fields[i].name));
  }
  dynstr_free(&ds_col);

  {
    /* Get the value */
    MYSQL_ROW row;
2502
    long rows= 0;
2503 2504 2505 2506
    const char* value= "No such row";

    while ((row= mysql_fetch_row(res)))
    {
msvensson@pilot.(none)'s avatar
msvensson@pilot.(none) committed
2507
      if (++rows == row_no)
2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529
      {

        DBUG_PRINT("info", ("At row %ld, column %d is '%s'",
                            row_no, col_no, row[col_no]));
        /* Found the row to get */
        if (row[col_no])
          value= row[col_no];
        else
          value= "NULL";

        break;
      }
    }
    eval_expr(var, value, 0);
  }
  dynstr_free(&ds_query);
  mysql_free_result(res);

  DBUG_VOID_RETURN;
}


2530 2531 2532
void var_copy(VAR *dest, VAR *src)
{
  dest->int_val= src->int_val;
2533
  dest->is_int= src->is_int;
2534 2535 2536 2537 2538
  dest->int_dirty= src->int_dirty;

  /* Alloc/realloc data for str_val in dest */
  if (dest->alloced_len < src->alloced_len &&
      !(dest->str_val= dest->str_val
2539 2540
        ? (char*)my_realloc(dest->str_val, src->alloced_len, MYF(MY_WME))
        : (char*)my_malloc(src->alloced_len, MYF(MY_WME))))
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551
    die("Out of memory");
  else
    dest->alloced_len= src->alloced_len;

  /* Copy str_val data to dest */
  dest->str_val_len= src->str_val_len;
  if (src->str_val_len)
    memcpy(dest->str_val, src->str_val, src->str_val_len);
}


Bjorn Munch's avatar
Bjorn Munch committed
2552 2553
void eval_expr(VAR *v, const char *p, const char **p_end,
               bool open_end, bool backtick)
2554
{
2555 2556 2557 2558

  DBUG_ENTER("eval_expr");
  DBUG_PRINT("enter", ("p: '%s'", p));

2559 2560
  if (*p == '$')
  {
2561
    VAR *vp;
2562
    const char* expected_end= *p_end; // Remember var end
2563 2564
    if ((vp= var_get(p, p_end, 0, 0)))
      var_copy(v, vp);
2565

2566 2567 2568
    /* Apparently it is not safe to assume null-terminated string */
    v->str_val[v->str_val_len]= 0;

2569 2570
    /* Make sure there was just a $variable and nothing else */
    const char* end= *p_end + 1;
2571
    if (end < expected_end && !open_end)
2572
      die("Found junk '%.*s' after $variable in expression",
Magnus Svensson's avatar
Magnus Svensson committed
2573
          (int)(expected_end - end - 1), end);
2574

2575
    DBUG_VOID_RETURN;
2576
  }
2577

2578
  if (*p == '`' && backtick)
2579 2580
  {
    var_query_set(v, p, p_end);
2581
    DBUG_VOID_RETURN;
2582
  }
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600

  {
    /* Check if this is a "let $var= query_get_value()" */
    const char* get_value_str= "query_get_value";
    const size_t len= strlen(get_value_str);
    if (strncmp(p, get_value_str, len)==0)
    {
      struct st_command command;
      memset(&command, 0, sizeof(command));
      command.query= (char*)p;
      command.first_word_len= len;
      command.first_argument= command.query + len;
      command.end= (char*)*p_end;
      var_set_query_get_value(&command, v);
      DBUG_VOID_RETURN;
    }
  }

2601 2602 2603 2604 2605
  {
    int new_val_len = (p_end && *p_end) ?
      (int) (*p_end - p) : (int) strlen(p);
    if (new_val_len + 1 >= v->alloced_len)
    {
2606
      static int MIN_VAR_ALLOC= 32;
2607 2608 2609
      v->alloced_len = (new_val_len < MIN_VAR_ALLOC - 1) ?
        MIN_VAR_ALLOC : new_val_len + 1;
      if (!(v->str_val =
2610 2611 2612
            v->str_val ?
            (char*)my_realloc(v->str_val, v->alloced_len+1, MYF(MY_WME)) :
            (char*)my_malloc(v->alloced_len+1, MYF(MY_WME))))
2613 2614 2615 2616 2617
        die("Out of memory");
    }
    v->str_val_len = new_val_len;
    memcpy(v->str_val, p, new_val_len);
    v->str_val[new_val_len] = 0;
2618
    var_check_int(v);
2619
  }
2620
  DBUG_VOID_RETURN;
2621 2622
}

2623

2624
int open_file(const char *name)
2625
{
joerg@mysql.com's avatar
joerg@mysql.com committed
2626
  char buff[FN_REFLEN];
msvensson@pilot.mysql.com's avatar
msvensson@pilot.mysql.com committed
2627
  size_t length;
2628 2629
  DBUG_ENTER("open_file");
  DBUG_PRINT("enter", ("name: %s", name));
msvensson@pilot.mysql.com's avatar
msvensson@pilot.mysql.com committed
2630 2631 2632 2633 2634 2635 2636 2637 2638 2639

  /* Extract path from current file and try it as base first */
  if (dirname_part(buff, cur_file->file_name, &length))
  {
    strxmov(buff, buff, name, NullS);
    if (access(buff, F_OK) == 0){
      DBUG_PRINT("info", ("The file exists"));
      name= buff;
    }
  }
2640 2641 2642 2643 2644
  if (!test_if_hard_path(name))
  {
    strxmov(buff, opt_basedir, name, NullS);
    name=buff;
  }
2645
  fn_format(buff, name, "", "", MY_UNPACK_FILENAME);
2646

2647
  if (cur_file == file_stack_end)
2648
    die("Source directives are nesting too deep");
2649
  cur_file++;
2650
  if (!(cur_file->file = fopen(buff, "rb")))
2651 2652
  {
    cur_file--;
2653
    die("Could not open '%s' for reading, errno: %d", buff, errno);
2654 2655
  }
  cur_file->file_name= my_strdup(buff, MYF(MY_FAE));
2656
  cur_file->lineno=1;
2657
  DBUG_RETURN(0);
2658
}
2659

2660 2661

/*
2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672
  Source and execute the given file

  SYNOPSIS
  do_source()
  query	called command

  DESCRIPTION
  source <file_name>

  Open the file <file_name> and execute it

2673 2674
*/

2675
void do_source(struct st_command *command)
2676
{
2677
  static DYNAMIC_STRING ds_filename;
2678
  const struct command_arg source_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
2679
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to source" }
2680 2681
  };
  DBUG_ENTER("do_source");
2682

2683 2684 2685
  check_command_args(command, command->first_argument, source_args,
                     sizeof(source_args)/sizeof(struct command_arg),
                     ' ');
2686

2687 2688 2689 2690 2691 2692 2693
  /*
    If this file has already been sourced, don't source it again.
    It's already available in the q_lines cache.
  */
  if (parser.current_line < (parser.read_lines - 1))
    ; /* Do nothing */
  else
2694
  {
2695 2696
    DBUG_PRINT("info", ("sourcing file: %s", ds_filename.str));
    open_file(ds_filename.str);
2697
  }
2698 2699

  dynstr_free(&ds_filename);
2700
  DBUG_VOID_RETURN;
2701 2702
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2703

2704 2705 2706
#if defined __WIN__

#ifdef USE_CYGWIN
2707
/* Variables used for temporary sh files used for emulating Unix on Windows */
2708
char tmp_sh_name[64], tmp_sh_cmd[70];
2709
#endif
2710 2711

void init_tmp_sh_file()
2712
{
2713
#ifdef USE_CYGWIN
2714 2715 2716 2717
  /* Format a name for the tmp sh file that is unique for this process */
  my_snprintf(tmp_sh_name, sizeof(tmp_sh_name), "tmp_%d.sh", getpid());
  /* Format the command to execute in order to run the script */
  my_snprintf(tmp_sh_cmd, sizeof(tmp_sh_cmd), "sh %s", tmp_sh_name);
2718
#endif
2719
}
2720

2721

2722
void free_tmp_sh_file()
2723
{
2724
#ifdef USE_CYGWIN
2725
  my_delete(tmp_sh_name, MYF(0));
2726
#endif
2727
}
2728
#endif
2729

2730

2731
FILE* my_popen(DYNAMIC_STRING *ds_cmd, const char *mode)
2732
{
2733
#if defined __WIN__ && defined USE_CYGWIN
2734 2735 2736 2737 2738 2739
  /* Dump the command into a sh script file and execute with popen */
  str_to_file(tmp_sh_name, ds_cmd->str, ds_cmd->length);
  return popen(tmp_sh_cmd, mode);
#else
  return popen(ds_cmd->str, mode);
#endif
2740 2741
}

2742

2743 2744 2745
static void init_builtin_echo(void)
{
#ifdef __WIN__
2746
  size_t echo_length;
2747 2748

  /* Look for "echo.exe" in same dir as mysqltest was started from */
2749
  dirname_part(builtin_echo, my_progname, &echo_length);
2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801
  fn_format(builtin_echo, ".\\echo.exe",
            builtin_echo, "", MYF(MY_REPLACE_DIR));

  /* Make sure echo.exe exists */
  if (access(builtin_echo, F_OK) != 0)
    builtin_echo[0]= 0;
  return;

#else

  builtin_echo[0]= 0;
  return;

#endif
}


/*
  Replace a substring

  SYNOPSIS
    replace
    ds_str      The string to search and perform the replace in
    search_str  The string to search for
    search_len  Length of the string to search for
    replace_str The string to replace with
    replace_len Length of the string to replace with

  RETURN
    0 String replaced
    1 Could not find search_str in str
*/

static int replace(DYNAMIC_STRING *ds_str,
                   const char *search_str, ulong search_len,
                   const char *replace_str, ulong replace_len)
{
  DYNAMIC_STRING ds_tmp;
  const char *start= strstr(ds_str->str, search_str);
  if (!start)
    return 1;
  init_dynamic_string(&ds_tmp, "",
                      ds_str->length + replace_len, 256);
  dynstr_append_mem(&ds_tmp, ds_str->str, start - ds_str->str);
  dynstr_append_mem(&ds_tmp, replace_str, replace_len);
  dynstr_append(&ds_tmp, start + search_len);
  dynstr_set(ds_str, ds_tmp.str);
  dynstr_free(&ds_tmp);
  return 0;
}


2802 2803 2804 2805
/*
  Execute given command.

  SYNOPSIS
2806 2807
  do_exec()
  query	called command
2808 2809

  DESCRIPTION
2810
  exec <command>
2811

2812 2813 2814 2815
  Execute the text between exec and end of line in a subprocess.
  The error code returned from the subprocess is checked against the
  expected error array, previously set with the --error command.
  It can thus be used to execute a command that shall fail.
2816

2817 2818 2819
  NOTE
  Although mysqltest is executed from cygwin shell, the command will be
  executed in "cmd.exe". Thus commands like "rm" etc can NOT be used, use
2820
  mysqltest commmand(s) like "remove_file" for that
2821 2822
*/

2823
void do_exec(struct st_command *command)
2824
{
kent@mysql.com's avatar
kent@mysql.com committed
2825
  int error;
2826
  char buf[512];
2827
  FILE *res_file;
2828 2829
  char *cmd= command->first_argument;
  DYNAMIC_STRING ds_cmd;
monty@mysql.com's avatar
monty@mysql.com committed
2830
  DBUG_ENTER("do_exec");
2831
  DBUG_PRINT("enter", ("cmd: '%s'", cmd));
2832

2833
  /* Skip leading space */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2834
  while (*cmd && my_isspace(charset_info, *cmd))
2835 2836
    cmd++;
  if (!*cmd)
2837
    die("Missing argument in exec");
2838 2839 2840 2841
  command->last_argument= command->end;

  init_dynamic_string(&ds_cmd, 0, command->query_len+256, 256);
  /* Eval the command, thus replacing all environment variables */
2842
  do_eval(&ds_cmd, cmd, command->end, !is_windows);
2843

2844 2845 2846 2847 2848 2849 2850
  /* Check if echo should be replaced with "builtin" echo */
  if (builtin_echo[0] && strncmp(cmd, "echo", 4) == 0)
  {
    /* Replace echo with our "builtin" echo */
    replace(&ds_cmd, "echo", 4, builtin_echo, strlen(builtin_echo));
  }

2851
#ifdef __WIN__
2852
#ifndef USE_CYGWIN
2853 2854 2855 2856 2857 2858
  /* Replace /dev/null with NUL */
  while(replace(&ds_cmd, "/dev/null", 9, "NUL", 3) == 0)
    ;
  /* Replace "closed stdout" with non existing output fd */
  while(replace(&ds_cmd, ">&-", 3, ">&4", 3) == 0)
    ;
2859
#endif
2860 2861
#endif

2862 2863 2864 2865
  /* exec command is interpreted externally and will not take newlines */
  while(replace(&ds_cmd, "\n", 1, " ", 1) == 0)
    ;
  
2866
  DBUG_PRINT("info", ("Executing '%s' as '%s'",
2867
                      command->first_argument, ds_cmd.str));
monty@mysql.com's avatar
monty@mysql.com committed
2868

2869
  if (!(res_file= my_popen(&ds_cmd, "r")) && command->abort_on_error)
2870 2871
  {
    dynstr_free(&ds_cmd);
2872
    die("popen(\"%s\", \"r\") failed", command->first_argument);
2873
  }
monty@mysql.com's avatar
monty@mysql.com committed
2874

2875
  while (fgets(buf, sizeof(buf), res_file))
2876
  {
2877
    if (disable_result_log)
2878 2879 2880 2881
    {
      buf[strlen(buf)-1]=0;
      DBUG_PRINT("exec_result",("%s", buf));
    }
2882
    else
2883
    {
2884
      replace_dynstr_append(&ds_res, buf);
2885
    }
kent@mysql.com's avatar
kent@mysql.com committed
2886 2887
  }
  error= pclose(res_file);
2888
  if (error > 0)
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2889
  {
2890 2891
    uint status= WEXITSTATUS(error);
    int i;
monty@mishka.local's avatar
monty@mishka.local committed
2892

2893
    if (command->abort_on_error)
2894
    {
msvensson@shellback.(none)'s avatar
msvensson@shellback.(none) committed
2895
      log_msg("exec of '%s' failed, error: %d, status: %d, errno: %d",
2896
              ds_cmd.str, error, status, errno);
2897
      dynstr_free(&ds_cmd);
2898 2899
      die("command \"%s\" failed\n\nOutput from before failure:\n%s\n",
          command->first_argument, ds_res.str);
2900
    }
monty@mishka.local's avatar
monty@mishka.local committed
2901 2902 2903

    DBUG_PRINT("info",
               ("error: %d, status: %d", error, status));
2904 2905 2906 2907 2908 2909 2910

    i= match_expected_error(command, status, NULL);

    if (i >= 0)
      DBUG_PRINT("info", ("command \"%s\" failed with expected error: %d",
                          command->first_argument, status));
    else
2911 2912
    {
      dynstr_free(&ds_cmd);
2913 2914 2915
      if (command->expected_errors.count > 0)
        die("command \"%s\" failed with wrong error: %d",
            command->first_argument, status);
2916
    }
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2917
  }
2918 2919
  else if (command->expected_errors.err[0].type == ERR_ERRNO &&
           command->expected_errors.err[0].code.errnum != 0)
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2920 2921
  {
    /* Error code we wanted was != 0, i.e. not an expected success */
2922 2923
    log_msg("exec of '%s failed, error: %d, errno: %d",
            ds_cmd.str, error, errno);
2924
    dynstr_free(&ds_cmd);
2925
    die("command \"%s\" succeeded - should have failed with errno %d...",
2926
        command->first_argument, command->expected_errors.err[0].code.errnum);
2927
  }
2928

2929 2930
  dynstr_free(&ds_cmd);
  DBUG_VOID_RETURN;
2931 2932
}

2933
enum enum_operator
2934
{
2935 2936 2937
  DO_DEC,
  DO_INC
};
2938

2939

2940
/*
2941
  Decrease or increase the value of a variable
2942 2943

  SYNOPSIS
2944 2945
  do_modify_var()
  query	called command
2946
  op    operation to perform on the var
2947 2948

  DESCRIPTION
2949 2950
  dec $var_name
  inc $var_name
2951

2952 2953
*/

2954
int do_modify_var(struct st_command *command,
2955
                  enum enum_operator op)
2956
{
2957
  const char *p= command->first_argument;
2958
  VAR* v;
2959
  if (!*p)
2960
    die("Missing argument to %.*s", command->first_word_len, command->query);
2961
  if (*p != '$')
2962 2963
    die("The argument to %.*s must be a variable (start with $)",
        command->first_word_len, command->query);
2964
  v= var_get(p, &p, 1, 0);
2965 2966
  if (! v->is_int)
    die("Cannot perform inc/dec on a non-numeric value");
2967
  switch (op) {
2968 2969 2970 2971 2972 2973 2974
  case DO_DEC:
    v->int_val--;
    break;
  case DO_INC:
    v->int_val++;
    break;
  default:
2975
    die("Invalid operator to do_modify_var");
2976 2977
    break;
  }
2978
  v->int_dirty= true;
2979
  command->last_argument= (char*)++p;
2980 2981 2982
  return 0;
}

2983

2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995
/*
  Wrapper for 'system' function

  NOTE
  If mysqltest is executed from cygwin shell, the command will be
  executed in the "windows command interpreter" cmd.exe and we prepend "sh"
  to make it be executed by cygwins "bash". Thus commands like "rm",
  "mkdir" as well as shellscripts can executed by "system" in Windows.

*/

int my_system(DYNAMIC_STRING* ds_cmd)
2996
{
2997
#if defined __WIN__ && defined USE_CYGWIN
2998 2999 3000 3001 3002 3003
  /* Dump the command into a sh script file and execute with system */
  str_to_file(tmp_sh_name, ds_cmd->str, ds_cmd->length);
  return system(tmp_sh_cmd);
#else
  return system(ds_cmd->str);
#endif
3004
}
3005

3006 3007 3008

/*
  SYNOPSIS
3009 3010
  do_system
  command	called command
3011 3012

  DESCRIPTION
3013
  system <command>
3014

3015 3016
  Eval the query to expand any $variables in the command.
  Execute the command with the "system" command.
3017 3018 3019

*/

3020
void do_system(struct st_command *command)
3021
{
3022 3023
  DYNAMIC_STRING ds_cmd;
  DBUG_ENTER("do_system");
3024

3025 3026
  if (strlen(command->first_argument) == 0)
    die("Missing arguments to system, nothing to do!");
3027

3028
  init_dynamic_string(&ds_cmd, 0, command->query_len + 64, 256);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3029

3030
  /* Eval the system command, thus replacing all environment variables */
3031 3032 3033
  do_eval(&ds_cmd, command->first_argument, command->end, !is_windows);

#ifdef __WIN__
3034
#ifndef USE_CYGWIN
3035 3036 3037 3038
   /* Replace /dev/null with NUL */
   while(replace(&ds_cmd, "/dev/null", 9, "NUL", 3) == 0)
     ;
#endif
3039
#endif
3040

3041

3042 3043 3044
  DBUG_PRINT("info", ("running system command '%s' as '%s'",
                      command->first_argument, ds_cmd.str));
  if (my_system(&ds_cmd))
3045
  {
3046 3047
    if (command->abort_on_error)
      die("system command '%s' failed", command->first_argument);
3048

3049 3050 3051 3052
    /* If ! abort_on_error, log message and continue */
    dynstr_append(&ds_res, "system command '");
    replace_dynstr_append(&ds_res, command->first_argument);
    dynstr_append(&ds_res, "' failed\n");
3053
  }
3054

3055 3056 3057 3058
  command->last_argument= command->end;
  dynstr_free(&ds_cmd);
  DBUG_VOID_RETURN;
}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3059

3060

3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095
/*
  SYNOPSIS
  set_wild_chars
  set  true to set * etc. as wild char, false to reset

  DESCRIPTION
  Auxiliary function to set "our" wild chars before calling wild_compare
  This is needed because the default values are changed to SQL syntax
  in mysqltest_embedded.
*/

void set_wild_chars (my_bool set)
{
  static char old_many= 0, old_one, old_prefix;

  if (set) 
  {
    if (wild_many == '*') return; // No need
    old_many= wild_many;
    old_one= wild_one;
    old_prefix= wild_prefix;
    wild_many= '*';
    wild_one= '?';
    wild_prefix= 0;
  }
  else 
  {
    if (! old_many) return;	// Was not set
    wild_many= old_many;
    wild_one= old_one;
    wild_prefix= old_prefix;
  }
}


3096 3097 3098 3099
/*
  SYNOPSIS
  do_remove_file
  command	called command
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3100

3101 3102 3103 3104
  DESCRIPTION
  remove_file <file_name>
  Remove the file <file_name>
*/
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3105

3106 3107 3108
void do_remove_file(struct st_command *command)
{
  int error;
3109
  static DYNAMIC_STRING ds_filename;
3110
  const struct command_arg rm_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3111
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to delete" }
3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123
  };
  DBUG_ENTER("do_remove_file");

  check_command_args(command, command->first_argument,
                     rm_args, sizeof(rm_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("removing file: %s", ds_filename.str));
  error= my_delete(ds_filename.str, MYF(0)) != 0;
  handle_command_error(command, error);
  dynstr_free(&ds_filename);
  DBUG_VOID_RETURN;
3124 3125 3126
}


3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171
/*
  SYNOPSIS
  do_remove_files_wildcard
  command	called command

  DESCRIPTION
  remove_files_wildcard <directory> [<file_name_pattern>]
  Remove the files in <directory> optionally matching <file_name_pattern>
*/

void do_remove_files_wildcard(struct st_command *command)
{
  int error= 0;
  uint i;
  MY_DIR *dir_info;
  FILEINFO *file;
  char dir_separator[2];
  static DYNAMIC_STRING ds_directory;
  static DYNAMIC_STRING ds_wild;
  static DYNAMIC_STRING ds_file_to_remove;
  char dirname[FN_REFLEN];
  
  const struct command_arg rm_args[] = {
    { "directory", ARG_STRING, TRUE, &ds_directory,
      "Directory containing files to delete" },
    { "filename", ARG_STRING, FALSE, &ds_wild, "File pattern to delete" }
  };
  DBUG_ENTER("do_remove_files_wildcard");

  check_command_args(command, command->first_argument,
                     rm_args, sizeof(rm_args)/sizeof(struct command_arg),
                     ' ');
  fn_format(dirname, ds_directory.str, "", "", MY_UNPACK_FILENAME);

  DBUG_PRINT("info", ("listing directory: %s", dirname));
  /* Note that my_dir sorts the list if not given any flags */
  if (!(dir_info= my_dir(dirname, MYF(MY_DONT_SORT | MY_WANT_STAT))))
  {
    error= 1;
    goto end;
  }
  init_dynamic_string(&ds_file_to_remove, dirname, 1024, 1024);
  dir_separator[0]= FN_LIBCHAR;
  dir_separator[1]= 0;
  dynstr_append(&ds_file_to_remove, dir_separator);
3172 3173 3174 3175
  
  /* Set default wild chars for wild_compare, is changed in embedded mode */
  set_wild_chars(1);
  
3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194
  for (i= 0; i < (uint) dir_info->number_off_files; i++)
  {
    file= dir_info->dir_entry + i;
    /* Remove only regular files, i.e. no directories etc. */
    /* if (!MY_S_ISREG(file->mystat->st_mode)) */
    /* MY_S_ISREG does not work here on Windows, just skip directories */
    if (MY_S_ISDIR(file->mystat->st_mode))
      continue;
    if (ds_wild.length &&
        wild_compare(file->name, ds_wild.str, 0))
      continue;
    ds_file_to_remove.length= ds_directory.length + 1;
    ds_file_to_remove.str[ds_directory.length + 1]= 0;
    dynstr_append(&ds_file_to_remove, file->name);
    DBUG_PRINT("info", ("removing file: %s", ds_file_to_remove.str));
    error= my_delete(ds_file_to_remove.str, MYF(0)) != 0;
    if (error)
      break;
  }
3195
  set_wild_chars(0);
3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206
  my_dirend(dir_info);

end:
  handle_command_error(command, error);
  dynstr_free(&ds_directory);
  dynstr_free(&ds_wild);
  dynstr_free(&ds_file_to_remove);
  DBUG_VOID_RETURN;
}


3207 3208
/*
  SYNOPSIS
3209 3210
  do_copy_file
  command	command handle
3211 3212

  DESCRIPTION
3213 3214
  copy_file <from_file> <to_file>
  Copy <from_file> to <to_file>
3215

3216 3217
  NOTE! Will fail if <to_file> exists
*/
3218

3219
void do_copy_file(struct st_command *command)
3220
{
3221
  int error;
3222 3223
  static DYNAMIC_STRING ds_from_file;
  static DYNAMIC_STRING ds_to_file;
3224
  const struct command_arg copy_file_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3225 3226
    { "from_file", ARG_STRING, TRUE, &ds_from_file, "Filename to copy from" },
    { "to_file", ARG_STRING, TRUE, &ds_to_file, "Filename to copy to" }
3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241
  };
  DBUG_ENTER("do_copy_file");

  check_command_args(command, command->first_argument,
                     copy_file_args,
                     sizeof(copy_file_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("Copy %s to %s", ds_from_file.str, ds_to_file.str));
  error= (my_copy(ds_from_file.str, ds_to_file.str,
                  MYF(MY_DONT_OVERWRITE_FILE)) != 0);
  handle_command_error(command, error);
  dynstr_free(&ds_from_file);
  dynstr_free(&ds_to_file);
  DBUG_VOID_RETURN;
3242 3243
}

3244

3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280
/*
  SYNOPSIS
  do_move_file
  command	command handle

  DESCRIPTION
  move_file <from_file> <to_file>
  Move <from_file> to <to_file>
*/

void do_move_file(struct st_command *command)
{
  int error;
  static DYNAMIC_STRING ds_from_file;
  static DYNAMIC_STRING ds_to_file;
  const struct command_arg move_file_args[] = {
    { "from_file", ARG_STRING, TRUE, &ds_from_file, "Filename to move from" },
    { "to_file", ARG_STRING, TRUE, &ds_to_file, "Filename to move to" }
  };
  DBUG_ENTER("do_move_file");

  check_command_args(command, command->first_argument,
                     move_file_args,
                     sizeof(move_file_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("Move %s to %s", ds_from_file.str, ds_to_file.str));
  error= (my_rename(ds_from_file.str, ds_to_file.str,
                    MYF(0)) != 0);
  handle_command_error(command, error);
  dynstr_free(&ds_from_file);
  dynstr_free(&ds_to_file);
  DBUG_VOID_RETURN;
}


3281 3282 3283 3284 3285 3286
/*
  SYNOPSIS
  do_chmod_file
  command	command handle

  DESCRIPTION
msvensson@pilot.mysql.com's avatar
msvensson@pilot.mysql.com committed
3287
  chmod <octal> <file_name>
3288
  Change file permission of <file_name>
3289 3290 3291 3292 3293

*/

void do_chmod_file(struct st_command *command)
{
3294
  long mode= 0;
3295
  int err_code;
3296 3297
  static DYNAMIC_STRING ds_mode;
  static DYNAMIC_STRING ds_file;
3298
  const struct command_arg chmod_file_args[] = {
3299 3300
    { "mode", ARG_STRING, TRUE, &ds_mode, "Mode of file(octal) ex. 0660"}, 
    { "filename", ARG_STRING, TRUE, &ds_file, "Filename of file to modify" }
3301 3302 3303 3304 3305 3306 3307 3308 3309
  };
  DBUG_ENTER("do_chmod_file");

  check_command_args(command, command->first_argument,
                     chmod_file_args,
                     sizeof(chmod_file_args)/sizeof(struct command_arg),
                     ' ');

  /* Parse what mode to set */
3310 3311
  if (ds_mode.length != 4 ||
      str2int(ds_mode.str, 8, 0, INT_MAX, &mode) == NullS)
3312 3313
    die("You must write a 4 digit octal number for mode");

3314
  DBUG_PRINT("info", ("chmod %o %s", (uint)mode, ds_file.str));
3315 3316 3317 3318
  err_code= chmod(ds_file.str, mode);
  if (err_code < 0)
    err_code= 1;
  handle_command_error(command, err_code);
3319 3320 3321 3322 3323 3324
  dynstr_free(&ds_mode);
  dynstr_free(&ds_file);
  DBUG_VOID_RETURN;
}


3325
/*
3326 3327 3328 3329 3330 3331 3332
  SYNOPSIS
  do_file_exists
  command	called command

  DESCRIPTION
  fiile_exist <file_name>
  Check if file <file_name> exists
3333 3334
*/

3335
void do_file_exist(struct st_command *command)
3336
{
3337
  int error;
3338
  static DYNAMIC_STRING ds_filename;
3339
  const struct command_arg file_exist_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3340
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to check if it exist" }
3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353
  };
  DBUG_ENTER("do_file_exist");

  check_command_args(command, command->first_argument,
                     file_exist_args,
                     sizeof(file_exist_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("Checking for existence of file: %s", ds_filename.str));
  error= (access(ds_filename.str, F_OK) != 0);
  handle_command_error(command, error);
  dynstr_free(&ds_filename);
  DBUG_VOID_RETURN;
3354 3355
}

3356

3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
/*
  SYNOPSIS
  do_mkdir
  command	called command

  DESCRIPTION
  mkdir <dir_name>
  Create the directory <dir_name>
*/

void do_mkdir(struct st_command *command)
{
  int error;
  static DYNAMIC_STRING ds_dirname;
  const struct command_arg mkdir_args[] = {
3372
    {"dirname", ARG_STRING, TRUE, &ds_dirname, "Directory to create"}
3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401
  };
  DBUG_ENTER("do_mkdir");

  check_command_args(command, command->first_argument,
                     mkdir_args, sizeof(mkdir_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("creating directory: %s", ds_dirname.str));
  error= my_mkdir(ds_dirname.str, 0777, MYF(0)) != 0;
  handle_command_error(command, error);
  dynstr_free(&ds_dirname);
  DBUG_VOID_RETURN;
}

/*
  SYNOPSIS
  do_rmdir
  command	called command

  DESCRIPTION
  rmdir <dir_name>
  Remove the empty directory <dir_name>
*/

void do_rmdir(struct st_command *command)
{
  int error;
  static DYNAMIC_STRING ds_dirname;
  const struct command_arg rmdir_args[] = {
3402
    {"dirname", ARG_STRING, TRUE, &ds_dirname, "Directory to remove"}
3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417
  };
  DBUG_ENTER("do_rmdir");

  check_command_args(command, command->first_argument,
                     rmdir_args, sizeof(rmdir_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("removing directory: %s", ds_dirname.str));
  error= rmdir(ds_dirname.str) != 0;
  handle_command_error(command, error);
  dynstr_free(&ds_dirname);
  DBUG_VOID_RETURN;
}


3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440
/*
  SYNOPSIS
  get_list_files
  ds          output
  ds_dirname  dir to list
  ds_wild     wild-card file pattern (can be empty)

  DESCRIPTION
  list all entries in directory (matching ds_wild if given)
*/

static int get_list_files(DYNAMIC_STRING *ds, const DYNAMIC_STRING *ds_dirname,
                          const DYNAMIC_STRING *ds_wild)
{
  uint i;
  MY_DIR *dir_info;
  FILEINFO *file;
  DBUG_ENTER("get_list_files");

  DBUG_PRINT("info", ("listing directory: %s", ds_dirname->str));
  /* Note that my_dir sorts the list if not given any flags */
  if (!(dir_info= my_dir(ds_dirname->str, MYF(0))))
    DBUG_RETURN(1);
3441
  set_wild_chars(1);
3442 3443 3444 3445 3446 3447 3448 3449 3450 3451
  for (i= 0; i < (uint) dir_info->number_off_files; i++)
  {
    file= dir_info->dir_entry + i;
    if (file->name[0] == '.' &&
        (file->name[1] == '\0' ||
         (file->name[1] == '.' && file->name[2] == '\0')))
      continue;                               /* . or .. */
    if (ds_wild && ds_wild->length &&
        wild_compare(file->name, ds_wild->str, 0))
      continue;
3452
    replace_dynstr_append(ds, file->name);
3453 3454
    dynstr_append(ds, "\n");
  }
3455
  set_wild_chars(0);
3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481
  my_dirend(dir_info);
  DBUG_RETURN(0);
}


/*
  SYNOPSIS
  do_list_files
  command	called command

  DESCRIPTION
  list_files <dir_name> [<file_name>]
  List files and directories in directory <dir_name> (like `ls`)
  [Matching <file_name>, where wild-cards are allowed]
*/

static void do_list_files(struct st_command *command)
{
  int error;
  static DYNAMIC_STRING ds_dirname;
  static DYNAMIC_STRING ds_wild;
  const struct command_arg list_files_args[] = {
    {"dirname", ARG_STRING, TRUE, &ds_dirname, "Directory to list"},
    {"file", ARG_STRING, FALSE, &ds_wild, "Filename (incl. wildcard)"}
  };
  DBUG_ENTER("do_list_files");
3482
  command->used_replace= 1;
3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523

  check_command_args(command, command->first_argument,
                     list_files_args,
                     sizeof(list_files_args)/sizeof(struct command_arg), ' ');

  error= get_list_files(&ds_res, &ds_dirname, &ds_wild);
  handle_command_error(command, error);
  dynstr_free(&ds_dirname);
  dynstr_free(&ds_wild);
  DBUG_VOID_RETURN;
}


/*
  SYNOPSIS
  do_list_files_write_file_command
  command       called command
  append        append file, or create new

  DESCRIPTION
  list_files_{write|append}_file <filename> <dir_name> [<match_file>]
  List files and directories in directory <dir_name> (like `ls`)
  [Matching <match_file>, where wild-cards are allowed]

  Note: File will be truncated if exists and append is not true.
*/

static void do_list_files_write_file_command(struct st_command *command,
                                             my_bool append)
{
  int error;
  static DYNAMIC_STRING ds_content;
  static DYNAMIC_STRING ds_filename;
  static DYNAMIC_STRING ds_dirname;
  static DYNAMIC_STRING ds_wild;
  const struct command_arg list_files_args[] = {
    {"filename", ARG_STRING, TRUE, &ds_filename, "Filename for write"},
    {"dirname", ARG_STRING, TRUE, &ds_dirname, "Directory to list"},
    {"file", ARG_STRING, FALSE, &ds_wild, "Filename (incl. wildcard)"}
  };
  DBUG_ENTER("do_list_files_write_file");
3524
  command->used_replace= 1;
3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541

  check_command_args(command, command->first_argument,
                     list_files_args,
                     sizeof(list_files_args)/sizeof(struct command_arg), ' ');

  init_dynamic_string(&ds_content, "", 1024, 1024);
  error= get_list_files(&ds_content, &ds_dirname, &ds_wild);
  handle_command_error(command, error);
  str_to_file2(ds_filename.str, ds_content.str, ds_content.length, append);
  dynstr_free(&ds_content);
  dynstr_free(&ds_filename);
  dynstr_free(&ds_dirname);
  dynstr_free(&ds_wild);
  DBUG_VOID_RETURN;
}


3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552
/*
  Read characters from line buffer or file. This is needed to allow
  my_ungetc() to buffer MAX_DELIMITER_LENGTH characters for a file

  NOTE:
  This works as long as one doesn't change files (with 'source file_name')
  when there is things pushed into the buffer.  This should however not
  happen for any tests in the test suite.
*/

int my_getc(FILE *file)
3553
{
3554 3555 3556
  if (line_buffer_pos == line_buffer)
    return fgetc(file);
  return *--line_buffer_pos;
3557 3558
}

3559

3560
void my_ungetc(int c)
3561
{
3562
  *line_buffer_pos++= (char) c;
3563 3564
}

3565

3566 3567
void read_until_delimiter(DYNAMIC_STRING *ds,
                          DYNAMIC_STRING *ds_delimiter)
3568
{
3569
  char c;
3570
  DBUG_ENTER("read_until_delimiter");
3571 3572
  DBUG_PRINT("enter", ("delimiter: %s, length: %u",
                       ds_delimiter->str, (uint) ds_delimiter->length));
3573 3574 3575 3576 3577 3578 3579 3580 3581 3582

  if (ds_delimiter->length > MAX_DELIMITER_LENGTH)
    die("Max delimiter length(%d) exceeded", MAX_DELIMITER_LENGTH);

  /* Read from file until delimiter is found */
  while (1)
  {
    c= my_getc(cur_file->file);

    if (c == '\n')
3583
    {
3584 3585
      cur_file->lineno++;

3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598
      /* Skip newline from the same line as the command */
      if (start_lineno == (cur_file->lineno - 1))
        continue;
    }
    else if (start_lineno == cur_file->lineno)
    {
      /*
        No characters except \n are allowed on
        the same line as the command
      */
      die("Trailing characters found after command");
    }

3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611
    if (feof(cur_file->file))
      die("End of file encountered before '%s' delimiter was found",
          ds_delimiter->str);

    if (match_delimiter(c, ds_delimiter->str, ds_delimiter->length))
    {
      DBUG_PRINT("exit", ("Found delimiter '%s'", ds_delimiter->str));
      break;
    }
    dynstr_append_mem(ds, (const char*)&c, 1);
  }
  DBUG_PRINT("exit", ("ds: %s", ds->str));
  DBUG_VOID_RETURN;
3612 3613 3614
}


3615 3616 3617 3618 3619 3620
void do_write_file_command(struct st_command *command, my_bool append)
{
  static DYNAMIC_STRING ds_content;
  static DYNAMIC_STRING ds_filename;
  static DYNAMIC_STRING ds_delimiter;
  const struct command_arg write_file_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3621 3622
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to write to" },
    { "delimiter", ARG_STRING, FALSE, &ds_delimiter, "Delimiter to read until" }
3623 3624 3625 3626 3627 3628 3629 3630 3631
  };
  DBUG_ENTER("do_write_file");

  check_command_args(command,
                     command->first_argument,
                     write_file_args,
                     sizeof(write_file_args)/sizeof(struct command_arg),
                     ' ');

3632 3633 3634 3635 3636 3637
  if (!append && access(ds_filename.str, F_OK) == 0)
  {
    /* The file should not be overwritten */
    die("File already exist: '%s'", ds_filename.str);
  }

3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655
  ds_content= command->content;
  /* If it hasn't been done already by a loop iteration, fill it in */
  if (! ds_content.str)
  {
    /* If no delimiter was provided, use EOF */
    if (ds_delimiter.length == 0)
      dynstr_set(&ds_delimiter, "EOF");

    init_dynamic_string(&ds_content, "", 1024, 1024);
    read_until_delimiter(&ds_content, &ds_delimiter);
    command->content= ds_content;
  }
  /* This function could be called even if "false", so check before printing */
  if (cur_block->ok)
  {
    DBUG_PRINT("info", ("Writing to file: %s", ds_filename.str));
    str_to_file2(ds_filename.str, ds_content.str, ds_content.length, append);
  }
3656 3657 3658 3659 3660 3661
  dynstr_free(&ds_filename);
  dynstr_free(&ds_delimiter);
  DBUG_VOID_RETURN;
}


3662 3663
/*
  SYNOPSIS
3664 3665
  do_write_file
  command	called command
3666 3667

  DESCRIPTION
3668 3669 3670 3671 3672
  write_file <file_name> [<delimiter>];
  <what to write line 1>
  <...>
  < what to write line n>
  EOF
paul@snake-hub.snake.net's avatar
paul@snake-hub.snake.net committed
3673

3674 3675 3676 3677 3678
  --write_file <file_name>;
  <what to write line 1>
  <...>
  < what to write line n>
  EOF
3679

3680 3681
  Write everything between the "write_file" command and 'delimiter'
  to "file_name"
3682

3683
  NOTE! Will fail if <file_name> exists
3684

3685
  Default <delimiter> is EOF
3686

3687
*/
3688

3689
void do_write_file(struct st_command *command)
3690
{
3691 3692
  do_write_file_command(command, FALSE);
}
3693 3694


3695 3696 3697 3698
/*
  SYNOPSIS
  do_append_file
  command	called command
3699

3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722
  DESCRIPTION
  append_file <file_name> [<delimiter>];
  <what to write line 1>
  <...>
  < what to write line n>
  EOF

  --append_file <file_name>;
  <what to write line 1>
  <...>
  < what to write line n>
  EOF

  Append everything between the "append_file" command
  and 'delimiter' to "file_name"

  Default <delimiter> is EOF

*/

void do_append_file(struct st_command *command)
{
  do_write_file_command(command, TRUE);
3723 3724
}

kent@mysql.com's avatar
kent@mysql.com committed
3725

3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739
/*
  SYNOPSIS
  do_cat_file
  command	called command

  DESCRIPTION
  cat_file <file_name>;

  Print the given file to result log

*/

void do_cat_file(struct st_command *command)
{
3740
  int error;
3741 3742
  static DYNAMIC_STRING ds_filename;
  const struct command_arg cat_file_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3743
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to read from" }
3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754
  };
  DBUG_ENTER("do_cat_file");

  check_command_args(command,
                     command->first_argument,
                     cat_file_args,
                     sizeof(cat_file_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("Reading from, file: %s", ds_filename.str));

3755 3756
  error= cat_file(&ds_res, ds_filename.str);
  handle_command_error(command, error);
3757 3758 3759 3760 3761
  dynstr_free(&ds_filename);
  DBUG_VOID_RETURN;
}


3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779
/*
  SYNOPSIS
  do_diff_files
  command	called command

  DESCRIPTION
  diff_files <file1> <file2>;

  Fails if the two files differ.

*/

void do_diff_files(struct st_command *command)
{
  int error= 0;
  static DYNAMIC_STRING ds_filename;
  static DYNAMIC_STRING ds_filename2;
  const struct command_arg diff_file_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3780 3781
    { "file1", ARG_STRING, TRUE, &ds_filename, "First file to diff" },
    { "file2", ARG_STRING, TRUE, &ds_filename2, "Second file to diff" }
3782 3783 3784 3785 3786 3787 3788 3789 3790
  };
  DBUG_ENTER("do_diff_files");

  check_command_args(command,
                     command->first_argument,
                     diff_file_args,
                     sizeof(diff_file_args)/sizeof(struct command_arg),
                     ' ');

3791 3792 3793 3794 3795 3796 3797 3798
  if (access(ds_filename.str, F_OK) != 0)
    die("command \"diff_files\" failed, file '%s' does not exist",
        ds_filename.str);

  if (access(ds_filename2.str, F_OK) != 0)
    die("command \"diff_files\" failed, file '%s' does not exist",
        ds_filename2.str);

3799 3800
  if ((error= compare_files(ds_filename.str, ds_filename2.str)) &&
      match_expected_error(command, error, NULL) < 0)
3801
  {
3802
    /* Compare of the two files failed, append them to output
3803 3804
       so the failure can be analyzed, but only if it was not
       expected to fail.
3805 3806
    */
    show_diff(&ds_res, ds_filename.str, ds_filename2.str);
3807 3808 3809
    log_file.write(&ds_res);
    log_file.flush();
    dynstr_set(&ds_res, 0);
3810 3811 3812 3813 3814 3815 3816 3817
  }

  dynstr_free(&ds_filename);
  dynstr_free(&ds_filename2);
  handle_command_error(command, error);
  DBUG_VOID_RETURN;
}

3818

3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831
struct st_connection * find_connection_by_name(const char *name)
{
  struct st_connection *con;
  for (con= connections; con < next_con; con++)
  {
    if (!strcmp(con->name, name))
    {
      return con;
    }
  }
  return 0; /* Connection not found */
}

3832

3833 3834 3835 3836 3837 3838 3839 3840 3841
/*
  SYNOPSIS
  do_send_quit
  command	called command

  DESCRIPTION
  Sends a simple quit command to the server for the named connection.

*/
3842 3843 3844 3845 3846 3847 3848 3849 3850 3851

void do_send_quit(struct st_command *command)
{
  char *p= command->first_argument, *name;
  struct st_connection *con;

  DBUG_ENTER("do_send_quit");
  DBUG_PRINT("enter",("name: '%s'",p));

  if (!*p)
3852
    die("Missing connection name in send_quit");
3853 3854 3855 3856 3857 3858 3859 3860
  name= p;
  while (*p && !my_isspace(charset_info,*p))
    p++;

  if (*p)
    *p++= 0;
  command->last_argument= p;

3861 3862 3863
  if (!(con= find_connection_by_name(name)))
    die("connection '%s' not found in connection pool", name);

3864
  simple_command(&con->mysql,COM_QUIT,0,0,1);
3865 3866

  DBUG_VOID_RETURN;
3867 3868 3869
}


3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902
/*
  SYNOPSIS
  do_change_user
  command       called command

  DESCRIPTION
  change_user [<user>], [<passwd>], [<db>]
  <user> - user to change to
  <passwd> - user password
  <db> - default database

  Changes the user and causes the database specified by db to become
  the default (current) database for the the current connection.

*/

void do_change_user(struct st_command *command)
{
  MYSQL *mysql = &cur_con->mysql;
  static DYNAMIC_STRING ds_user, ds_passwd, ds_db;
  const struct command_arg change_user_args[] = {
    { "user", ARG_STRING, FALSE, &ds_user, "User to connect as" },
    { "password", ARG_STRING, FALSE, &ds_passwd, "Password used when connecting" },
    { "database", ARG_STRING, FALSE, &ds_db, "Database to select after connect" },
  };

  DBUG_ENTER("do_change_user");

  check_command_args(command, command->first_argument,
                     change_user_args,
                     sizeof(change_user_args)/sizeof(struct command_arg),
                     ',');

3903 3904 3905 3906 3907 3908
  if (cur_con->stmt)
  {
    mysql_stmt_close(cur_con->stmt);
    cur_con->stmt= NULL;
  }

3909
  if (!ds_user.length)
3910
  {
3911 3912
    dynstr_set(&ds_user, mysql->user);

3913 3914
    if (!ds_passwd.length)
      dynstr_set(&ds_passwd, mysql->passwd);
3915

3916 3917 3918
    if (!ds_db.length)
      dynstr_set(&ds_db, mysql->db);
  }
3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933

  DBUG_PRINT("info",("connection: '%s' user: '%s' password: '%s' database: '%s'",
                      cur_con->name, ds_user.str, ds_passwd.str, ds_db.str));

  if (mysql_change_user(mysql, ds_user.str, ds_passwd.str, ds_db.str))
    die("change user failed: %s", mysql_error(mysql));

  dynstr_free(&ds_user);
  dynstr_free(&ds_passwd);
  dynstr_free(&ds_db);

  DBUG_VOID_RETURN;
}


3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944
/*
  SYNOPSIS
  do_perl
  command	command handle

  DESCRIPTION
  perl [<delimiter>];
  <perlscript line 1>
  <...>
  <perlscript line n>
  EOF
3945

3946 3947 3948 3949 3950 3951 3952 3953
  Execute everything after "perl" until <delimiter> as perl.
  Useful for doing more advanced things
  but still being able to execute it on all platforms.

  Default <delimiter> is EOF
*/

void do_perl(struct st_command *command)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3954
{
3955
  int error;
3956
  File fd;
3957
  FILE *res_file;
3958 3959
  char buf[FN_REFLEN];
  char temp_file_path[FN_REFLEN];
3960 3961
  static DYNAMIC_STRING ds_script;
  static DYNAMIC_STRING ds_delimiter;
3962
  const struct command_arg perl_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3963
    { "delimiter", ARG_STRING, FALSE, &ds_delimiter, "Delimiter to read until" }
3964 3965
  };
  DBUG_ENTER("do_perl");
3966

3967 3968 3969 3970 3971
  check_command_args(command,
                     command->first_argument,
                     perl_args,
                     sizeof(perl_args)/sizeof(struct command_arg),
                     ' ');
3972

3973 3974 3975 3976 3977 3978 3979
  ds_script= command->content;
  /* If it hasn't been done already by a loop iteration, fill it in */
  if (! ds_script.str)
  {
    /* If no delimiter was provided, use EOF */
    if (ds_delimiter.length == 0)
      dynstr_set(&ds_delimiter, "EOF");
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3980

3981 3982 3983 3984
    init_dynamic_string(&ds_script, "", 1024, 1024);
    read_until_delimiter(&ds_script, &ds_delimiter);
    command->content= ds_script;
  }
3985

3986 3987 3988 3989
  /* This function could be called even if "false", so check before doing */
  if (cur_block->ok)
  {
    DBUG_PRINT("info", ("Executing perl: %s", ds_script.str));
3990

3991 3992 3993 3994 3995 3996
    /* Create temporary file name */
    if ((fd= create_temp_file(temp_file_path, getenv("MYSQLTEST_VARDIR"),
                              "tmp", O_CREAT | O_SHARE | O_RDWR,
                              MYF(MY_WME))) < 0)
      die("Failed to create temporary file for perl command");
    my_close(fd, MYF(0));
3997

3998
    str_to_file(temp_file_path, ds_script.str, ds_script.length);
3999

4000 4001
    /* Format the "perl <filename>" command */
    my_snprintf(buf, sizeof(buf), "perl %s", temp_file_path);
4002

4003 4004
    if (!(res_file= popen(buf, "r")) && command->abort_on_error)
     die("popen(\"%s\", \"r\") failed", buf);
4005

4006
    while (fgets(buf, sizeof(buf), res_file))
4007
    {
4008 4009 4010 4011 4012 4013 4014 4015 4016
      if (disable_result_log)
      {
	buf[strlen(buf)-1]=0;
	DBUG_PRINT("exec_result",("%s", buf));
      }
      else
      {
	replace_dynstr_append(&ds_res, buf);
      }
4017
    }
4018
    error= pclose(res_file);
4019

4020 4021 4022
    /* Remove the temporary file, but keep it if perl failed */
    if (!error)
      my_delete(temp_file_path, MYF(0));
4023

4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035
    /* Check for error code that indicates perl could not be started */
    int exstat= WEXITSTATUS(error);
#ifdef __WIN__
    if (exstat == 1)
      /* Text must begin 'perl not found' as mtr looks for it */
      abort_not_supported_test("perl not found in path or did not start");
#else
    if (exstat == 127)
      abort_not_supported_test("perl not found in path");
#endif
    else
      handle_command_error(command, exstat);
4036
  }
4037 4038
  dynstr_free(&ds_delimiter);
  DBUG_VOID_RETURN;
4039 4040 4041 4042
}


/*
4043 4044 4045
  Print the content between echo and <delimiter> to result file.
  Evaluate all variables in the string before printing, allow
  for variable names to be escaped using \
4046

4047 4048 4049
  SYNOPSIS
  do_echo()
  command  called command
4050

4051 4052 4053
  DESCRIPTION
  echo text
  Print the text after echo until end of command to result file
4054

4055 4056
  echo $<var_name>
  Print the content of the variable <var_name> to result file
4057

4058 4059 4060 4061 4062 4063 4064 4065 4066
  echo Some text $<var_name>
  Print "Some text" plus the content of the variable <var_name> to
  result file

  echo Some text \$<var_name>
  Print "Some text" plus $<var_name> to result file
*/

int do_echo(struct st_command *command)
4067
{
4068
  DYNAMIC_STRING ds_echo;
4069
  DBUG_ENTER("do_echo");
4070 4071 4072 4073 4074 4075 4076

  init_dynamic_string(&ds_echo, "", command->query_len, 256);
  do_eval(&ds_echo, command->first_argument, command->end, FALSE);
  dynstr_append_mem(&ds_res, ds_echo.str, ds_echo.length);
  dynstr_append_mem(&ds_res, "\n", 1);
  dynstr_free(&ds_echo);
  command->last_argument= command->end;
4077
  DBUG_RETURN(0);
4078 4079
}

4080

4081
void do_wait_for_slave_to_stop(struct st_command *c __attribute__((unused)))
4082
{
4083 4084 4085
  static int SLAVE_POLL_INTERVAL= 300000;
  MYSQL* mysql = &cur_con->mysql;
  for (;;)
4086
  {
4087
    MYSQL_RES *UNINIT_VAR(res);
4088 4089 4090 4091 4092 4093 4094 4095
    MYSQL_ROW row;
    int done;

    if (mysql_query(mysql,"show status like 'Slave_running'") ||
	!(res=mysql_store_result(mysql)))
      die("Query failed while probing slave for stop: %s",
	  mysql_error(mysql));
    if (!(row=mysql_fetch_row(res)) || !row[1])
4096
    {
4097 4098
      mysql_free_result(res);
      die("Strange result from query while probing slave for stop");
4099
    }
4100 4101 4102 4103 4104
    done = !strcmp(row[1],"OFF");
    mysql_free_result(res);
    if (done)
      break;
    my_sleep(SLAVE_POLL_INTERVAL);
4105
  }
4106
  return;
4107 4108
}

4109

4110
void do_sync_with_master2(struct st_command *command, long offset)
4111
{
4112 4113 4114 4115
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL *mysql= &cur_con->mysql;
  char query_buf[FN_REFLEN+128];
4116
  int timeout= 300; /* seconds */
4117

4118 4119
  if (!master_pos.file[0])
    die("Calling 'sync_with_master' without calling 'save_master_pos'");
4120

4121 4122
  sprintf(query_buf, "select master_pos_wait('%s', %ld, %d)",
          master_pos.file, master_pos.pos + offset, timeout);
4123

4124 4125 4126
  if (mysql_query(mysql, query_buf))
    die("failed in '%s': %d: %s", query_buf, mysql_errno(mysql),
        mysql_error(mysql));
4127

4128 4129 4130
  if (!(res= mysql_store_result(mysql)))
    die("mysql_store_result() returned NULL for '%s'", query_buf);
  if (!(row= mysql_fetch_row(res)))
4131 4132
  {
    mysql_free_result(res);
4133
    die("empty result in %s", query_buf);
4134
  }
4135 4136 4137 4138 4139 4140 4141 4142 4143

  int result= -99;
  const char* result_str= row[0];
  if (result_str)
    result= atoi(result_str);

  mysql_free_result(res);

  if (!result_str || result < 0)
4144
  {
4145 4146 4147 4148 4149 4150 4151
    /* master_pos_wait returned NULL or < 0 */
    show_query(mysql, "SHOW MASTER STATUS");
    show_query(mysql, "SHOW SLAVE STATUS");
    show_query(mysql, "SHOW PROCESSLIST");
    fprintf(stderr, "analyze: sync_with_master\n");

    if (!result_str)
4152
    {
4153 4154 4155 4156 4157 4158 4159 4160 4161 4162
      /*
        master_pos_wait returned NULL. This indicates that
        slave SQL thread is not started, the slave's master
        information is not initialized, the arguments are
        incorrect, or an error has occured
      */
      die("%.*s failed: '%s' returned NULL "\
          "indicating slave SQL thread failure",
          command->first_word_len, command->query, query_buf);

4163
    }
4164 4165 4166 4167 4168 4169 4170 4171

    if (result == -1)
      die("%.*s failed: '%s' returned -1 "\
          "indicating timeout after %d seconds",
          command->first_word_len, command->query, query_buf, timeout);
    else
      die("%.*s failed: '%s' returned unknown result :%d",
          command->first_word_len, command->query, query_buf, result);
4172
  }
4173

4174 4175
  return;
}
4176

4177
void do_sync_with_master(struct st_command *command)
4178
{
4179 4180 4181 4182
  long offset= 0;
  char *p= command->first_argument;
  const char *offset_start= p;
  if (*offset_start)
4183
  {
4184 4185
    for (; my_isdigit(charset_info, *p); p++)
      offset = offset * 10 + *p - '0';
4186

4187 4188 4189 4190
    if(*p && !my_isspace(charset_info, *p))
      die("Invalid integer argument \"%s\"", offset_start);
    command->last_argument= p;
  }
4191
  do_sync_with_master2(command, offset);
4192
  return;
4193 4194
}

4195 4196 4197 4198 4199 4200

/*
  when ndb binlog is on, this call will wait until last updated epoch
  (locally in the mysqld) has been received into the binlog
*/
int do_save_master_pos()
4201
{
4202 4203 4204 4205
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL *mysql = &cur_con->mysql;
  const char *query;
4206
  DBUG_ENTER("do_save_master_pos");
4207

4208 4209 4210 4211 4212
#ifdef HAVE_NDB_BINLOG
  /*
    Wait for ndb binlog to be up-to-date with all changes
    done on the local mysql server
  */
4213
  {
4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226
    ulong have_ndbcluster;
    if (mysql_query(mysql, query= "show variables like 'have_ndbcluster'"))
      die("'%s' failed: %d %s", query,
          mysql_errno(mysql), mysql_error(mysql));
    if (!(res= mysql_store_result(mysql)))
      die("mysql_store_result() returned NULL for '%s'", query);
    if (!(row= mysql_fetch_row(res)))
      die("Query '%s' returned empty result", query);

    have_ndbcluster= strcmp("YES", row[1]) == 0;
    mysql_free_result(res);

    if (have_ndbcluster)
4227
    {
4228
      ulonglong start_epoch= 0, handled_epoch= 0,
4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247
	latest_epoch=0, latest_trans_epoch=0,
	latest_handled_binlog_epoch= 0, latest_received_binlog_epoch= 0,
	latest_applied_binlog_epoch= 0;
      int count= 0;
      int do_continue= 1;
      while (do_continue)
      {
        const char binlog[]= "binlog";
	const char latest_epoch_str[]=
          "latest_epoch=";
        const char latest_trans_epoch_str[]=
          "latest_trans_epoch=";
	const char latest_received_binlog_epoch_str[]=
	  "latest_received_binlog_epoch";
        const char latest_handled_binlog_epoch_str[]=
          "latest_handled_binlog_epoch=";
        const char latest_applied_binlog_epoch_str[]=
          "latest_applied_binlog_epoch=";
        if (count)
4248
          my_sleep(100*1000); /* 100ms */
4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330
        if (mysql_query(mysql, query= "show engine ndb status"))
          die("failed in '%s': %d %s", query,
              mysql_errno(mysql), mysql_error(mysql));
        if (!(res= mysql_store_result(mysql)))
          die("mysql_store_result() returned NULL for '%s'", query);
        while ((row= mysql_fetch_row(res)))
        {
          if (strcmp(row[1], binlog) == 0)
          {
            const char *status= row[2];

	    /* latest_epoch */
	    while (*status && strncmp(status, latest_epoch_str,
				      sizeof(latest_epoch_str)-1))
	      status++;
	    if (*status)
            {
	      status+= sizeof(latest_epoch_str)-1;
	      latest_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_epoch_str, query);
	    /* latest_trans_epoch */
	    while (*status && strncmp(status, latest_trans_epoch_str,
				      sizeof(latest_trans_epoch_str)-1))
	      status++;
	    if (*status)
	    {
	      status+= sizeof(latest_trans_epoch_str)-1;
	      latest_trans_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_trans_epoch_str, query);
	    /* latest_received_binlog_epoch */
	    while (*status &&
		   strncmp(status, latest_received_binlog_epoch_str,
			   sizeof(latest_received_binlog_epoch_str)-1))
	      status++;
	    if (*status)
	    {
	      status+= sizeof(latest_received_binlog_epoch_str)-1;
	      latest_received_binlog_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_received_binlog_epoch_str, query);
	    /* latest_handled_binlog */
	    while (*status &&
		   strncmp(status, latest_handled_binlog_epoch_str,
			   sizeof(latest_handled_binlog_epoch_str)-1))
	      status++;
	    if (*status)
	    {
	      status+= sizeof(latest_handled_binlog_epoch_str)-1;
	      latest_handled_binlog_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_handled_binlog_epoch_str, query);
	    /* latest_applied_binlog_epoch */
	    while (*status &&
		   strncmp(status, latest_applied_binlog_epoch_str,
			   sizeof(latest_applied_binlog_epoch_str)-1))
	      status++;
	    if (*status)
	    {
	      status+= sizeof(latest_applied_binlog_epoch_str)-1;
	      latest_applied_binlog_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_applied_binlog_epoch_str, query);
	    if (count == 0)
	      start_epoch= latest_trans_epoch;
	    break;
	  }
	}
	if (!row)
	  die("result does not contain '%s' in '%s'",
	      binlog, query);
4331
	if (latest_handled_binlog_epoch > handled_epoch)
4332
	  count= 0;
4333
	handled_epoch= latest_handled_binlog_epoch;
4334 4335 4336
	count++;
	if (latest_handled_binlog_epoch >= start_epoch)
          do_continue= 0;
4337
        else if (count > 300) /* 30s */
4338 4339 4340 4341 4342
	{
	  break;
        }
        mysql_free_result(res);
      }
4343 4344
    }
  }
4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356
#endif
  if (mysql_query(mysql, query= "show master status"))
    die("failed in 'show master status': %d %s",
	mysql_errno(mysql), mysql_error(mysql));

  if (!(res = mysql_store_result(mysql)))
    die("mysql_store_result() retuned NULL for '%s'", query);
  if (!(row = mysql_fetch_row(res)))
    die("empty result in show master status");
  strnmov(master_pos.file, row[0], sizeof(master_pos.file)-1);
  master_pos.pos = strtoul(row[1], (char**) 0, 10);
  mysql_free_result(res);
4357
  DBUG_RETURN(0);
4358 4359
}

4360

4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380
/*
  Assign the variable <var_name> with <var_val>

  SYNOPSIS
  do_let()
  query	called command

  DESCRIPTION
  let $<var_name>=<var_val><delimiter>

  <var_name>  - is the string string found between the $ and =
  <var_val>   - is the content between the = and <delimiter>, it may span
  multiple line and contain any characters except <delimiter>
  <delimiter> - is a string containing of one or more chars, default is ;

  RETURN VALUES
  Program will die if error detected
*/

void do_let(struct st_command *command)
4381
{
4382 4383 4384 4385
  char *p= command->first_argument;
  char *var_name, *var_name_end;
  DYNAMIC_STRING let_rhs_expr;
  DBUG_ENTER("do_let");
4386

4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402
  init_dynamic_string(&let_rhs_expr, "", 512, 2048);

  /* Find <var_name> */
  if (!*p)
    die("Missing arguments to let");
  var_name= p;
  while (*p && (*p != '=') && !my_isspace(charset_info,*p))
    p++;
  var_name_end= p;
  if (var_name == var_name_end ||
      (var_name+1 == var_name_end && *var_name == '$'))
    die("Missing variable name in let");
  while (my_isspace(charset_info,*p))
    p++;
  if (*p++ != '=')
    die("Missing assignment operator in let");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4403

4404 4405 4406
  /* Find start of <var_val> */
  while (*p && my_isspace(charset_info,*p))
    p++;
4407

4408
  do_eval(&let_rhs_expr, p, command->end, FALSE);
4409

4410 4411 4412 4413 4414 4415
  command->last_argument= command->end;
  /* Assign var_val to var_name */
  var_set(var_name, var_name_end, let_rhs_expr.str,
          (let_rhs_expr.str + let_rhs_expr.length));
  dynstr_free(&let_rhs_expr);
  DBUG_VOID_RETURN;
4416 4417
}

4418

4419 4420
/*
  Sleep the number of specified seconds
4421

4422 4423 4424 4425 4426
  SYNOPSIS
  do_sleep()
  q	       called command
  real_sleep   use the value from opt_sleep as number of seconds to sleep
               if real_sleep is false
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4427

4428 4429 4430
  DESCRIPTION
  sleep <seconds>
  real_sleep <seconds>
4431

4432 4433 4434 4435 4436 4437 4438 4439
  The difference between the sleep and real_sleep commands is that sleep
  uses the delay from the --sleep command-line option if there is one.
  (If the --sleep option is not given, the sleep command uses the delay
  specified by its argument.) The real_sleep command always uses the
  delay specified by its argument.  The logic is that sometimes delays are
  cpu-dependent, and --sleep can be used to set this delay.  real_sleep is
  used for cpu-independent delays.
*/
4440

4441 4442 4443
int do_sleep(struct st_command *command, my_bool real_sleep)
{
  int error= 0;
4444
  char *sleep_start, *sleep_end;
4445
  double sleep_val;
4446 4447 4448 4449 4450 4451 4452 4453
  char *p;
  static DYNAMIC_STRING ds_sleep;
  const struct command_arg sleep_args[] = {
    { "sleep_delay", ARG_STRING, TRUE, &ds_sleep, "Number of seconds to sleep." }
  };
  check_command_args(command, command->first_argument, sleep_args,
                     sizeof(sleep_args)/sizeof(struct command_arg),
                     ' ');
4454

4455 4456
  p= ds_sleep.str;
  sleep_end= ds_sleep.str + ds_sleep.length;
4457 4458 4459 4460 4461 4462 4463 4464
  while (my_isspace(charset_info, *p))
    p++;
  if (!*p)
    die("Missing argument to %.*s", command->first_word_len, command->query);
  sleep_start= p;
  /* Check that arg starts with a digit, not handled by my_strtod */
  if (!my_isdigit(charset_info, *sleep_start))
    die("Invalid argument to %.*s \"%s\"", command->first_word_len,
4465
        command->query, sleep_start);
4466
  sleep_val= my_strtod(sleep_start, &sleep_end, &error);
4467
  check_eol_junk_line(sleep_end);
4468 4469 4470
  if (error)
    die("Invalid argument to %.*s \"%s\"", command->first_word_len,
        command->query, command->first_argument);
4471
  dynstr_free(&ds_sleep);
4472

4473 4474 4475 4476 4477 4478 4479
  /* Fixed sleep time selected by --sleep option */
  if (opt_sleep >= 0 && !real_sleep)
    sleep_val= opt_sleep;

  DBUG_PRINT("info", ("sleep_val: %f", sleep_val));
  if (sleep_val)
    my_sleep((ulong) (sleep_val * 1000000L));
4480
  return 0;
4481 4482
}

4483

4484 4485
void do_get_file_name(struct st_command *command,
                      char* dest, uint dest_max_len)
4486
{
4487 4488 4489 4490 4491 4492 4493 4494 4495
  char *p= command->first_argument, *name;
  if (!*p)
    die("Missing file name argument");
  name= p;
  while (*p && !my_isspace(charset_info,*p))
    p++;
  if (*p)
    *p++= 0;
  command->last_argument= p;
4496
  strmake(dest, name, dest_max_len - 1);
4497 4498
}

4499 4500

void do_set_charset(struct st_command *command)
4501
{
4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516
  char *charset_name= command->first_argument;
  char *p;

  if (!charset_name || !*charset_name)
    die("Missing charset name in 'character_set'");
  /* Remove end space */
  p= charset_name;
  while (*p && !my_isspace(charset_info,*p))
    p++;
  if(*p)
    *p++= 0;
  command->last_argument= p;
  charset_info= get_charset_by_csname(charset_name,MY_CS_PRIMARY,MYF(MY_WME));
  if (!charset_info)
    abort_not_supported_test("Test requires charset '%s'", charset_name);
4517 4518 4519
}


4520 4521 4522 4523 4524 4525 4526 4527
/*
  Run query and return one field in the result set from the
  first row and <column>
*/

int query_get_string(MYSQL* mysql, const char* query,
                     int column, DYNAMIC_STRING* ds)
{
4528
  MYSQL_RES *res= NULL;
4529 4530
  MYSQL_ROW row;

4531
  if (mysql_query(mysql, query))
4532 4533
    die("'%s' failed: %d %s", query,
        mysql_errno(mysql), mysql_error(mysql));
4534 4535 4536 4537 4538
  if ((res= mysql_store_result(mysql)) == NULL)
    die("Failed to store result: %d %s",
        mysql_errno(mysql), mysql_error(mysql));

  if ((row= mysql_fetch_row(res)) == NULL)
4539 4540 4541 4542 4543
  {
    mysql_free_result(res);
    ds= 0;
    return 1;
  }
4544
  init_dynamic_string(ds, (row[column] ? row[column] : "NULL"), ~0, 32);
4545 4546 4547 4548 4549
  mysql_free_result(res);
  return 0;
}


4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570
static int my_kill(int pid, int sig)
{
#ifdef __WIN__
  HANDLE proc;
  if ((proc= OpenProcess(PROCESS_TERMINATE, FALSE, pid)) == NULL)
    return -1;
  if (sig == 0)
  {
    CloseHandle(proc);
    return 0;
  }
  (void)TerminateProcess(proc, 201);
  CloseHandle(proc);
  return 1;
#else
  return kill(pid, sig);
#endif
}



4571 4572 4573 4574 4575 4576 4577
/*
  Shutdown the server of current connection and
  make sure it goes away within <timeout> seconds

  NOTE! Currently only works with local server

  SYNOPSIS
4578
  do_shutdown_server()
4579 4580 4581
  command  called command

  DESCRIPTION
4582
  shutdown [<timeout>]
4583 4584 4585

*/

4586
void do_shutdown_server(struct st_command *command)
4587 4588
{
  int timeout=60, pid;
4589
  DYNAMIC_STRING ds_pidfile_name;
4590 4591
  MYSQL* mysql = &cur_con->mysql;
  static DYNAMIC_STRING ds_timeout;
4592 4593
  const struct command_arg shutdown_args[] = {
    {"timeout", ARG_STRING, FALSE, &ds_timeout, "Timeout before killing server"}
4594
  };
4595
  DBUG_ENTER("do_shutdown_server");
4596

4597 4598
  check_command_args(command, command->first_argument, shutdown_args,
                     sizeof(shutdown_args)/sizeof(struct command_arg),
4599 4600 4601 4602 4603 4604 4605 4606
                     ' ');

  if (ds_timeout.length)
  {
    timeout= atoi(ds_timeout.str);
    if (timeout == 0)
      die("Illegal argument for timeout: '%s'", ds_timeout.str);
  }
4607
  dynstr_free(&ds_timeout);
4608 4609 4610

  /* Get the servers pid_file name and use it to read pid */
  if (query_get_string(mysql, "SHOW VARIABLES LIKE 'pid_file'", 1,
4611
                       &ds_pidfile_name))
4612 4613 4614 4615 4616 4617 4618
    die("Failed to get pid_file from server");

  /* Read the pid from the file */
  {
    int fd;
    char buff[32];

4619 4620
    if ((fd= my_open(ds_pidfile_name.str, O_RDONLY, MYF(0))) < 0)
      die("Failed to open file '%s'", ds_pidfile_name.str);
4621 4622
    dynstr_free(&ds_pidfile_name);

4623 4624 4625 4626 4627 4628
    if (my_read(fd, (uchar*)&buff,
                sizeof(buff), MYF(0)) <= 0){
      my_close(fd, MYF(0));
      die("pid file was empty");
    }
    my_close(fd, MYF(0));
4629

4630 4631 4632
    pid= atoi(buff);
    if (pid == 0)
      die("Pidfile didn't contain a valid number");
4633 4634 4635
  }
  DBUG_PRINT("info", ("Got pid %d", pid));

4636
  /* Tell server to shutdown if timeout > 0*/
4637
  if (timeout && mysql_shutdown(mysql, SHUTDOWN_DEFAULT))
4638 4639 4640 4641
    die("mysql_shutdown failed");

  /* Check that server dies */
  while(timeout--){
4642
    if (my_kill(pid, 0) < 0){
4643
      DBUG_PRINT("info", ("Process %d does not exist anymore", pid));
4644
      DBUG_VOID_RETURN;
4645 4646
    }
    DBUG_PRINT("info", ("Sleeping, timeout: %d", timeout));
4647
    my_sleep(1000000L);
4648 4649 4650 4651
  }

  /* Kill the server */
  DBUG_PRINT("info", ("Killing server, pid: %d", pid));
4652
  (void)my_kill(pid, 9);
4653 4654 4655 4656 4657 4658

  DBUG_VOID_RETURN;

}


4659 4660 4661
#if MYSQL_VERSION_ID >= 50000
/* List of error names to error codes, available from 5.0 */
typedef struct
4662
{
4663
  const char *name;
4664
  uint        code;
4665
  const char *text;
4666
} st_error;
4667

4668 4669 4670
static st_error global_error_names[] =
{
#include <mysqld_ername.h>
4671
  { 0, 0, 0 }
4672
};
4673

4674 4675 4676 4677
uint get_errcode_from_name(char *error_name, char *error_end)
{
  /* SQL error as string */
  st_error *e= global_error_names;
4678 4679

  DBUG_ENTER("get_errcode_from_name");
4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692
  DBUG_PRINT("enter", ("error_name: %s", error_name));

  /* Loop through the array of known error names */
  for (; e->name; e++)
  {
    /*
      If we get a match, we need to check the length of the name we
      matched against in case it was longer than what we are checking
      (as in ER_WRONG_VALUE vs. ER_WRONG_VALUE_COUNT).
    */
    if (!strncmp(error_name, e->name, (int) (error_end - error_name)) &&
        (uint) strlen(e->name) == (uint) (error_end - error_name))
    {
4693
      DBUG_RETURN(e->code);
4694 4695 4696 4697
    }
  }
  if (!e->name)
    die("Unknown SQL error name '%s'", error_name);
4698 4699
  DBUG_RETURN(0);
}
4700
#else
4701 4702 4703
uint get_errcode_from_name(char *error_name __attribute__((unused)),
                           char *error_end __attribute__((unused)))
{
4704
  abort_not_in_this_version();
4705
  return 0; /* Never reached */
4706
}
4707 4708
#endif

4709 4710


4711 4712 4713 4714 4715
void do_get_errcodes(struct st_command *command)
{
  struct st_match_err *to= saved_expected_errors.err;
  char *p= command->first_argument;
  uint count= 0;
4716

4717
  DBUG_ENTER("do_get_errcodes");
4718

4719 4720
  if (!*p)
    die("Missing argument(s) to 'error'");
4721

4722 4723 4724
  do
  {
    char *end;
4725

4726 4727 4728
    /* Skip leading spaces */
    while (*p && *p == ' ')
      p++;
4729

4730 4731 4732 4733
    /* Find end */
    end= p;
    while (*end && *end != ',' && *end != ' ')
      end++;
4734

4735
    if (*p == 'S')
4736
    {
4737 4738
      char *to_ptr= to->code.sqlstate;

4739 4740 4741 4742 4743 4744
      /*
        SQLSTATE string
        - Must be SQLSTATE_LENGTH long
        - May contain only digits[0-9] and _uppercase_ letters
      */
      p++; /* Step past the S */
4745
      if ((end - p) != SQLSTATE_LENGTH)
4746
        die("The sqlstate must be exactly %d chars long", SQLSTATE_LENGTH);
4747

4748
      /* Check sqlstate string validity */
4749
      while (*p && p < end)
4750
      {
4751 4752 4753 4754 4755
        if (my_isdigit(charset_info, *p) || my_isupper(charset_info, *p))
          *to_ptr++= *p++;
        else
          die("The sqlstate may only consist of digits[0-9] " \
              "and _uppercase_ letters");
4756
      }
4757

4758 4759
      *to_ptr= 0;
      to->type= ERR_SQLSTATE;
4760
      DBUG_PRINT("info", ("ERR_SQLSTATE: %s", to->code.sqlstate));
4761 4762 4763 4764
    }
    else if (*p == 's')
    {
      die("The sqlstate definition must start with an uppercase S");
4765
    }
4766 4767 4768
    else if (*p == 'E')
    {
      /* Error name string */
4769

4770 4771 4772 4773 4774 4775
      DBUG_PRINT("info", ("Error name: %s", p));
      to->code.errnum= get_errcode_from_name(p, end);
      to->type= ERR_ERRNO;
      DBUG_PRINT("info", ("ERR_ERRNO: %d", to->code.errnum));
    }
    else if (*p == 'e')
kent@mysql.com's avatar
kent@mysql.com committed
4776
    {
4777 4778 4779 4780 4781 4782 4783 4784
      die("The error name definition must start with an uppercase E");
    }
    else
    {
      long val;
      char *start= p;
      /* Check that the string passed to str2int only contain digits */
      while (*p && p != end)
kent@mysql.com's avatar
kent@mysql.com committed
4785
      {
4786 4787 4788 4789 4790 4791
        if (!my_isdigit(charset_info, *p))
          die("Invalid argument to error: '%s' - "\
              "the errno may only consist of digits[0-9]",
              command->first_argument);
        p++;
      }
kent@mysql.com's avatar
kent@mysql.com committed
4792

4793 4794 4795
      /* Convert the sting to int */
      if (!str2int(start, 10, (long) INT_MIN, (long) INT_MAX, &val))
	die("Invalid argument to error: '%s'", command->first_argument);
kent@mysql.com's avatar
kent@mysql.com committed
4796

4797 4798 4799
      to->code.errnum= (uint) val;
      to->type= ERR_ERRNO;
      DBUG_PRINT("info", ("ERR_ERRNO: %d", to->code.errnum));
kent@mysql.com's avatar
kent@mysql.com committed
4800
    }
4801 4802
    to++;
    count++;
4803

4804 4805 4806
    if (count >= (sizeof(saved_expected_errors.err) /
                  sizeof(struct st_match_err)))
      die("Too many errorcodes specified");
4807

4808 4809
    /* Set pointer to the end of the last error code */
    p= end;
4810

4811 4812 4813
    /* Find next ',' */
    while (*p && *p != ',')
      p++;
4814

4815 4816
    if (*p)
      p++; /* Step past ',' */
4817

4818
  } while (*p);
4819

4820 4821
  command->last_argument= p;
  to->type= ERR_EMPTY;                        /* End of data */
monty@mysql.com's avatar
monty@mysql.com committed
4822

4823 4824 4825 4826
  DBUG_PRINT("info", ("Expected errors: %d", count));
  saved_expected_errors.count= count;
  DBUG_VOID_RETURN;
}
4827 4828


4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910
/*
  Get a string;  Return ptr to end of string
  Strings may be surrounded by " or '

  If string is a '$variable', return the value of the variable.
*/

char *get_string(char **to_ptr, char **from_ptr,
                 struct st_command *command)
{
  char c, sep;
  char *to= *to_ptr, *from= *from_ptr, *start=to;
  DBUG_ENTER("get_string");

  /* Find separator */
  if (*from == '"' || *from == '\'')
    sep= *from++;
  else
    sep=' ';				/* Separated with space */

  for ( ; (c=*from) ; from++)
  {
    if (c == '\\' && from[1])
    {					/* Escaped character */
      /* We can't translate \0 -> ASCII 0 as replace can't handle ASCII 0 */
      switch (*++from) {
      case 'n':
	*to++= '\n';
	break;
      case 't':
	*to++= '\t';
	break;
      case 'r':
	*to++ = '\r';
	break;
      case 'b':
	*to++ = '\b';
	break;
      case 'Z':				/* ^Z must be escaped on Win32 */
	*to++='\032';
	break;
      default:
	*to++ = *from;
	break;
      }
    }
    else if (c == sep)
    {
      if (c == ' ' || c != *++from)
	break;				/* Found end of string */
      *to++=c;				/* Copy duplicated separator */
    }
    else
      *to++=c;
  }
  if (*from != ' ' && *from)
    die("Wrong string argument in %s", command->query);

  while (my_isspace(charset_info,*from))	/* Point to next string */
    from++;

  *to =0;				/* End of string marker */
  *to_ptr= to+1;			/* Store pointer to end */
  *from_ptr= from;

  /* Check if this was a variable */
  if (*start == '$')
  {
    const char *end= to;
    VAR *var=var_get(start, &end, 0, 1);
    if (var && to == (char*) end+1)
    {
      DBUG_PRINT("info",("var: '%s' -> '%s'", start, var->str_val));
      DBUG_RETURN(var->str_val);	/* return found variable value */
    }
  }
  DBUG_RETURN(start);
}


void set_reconnect(MYSQL* mysql, int val)
{
4911
  my_bool reconnect= val;
4912 4913
  DBUG_ENTER("set_reconnect");
  DBUG_PRINT("info", ("val: %d", val));
4914
#if MYSQL_VERSION_ID < 50000
4915
  mysql->reconnect= reconnect;
4916 4917 4918
#else
  mysql_options(mysql, MYSQL_OPT_RECONNECT, (char *)&reconnect);
#endif
4919
  DBUG_VOID_RETURN;
4920 4921 4922
}


4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938
/**
  Change the current connection to the given st_connection, and update
  $mysql_get_server_version and $CURRENT_CONNECTION accordingly.
*/
void set_current_connection(struct st_connection *con)
{
  cur_con= con;
  /* Update $mysql_get_server_version to that of current connection */
  var_set_int("$mysql_get_server_version",
              mysql_get_server_version(&con->mysql));
  /* Update $CURRENT_CONNECTION to the name of the current connection */
  var_set_string("$CURRENT_CONNECTION", con->name);
}


void select_connection_name(const char *name)
4939
{
4940
  DBUG_ENTER("select_connection_name");
4941
  DBUG_PRINT("enter",("name: '%s'", name));
4942
  st_connection *con= find_connection_by_name(name);
4943

4944
  if (!con)
4945
    die("connection '%s' not found in connection pool", name);
4946

4947
  set_current_connection(con);
4948

4949 4950 4951 4952 4953 4954 4955 4956 4957 4958
  /* Connection logging if enabled */
  if (!disable_connect_log && !disable_query_log)
  {
    DYNAMIC_STRING *ds= &ds_res;

    dynstr_append_mem(ds, "connection ", 11);
    replace_dynstr_append(ds, name);
    dynstr_append_mem(ds, ";\n", 2);
  }

4959
  DBUG_VOID_RETURN;
4960 4961 4962
}


4963
void select_connection(struct st_command *command)
4964 4965
{
  DBUG_ENTER("select_connection");
4966 4967 4968 4969 4970 4971
  static DYNAMIC_STRING ds_connection;
  const struct command_arg connection_args[] = {
    { "connection_name", ARG_STRING, TRUE, &ds_connection, "Name of the connection that we switch to." }
  };
  check_command_args(command, command->first_argument, connection_args,
                     sizeof(connection_args)/sizeof(struct command_arg),
4972
                     ' ');
4973

4974 4975 4976 4977
  DBUG_PRINT("info", ("changing connection: %s", ds_connection.str));
  select_connection_name(ds_connection.str);
  dynstr_free(&ds_connection);
  DBUG_VOID_RETURN;
4978 4979 4980 4981 4982 4983 4984
}


void do_close_connection(struct st_command *command)
{
  DBUG_ENTER("close_connection");

4985 4986 4987 4988 4989 4990 4991 4992 4993 4994
  struct st_connection *con;
  static DYNAMIC_STRING ds_connection;
  const struct command_arg close_connection_args[] = {
    { "connection_name", ARG_STRING, TRUE, &ds_connection,
      "Name of the connection to close." }
  };
  check_command_args(command, command->first_argument,
                     close_connection_args,
                     sizeof(close_connection_args)/sizeof(struct command_arg),
                     ' ');
4995

4996
  DBUG_PRINT("enter",("connection name: '%s'", ds_connection.str));
4997

4998 4999
  if (!(con= find_connection_by_name(ds_connection.str)))
    die("connection '%s' not found in connection pool", ds_connection.str);
5000 5001 5002 5003

  DBUG_PRINT("info", ("Closing connection %s", con->name));
#ifndef EMBEDDED_LIBRARY
  if (command->type == Q_DIRTY_CLOSE)
5004
  {
5005
    if (con->mysql.net.vio)
5006
    {
5007 5008 5009 5010
      vio_delete(con->mysql.net.vio);
      con->mysql.net.vio = 0;
    }
  }
5011 5012 5013 5014 5015 5016
#else
  /*
    As query could be still executed in a separate theread
    we need to check if the query's thread was finished and probably wait
    (embedded-server specific)
  */
5017
  emb_close_connection(con);
5018
#endif /*EMBEDDED_LIBRARY*/
5019 5020 5021
  if (con->stmt)
    mysql_stmt_close(con->stmt);
  con->stmt= 0;
5022

5023
  mysql_close(&con->mysql);
5024

5025 5026 5027
  if (con->util_mysql)
    mysql_close(con->util_mysql);
  con->util_mysql= 0;
5028 5029
  con->pending= FALSE;
  
5030
  my_free(con->name);
5031 5032 5033 5034 5035 5036 5037 5038

  /*
    When the connection is closed set name to "-closed_connection-"
    to make it possible to reuse the connection name.
  */
  if (!(con->name = my_strdup("-closed_connection-", MYF(MY_WME))))
    die("Out of memory");

5039 5040 5041 5042 5043 5044 5045
  if (con == cur_con)
  {
    /* Current connection was closed */
    var_set_int("$mysql_get_server_version", 0xFFFFFFFF);
    var_set_string("$CURRENT_CONNECTION", con->name);
  }

5046 5047 5048 5049 5050 5051 5052 5053 5054 5055
  /* Connection logging if enabled */
  if (!disable_connect_log && !disable_query_log)
  {
    DYNAMIC_STRING *ds= &ds_res;

    dynstr_append_mem(ds, "disconnect ", 11);
    replace_dynstr_append(ds, ds_connection.str);
    dynstr_append_mem(ds, ";\n", 2);
  }

5056
  DBUG_VOID_RETURN;
5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091
}


/*
  Connect to a server doing several retries if needed.

  SYNOPSIS
  safe_connect()
  con               - connection structure to be used
  host, user, pass, - connection parameters
  db, port, sock

  NOTE

  Sometimes in a test the client starts before
  the server - to solve the problem, we try again
  after some sleep if connection fails the first
  time

  This function will try to connect to the given server
  "opt_max_connect_retries" times and sleep "connection_retry_sleep"
  seconds between attempts before finally giving up.
  This helps in situation when the client starts
  before the server (which happens sometimes).
  It will only ignore connection errors during these retries.

*/

void safe_connect(MYSQL* mysql, const char *name, const char *host,
                  const char *user, const char *pass, const char *db,
                  int port, const char *sock)
{
  int failed_attempts= 0;

  DBUG_ENTER("safe_connect");
5092 5093 5094 5095

  verbose_msg("Connecting to server %s:%d (socket %s) as '%s'"
              ", connection '%s', attempt %d ...", 
              host, port, sock, user, name, failed_attempts);
5096 5097 5098 5099 5100 5101 5102
  while(!mysql_real_connect(mysql, host,user, pass, db, port, sock,
                            CLIENT_MULTI_STATEMENTS | CLIENT_REMEMBER_OPTIONS))
  {
    /*
      Connect failed

      Only allow retry if this was an error indicating the server
5103 5104
      could not be contacted. Error code differs depending
      on protocol/connection type
5105 5106
    */

5107 5108
    if ((mysql_errno(mysql) == CR_CONN_HOST_ERROR ||
         mysql_errno(mysql) == CR_CONNECTION_ERROR) &&
5109
        failed_attempts < opt_max_connect_retries)
5110 5111 5112 5113
    {
      verbose_msg("Connect attempt %d/%d failed: %d: %s", failed_attempts,
                  opt_max_connect_retries, mysql_errno(mysql),
                  mysql_error(mysql));
5114
      my_sleep(connection_retry_sleep);
5115
    }
5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126
    else
    {
      if (failed_attempts > 0)
        die("Could not open connection '%s' after %d attempts: %d %s", name,
            failed_attempts, mysql_errno(mysql), mysql_error(mysql));
      else
        die("Could not open connection '%s': %d %s", name,
            mysql_errno(mysql), mysql_error(mysql));
    }
    failed_attempts++;
  }
5127
  verbose_msg("... Connected.");
5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160
  DBUG_VOID_RETURN;
}


/*
  Connect to a server and handle connection errors in case they occur.

  SYNOPSIS
  connect_n_handle_errors()
  q                 - context of connect "query" (command)
  con               - connection structure to be used
  host, user, pass, - connection parameters
  db, port, sock

  DESCRIPTION
  This function will try to establish a connection to server and handle
  possible errors in the same manner as if "connect" was usual SQL-statement
  (If error is expected it will ignore it once it occurs and log the
  "statement" to the query log).
  Unlike safe_connect() it won't do several attempts.

  RETURN VALUES
  1 - Connected
  0 - Not connected

*/

int connect_n_handle_errors(struct st_command *command,
                            MYSQL* con, const char* host,
                            const char* user, const char* pass,
                            const char* db, int port, const char* sock)
{
  DYNAMIC_STRING *ds;
5161
  int failed_attempts= 0;
5162 5163 5164 5165

  ds= &ds_res;

  /* Only log if an error is expected */
5166
  if (command->expected_errors.count > 0 &&
5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189
      !disable_query_log)
  {
    /*
      Log the connect to result log
    */
    dynstr_append_mem(ds, "connect(", 8);
    replace_dynstr_append(ds, host);
    dynstr_append_mem(ds, ",", 1);
    replace_dynstr_append(ds, user);
    dynstr_append_mem(ds, ",", 1);
    replace_dynstr_append(ds, pass);
    dynstr_append_mem(ds, ",", 1);
    if (db)
      replace_dynstr_append(ds, db);
    dynstr_append_mem(ds, ",", 1);
    replace_dynstr_append_uint(ds, port);
    dynstr_append_mem(ds, ",", 1);
    if (sock)
      replace_dynstr_append(ds, sock);
    dynstr_append_mem(ds, ")", 1);
    dynstr_append_mem(ds, delimiter, delimiter_length);
    dynstr_append_mem(ds, "\n", 1);
  }
5190 5191 5192 5193 5194 5195 5196
  /* Simlified logging if enabled */
  if (!disable_connect_log && !disable_query_log)
  {
    replace_dynstr_append(ds, command->query);
    dynstr_append_mem(ds, ";\n", 2);
  }
  
5197
  while (!mysql_real_connect(con, host, user, pass, db, port, sock ? sock: 0,
5198 5199
                          CLIENT_MULTI_STATEMENTS))
  {
5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231
    /*
      If we have used up all our connections check whether this
      is expected (by --error). If so, handle the error right away.
      Otherwise, give it some extra time to rule out race-conditions.
      If extra-time doesn't help, we have an unexpected error and
      must abort -- just proceeding to handle_error() when second
      and third chances are used up will handle that for us.

      There are various user-limits of which only max_user_connections
      and max_connections_per_hour apply at connect time. For the
      the second to create a race in our logic, we'd need a limits
      test that runs without a FLUSH for longer than an hour, so we'll
      stay clear of trying to work out which exact user-limit was
      exceeded.
    */

    if (((mysql_errno(con) == ER_TOO_MANY_USER_CONNECTIONS) ||
         (mysql_errno(con) == ER_USER_LIMIT_REACHED)) &&
        (failed_attempts++ < opt_max_connect_retries))
    {
      int i;

      i= match_expected_error(command, mysql_errno(con), mysql_sqlstate(con));

      if (i >= 0)
        goto do_handle_error;                 /* expected error, handle */

      my_sleep(connection_retry_sleep);       /* unexpected error, wait */
      continue;                               /* and give it 1 more chance */
    }

do_handle_error:
5232
    var_set_errno(mysql_errno(con));
5233 5234 5235 5236 5237
    handle_error(command, mysql_errno(con), mysql_error(con),
		 mysql_sqlstate(con), ds);
    return 0; /* Not connected */
  }

5238
  var_set_errno(0);
5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265
  handle_no_error(command);
  return 1; /* Connected */
}


/*
  Open a new connection to MySQL Server with the parameters
  specified. Make the new connection the current connection.

  SYNOPSIS
  do_connect()
  q	       called command

  DESCRIPTION
  connect(<name>,<host>,<user>,[<pass>,[<db>,[<port>,<sock>[<opts>]]]]);
  connect <name>,<host>,<user>,[<pass>,[<db>,[<port>,<sock>[<opts>]]]];

  <name> - name of the new connection
  <host> - hostname of server
  <user> - user to connect as
  <pass> - password used when connecting
  <db>   - initial db when connected
  <port> - server port
  <sock> - server socket
  <opts> - options to use for the connection
   * SSL - use SSL if available
   * COMPRESS - use compression if available
5266 5267
   * SHM - use shared memory if available
   * PIPE - use named pipe if available
5268 5269 5270 5271 5272

*/

void do_connect(struct st_command *command)
{
5273
  int con_port= opt_port;
5274
  char *con_options;
5275
  my_bool con_ssl= 0, con_compress= 0;
5276
  my_bool con_pipe= 0, con_shm= 0;
5277
  struct st_connection* con_slot;
5278

5279 5280 5281 5282 5283 5284 5285 5286
  static DYNAMIC_STRING ds_connection_name;
  static DYNAMIC_STRING ds_host;
  static DYNAMIC_STRING ds_user;
  static DYNAMIC_STRING ds_password;
  static DYNAMIC_STRING ds_database;
  static DYNAMIC_STRING ds_port;
  static DYNAMIC_STRING ds_sock;
  static DYNAMIC_STRING ds_options;
5287
  static DYNAMIC_STRING ds_default_auth;
5288 5289 5290
#ifdef HAVE_SMEM
  static DYNAMIC_STRING ds_shm;
#endif
5291
  const struct command_arg connect_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
5292 5293 5294 5295 5296 5297 5298
    { "connection name", ARG_STRING, TRUE, &ds_connection_name, "Name of the connection" },
    { "host", ARG_STRING, TRUE, &ds_host, "Host to connect to" },
    { "user", ARG_STRING, FALSE, &ds_user, "User to connect as" },
    { "passsword", ARG_STRING, FALSE, &ds_password, "Password used when connecting" },
    { "database", ARG_STRING, FALSE, &ds_database, "Database to select after connect" },
    { "port", ARG_STRING, FALSE, &ds_port, "Port to connect to" },
    { "socket", ARG_STRING, FALSE, &ds_sock, "Socket to connect with" },
5299 5300
    { "options", ARG_STRING, FALSE, &ds_options, "Options to use while connecting" },
    { "default_auth", ARG_STRING, FALSE, &ds_default_auth, "Default authentication to use" }
5301 5302 5303 5304 5305
  };

  DBUG_ENTER("do_connect");
  DBUG_PRINT("enter",("connect: %s", command->first_argument));

5306
  strip_parentheses(command);
5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318
  check_command_args(command, command->first_argument, connect_args,
                     sizeof(connect_args)/sizeof(struct command_arg),
                     ',');

  /* Port */
  if (ds_port.length)
  {
    con_port= atoi(ds_port.str);
    if (con_port == 0)
      die("Illegal argument for port: '%s'", ds_port.str);
  }

5319 5320 5321 5322 5323
#ifdef HAVE_SMEM
  /* Shared memory */
  init_dynamic_string(&ds_shm, ds_sock.str, 0, 0);
#endif

5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349
  /* Sock */
  if (ds_sock.length)
  {
    /*
      If the socket is specified just as a name without path
      append tmpdir in front
    */
    if (*ds_sock.str != FN_LIBCHAR)
    {
      char buff[FN_REFLEN];
      fn_format(buff, ds_sock.str, TMPDIR, "", 0);
      dynstr_set(&ds_sock, buff);
    }
  }
  else
  {
    /* No socket specified, use default */
    dynstr_set(&ds_sock, unix_sock);
  }
  DBUG_PRINT("info", ("socket: %s", ds_sock.str));


  /* Options */
  con_options= ds_options.str;
  while (*con_options)
  {
5350 5351 5352 5353 5354 5355
    char* end;
    /* Step past any spaces in beginning of option*/
    while (*con_options && my_isspace(charset_info, *con_options))
     con_options++;
    /* Find end of this option */
    end= con_options;
5356 5357 5358 5359 5360 5361
    while (*end && !my_isspace(charset_info, *end))
      end++;
    if (!strncmp(con_options, "SSL", 3))
      con_ssl= 1;
    else if (!strncmp(con_options, "COMPRESS", 8))
      con_compress= 1;
5362 5363 5364 5365
    else if (!strncmp(con_options, "PIPE", 4))
      con_pipe= 1;
    else if (!strncmp(con_options, "SHM", 3))
      con_shm= 1;
5366
    else
5367 5368
      die("Illegal option to connect: %.*s", 
          (int) (end - con_options), con_options);
5369 5370 5371 5372 5373 5374
    /* Process next option */
    con_options= end;
  }

  if (find_connection_by_name(ds_connection_name.str))
    die("Connection %s already exists", ds_connection_name.str);
5375 5376 5377 5378
    
  if (next_con != connections_end)
    con_slot= next_con;
  else
5379
  {
5380
    if (!(con_slot= find_connection_by_name("-closed_connection-")))
5381
      die("Connection limit exhausted, you can have max %d connections",
5382
          opt_max_connections);
5383
  }
5384

5385
#ifdef EMBEDDED_LIBRARY
5386 5387 5388
  init_connection_thd(con_slot);
#endif /*EMBEDDED_LIBRARY*/

5389
  if (!mysql_init(&con_slot->mysql))
5390
    die("Failed on mysql_init()");
5391 5392 5393 5394 5395

  if (opt_connect_timeout)
    mysql_options(&con_slot->mysql, MYSQL_OPT_CONNECT_TIMEOUT,
                  (void *) &opt_connect_timeout);

5396
  if (opt_compress || con_compress)
5397 5398 5399
    mysql_options(&con_slot->mysql, MYSQL_OPT_COMPRESS, NullS);
  mysql_options(&con_slot->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
  mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_NAME,
5400 5401
                charset_info->csname);
  if (opt_charsets_dir)
5402
    mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_DIR,
5403
                  opt_charsets_dir);
5404

Konstantin Osipov's avatar
Konstantin Osipov committed
5405
#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
5406 5407
  if (opt_use_ssl || con_ssl)
  {
5408
    mysql_ssl_set(&con_slot->mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
5409 5410 5411
		  opt_ssl_capath, opt_ssl_cipher);
#if MYSQL_VERSION_ID >= 50000
    /* Turn on ssl_verify_server_cert only if host is "localhost" */
5412
    opt_ssl_verify_server_cert= !strcmp(ds_host.str, "localhost");
5413
    mysql_options(&con_slot->mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
5414 5415 5416 5417 5418
                  &opt_ssl_verify_server_cert);
#endif
  }
#endif

5419 5420 5421
#ifdef __WIN__
  if (con_pipe)
  {
5422
    opt_protocol= MYSQL_PROTOCOL_PIPE;
5423 5424 5425
  }
#endif

5426 5427 5428
  if (opt_protocol)
    mysql_options(&con_slot->mysql, MYSQL_OPT_PROTOCOL, (char*) &opt_protocol);

5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445
#ifdef HAVE_SMEM
  if (con_shm)
  {
    uint protocol= MYSQL_PROTOCOL_MEMORY;
    if (!ds_shm.length)
      die("Missing shared memory base name");
    mysql_options(&con_slot->mysql, MYSQL_SHARED_MEMORY_BASE_NAME, ds_shm.str);
    mysql_options(&con_slot->mysql, MYSQL_OPT_PROTOCOL, &protocol);
  }
  else if(shared_memory_base_name)
  {
    mysql_options(&con_slot->mysql, MYSQL_SHARED_MEMORY_BASE_NAME,
      shared_memory_base_name);
  }
#endif


5446 5447
  /* Use default db name */
  if (ds_database.length == 0)
5448
    dynstr_set(&ds_database, opt_db);
5449

5450 5451 5452 5453 5454 5455
  if (opt_plugin_dir && *opt_plugin_dir)
    mysql_options(&con_slot->mysql, MYSQL_PLUGIN_DIR, opt_plugin_dir);

  if (ds_default_auth.length)
    mysql_options(&con_slot->mysql, MYSQL_DEFAULT_AUTH, ds_default_auth.str);

5456 5457 5458 5459
  /* Special database to allow one to connect without a database name */
  if (ds_database.length && !strcmp(ds_database.str,"*NO-ONE*"))
    dynstr_set(&ds_database, "");

5460
  if (connect_n_handle_errors(command, &con_slot->mysql,
5461 5462 5463 5464 5465 5466
                              ds_host.str,ds_user.str,
                              ds_password.str, ds_database.str,
                              con_port, ds_sock.str))
  {
    DBUG_PRINT("info", ("Inserting connection %s in connection pool",
                        ds_connection_name.str));
5467
    if (!(con_slot->name= my_strdup(ds_connection_name.str, MYF(MY_WME))))
5468
      die("Out of memory");
5469
    con_slot->name_len= strlen(con_slot->name);
5470 5471
    set_current_connection(con_slot);

5472 5473
    if (con_slot == next_con)
      next_con++; /* if we used the next_con slot, advance the pointer */
5474 5475 5476 5477 5478 5479 5480 5481 5482 5483
  }

  dynstr_free(&ds_connection_name);
  dynstr_free(&ds_host);
  dynstr_free(&ds_user);
  dynstr_free(&ds_password);
  dynstr_free(&ds_database);
  dynstr_free(&ds_port);
  dynstr_free(&ds_sock);
  dynstr_free(&ds_options);
5484 5485 5486
#ifdef HAVE_SMEM
  dynstr_free(&ds_shm);
#endif
5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509
  DBUG_VOID_RETURN;
}


int do_done(struct st_command *command)
{
  /* Check if empty block stack */
  if (cur_block == block_stack)
  {
    if (*command->query != '}')
      die("Stray 'end' command - end of block before beginning");
    die("Stray '}' - end of block before beginning");
  }

  /* Test if inner block has been executed */
  if (cur_block->ok && cur_block->cmd == cmd_while)
  {
    /* Pop block from stack, re-execute outer block */
    cur_block--;
    parser.current_line = cur_block->line;
  }
  else
  {
5510 5511 5512 5513 5514 5515
    if (*cur_block->delim) 
    {
      /* Restore "old" delimiter after false if block */
      strcpy (delimiter, cur_block->delim);
      delimiter_length= strlen(delimiter);
    }
5516 5517 5518 5519 5520 5521 5522
    /* Pop block from stack, goto next line */
    cur_block--;
    parser.current_line++;
  }
  return 0;
}

5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556
/* Operands available in if or while conditions */

enum block_op {
  EQ_OP,
  NE_OP,
  GT_OP,
  GE_OP,
  LT_OP,
  LE_OP,
  ILLEG_OP
};


enum block_op find_operand(const char *start)
{
 char first= *start;
 char next= *(start+1);
 
 if (first == '=' && next == '=')
   return EQ_OP;
 if (first == '!' && next == '=')
   return NE_OP;
 if (first == '>' && next == '=')
   return GE_OP;
 if (first == '>')
   return GT_OP;
 if (first == '<' && next == '=')
   return LE_OP;
 if (first == '<')
   return LT_OP;
 
 return ILLEG_OP;
}

5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581

/*
  Process start of a "if" or "while" statement

  SYNOPSIS
  do_block()
  cmd        Type of block
  q	       called command

  DESCRIPTION
  if ([!]<expr>)
  {
  <block statements>
  }

  while ([!]<expr>)
  {
  <block statements>
  }

  Evaluates the <expr> and if it evaluates to
  greater than zero executes the following code block.
  A '!' can be used before the <expr> to indicate it should
  be executed if it evaluates to zero.

5582 5583 5584 5585 5586 5587 5588
  <expr> can also be a simple comparison condition:

  <variable> <op> <expr>

  The left hand side must be a variable, the right hand side can be a
  variable, number, string or `query`. Operands are ==, !=, <, <=, >, >=.
  == and != can be used for strings, all can be used for numerical values.
5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614
*/

void do_block(enum block_cmd cmd, struct st_command* command)
{
  char *p= command->first_argument;
  const char *expr_start, *expr_end;
  VAR v;
  const char *cmd_name= (cmd == cmd_while ? "while" : "if");
  my_bool not_expr= FALSE;
  DBUG_ENTER("do_block");
  DBUG_PRINT("enter", ("%s", cmd_name));

  /* Check stack overflow */
  if (cur_block == block_stack_end)
    die("Nesting too deeply");

  /* Set way to find outer block again, increase line counter */
  cur_block->line= parser.current_line++;

  /* If this block is ignored */
  if (!cur_block->ok)
  {
    /* Inner block should be ignored too */
    cur_block++;
    cur_block->cmd= cmd;
    cur_block->ok= FALSE;
5615
    cur_block->delim[0]= '\0';
5616 5617 5618 5619 5620 5621 5622 5623
    DBUG_VOID_RETURN;
  }

  /* Parse and evaluate test expression */
  expr_start= strchr(p, '(');
  if (!expr_start++)
    die("missing '(' in %s", cmd_name);

5624 5625 5626
  while (my_isspace(charset_info, *expr_start))
    expr_start++;
  
5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645
  /* Check for !<expr> */
  if (*expr_start == '!')
  {
    not_expr= TRUE;
    expr_start++; /* Step past the '!' */
  }
  /* Find ending ')' */
  expr_end= strrchr(expr_start, ')');
  if (!expr_end)
    die("missing ')' in %s", cmd_name);
  p= (char*)expr_end+1;

  while (*p && my_isspace(charset_info, *p))
    p++;
  if (*p && *p != '{')
    die("Missing '{' after %s. Found \"%s\"", cmd_name, p);

  var_init(&v,0,0,0,0);

5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726
  /* If expression starts with a variable, it may be a compare condition */

  if (*expr_start == '$')
  {
    const char *curr_ptr= expr_end;
    eval_expr(&v, expr_start, &curr_ptr, true);
    while (my_isspace(charset_info, *++curr_ptr))
    {}
    /* If there was nothing past the variable, skip condition part */
    if (curr_ptr == expr_end)
      goto NO_COMPARE;

    enum block_op operand= find_operand(curr_ptr);
    if (operand == ILLEG_OP)
      die("Found junk '%.*s' after $variable in condition",
          (int)(expr_end - curr_ptr), curr_ptr);

    /* We could silently allow this, but may be confusing */
    if (not_expr)
      die("Negation and comparison should not be combined, please rewrite");
    
    /* Skip the 1 or 2 chars of the operand, then white space */
    if (operand == LT_OP || operand == GT_OP)
    {
      curr_ptr++;
    }
    else
    {
      curr_ptr+= 2;
    }
    while (my_isspace(charset_info, *curr_ptr))
      curr_ptr++;

    VAR v2;
    var_init(&v2,0,0,0,0);
    eval_expr(&v2, curr_ptr, &expr_end);

    if ((operand!=EQ_OP && operand!=NE_OP) && ! (v.is_int && v2.is_int))
      die ("Only == and != are supported for string values");

    /* Now we overwrite the first variable with 0 or 1 (for false or true) */

    switch (operand)
    {
    case EQ_OP:
      if (v.is_int)
        v.int_val= (v2.is_int && v2.int_val == v.int_val);
      else
        v.int_val= !strcmp (v.str_val, v2.str_val);
      break;
      
    case NE_OP:
      if (v.is_int)
        v.int_val= ! (v2.is_int && v2.int_val == v.int_val);
      else
        v.int_val= (strcmp (v.str_val, v2.str_val) != 0);
      break;

    case LT_OP:
      v.int_val= (v.int_val < v2.int_val);
      break;
    case LE_OP:
      v.int_val= (v.int_val <= v2.int_val);
      break;
    case GT_OP:
      v.int_val= (v.int_val > v2.int_val);
      break;
    case GE_OP:
      v.int_val= (v.int_val >= v2.int_val);
      break;
    }

    v.is_int= TRUE;
  } else
  {
    if (*expr_start != '`' && ! my_isdigit(charset_info, *expr_start))
      die("Expression in if/while must beging with $, ` or a number");
    eval_expr(&v, expr_start, &expr_end);
  }

 NO_COMPARE:
5727 5728 5729
  /* Define inner block */
  cur_block++;
  cur_block->cmd= cmd;
5730
  if (v.is_int)
5731
  {
5732
    cur_block->ok= (v.int_val != 0);
5733 5734 5735 5736 5737 5738 5739
  } else
  /* Any non-empty string which does not begin with 0 is also TRUE */
  {
    p= v.str_val;
    /* First skip any leading white space or unary -+ */
    while (*p && ((my_isspace(charset_info, *p) || *p == '-' || *p == '+')))
      p++;
5740

5741 5742 5743
    cur_block->ok= (*p && *p != '0') ? TRUE : FALSE;
  }
  
5744 5745 5746
  if (not_expr)
    cur_block->ok = !cur_block->ok;

5747 5748 5749 5750 5751 5752 5753 5754 5755
  if (cur_block->ok) 
  {
    cur_block->delim[0]= '\0';
  } else
  {
    /* Remember "old" delimiter if entering a false if block */
    strcpy (cur_block->delim, delimiter);
  }
  
5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839
  DBUG_PRINT("info", ("OK: %d", cur_block->ok));

  var_free(&v);
  DBUG_VOID_RETURN;
}


void do_delimiter(struct st_command* command)
{
  char* p= command->first_argument;
  DBUG_ENTER("do_delimiter");
  DBUG_PRINT("enter", ("first_argument: %s", command->first_argument));

  while (*p && my_isspace(charset_info, *p))
    p++;

  if (!(*p))
    die("Can't set empty delimiter");

  strmake(delimiter, p, sizeof(delimiter) - 1);
  delimiter_length= strlen(delimiter);

  DBUG_PRINT("exit", ("delimiter: %s", delimiter));
  command->last_argument= p + delimiter_length;
  DBUG_VOID_RETURN;
}


my_bool match_delimiter(int c, const char *delim, uint length)
{
  uint i;
  char tmp[MAX_DELIMITER_LENGTH];

  if (c != *delim)
    return 0;

  for (i= 1; i < length &&
	 (c= my_getc(cur_file->file)) == *(delim + i);
       i++)
    tmp[i]= c;

  if (i == length)
    return 1;					/* Found delimiter */

  /* didn't find delimiter, push back things that we read */
  my_ungetc(c);
  while (i > 1)
    my_ungetc(tmp[--i]);
  return 0;
}


my_bool end_of_query(int c)
{
  return match_delimiter(c, delimiter, delimiter_length);
}


/*
  Read one "line" from the file

  SYNOPSIS
  read_line
  buf     buffer for the read line
  size    size of the buffer i.e max size to read

  DESCRIPTION
  This function actually reads several lines and adds them to the
  buffer buf. It continues to read until it finds what it believes
  is a complete query.

  Normally that means it will read lines until it reaches the
  "delimiter" that marks end of query. Default delimiter is ';'
  The function should be smart enough not to detect delimiter's
  found inside strings surrounded with '"' and '\'' escaped strings.

  If the first line in a query starts with '#' or '-' this line is treated
  as a comment. A comment is always terminated when end of line '\n' is
  reached.

*/

int read_line(char *buf, int size)
{
5840
  char c, UNINIT_VAR(last_quote), last_char= 0;
5841 5842
  char *p= buf, *buf_end= buf + size - 1;
  int skip_char= 0;
5843 5844
  my_bool have_slash= FALSE;
  
5845 5846 5847 5848 5849
  enum {R_NORMAL, R_Q, R_SLASH_IN_Q,
        R_COMMENT, R_LINE_START} state= R_LINE_START;
  DBUG_ENTER("read_line");

  start_lineno= cur_file->lineno;
5850
  DBUG_PRINT("info", ("Starting to read at lineno: %d", start_lineno));
5851 5852 5853 5854 5855 5856 5857 5858 5859
  for (; p < buf_end ;)
  {
    skip_char= 0;
    c= my_getc(cur_file->file);
    if (feof(cur_file->file))
    {
  found_eof:
      if (cur_file->file != stdin)
      {
5860
	fclose(cur_file->file);
5861 5862
        cur_file->file= 0;
      }
5863
      my_free(cur_file->file_name);
5864 5865 5866 5867 5868 5869 5870 5871 5872 5873
      cur_file->file_name= 0;
      if (cur_file == file_stack)
      {
        /* We're back at the first file, check if
           all { have matching }
        */
        if (cur_block != block_stack)
          die("Missing end of block");

        *p= 0;
5874
        DBUG_PRINT("info", ("end of file at line %d", cur_file->lineno));
5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896
        DBUG_RETURN(1);
      }
      cur_file--;
      start_lineno= cur_file->lineno;
      continue;
    }

    if (c == '\n')
    {
      /* Line counting is independent of state */
      cur_file->lineno++;

      /* Convert cr/lf to lf */
      if (p != buf && *(p-1) == '\r')
        p--;
    }

    switch(state) {
    case R_NORMAL:
      if (end_of_query(c))
      {
	*p= 0;
5897 5898
        DBUG_PRINT("exit", ("Found delimiter '%s' at line %d",
                            delimiter, cur_file->lineno));
5899 5900 5901
	DBUG_RETURN(0);
      }
      else if ((c == '{' &&
5902 5903 5904 5905
                (!my_strnncoll_simple(charset_info, (const uchar*) "while", 5,
                                      (uchar*) buf, min(5, p - buf), 0) ||
                 !my_strnncoll_simple(charset_info, (const uchar*) "if", 2,
                                      (uchar*) buf, min(2, p - buf), 0))))
5906 5907 5908 5909
      {
        /* Only if and while commands can be terminated by { */
        *p++= c;
	*p= 0;
5910 5911
        DBUG_PRINT("exit", ("Found '{' indicating start of block at line %d",
                            cur_file->lineno));
5912 5913 5914 5915
	DBUG_RETURN(0);
      }
      else if (c == '\'' || c == '"' || c == '`')
      {
5916 5917 5918 5919 5920
        if (! have_slash) 
        {
	  last_quote= c;
	  state= R_Q;
	}
5921
      }
5922
      have_slash= (c == '\\');
5923 5924 5925 5926 5927 5928 5929
      break;

    case R_COMMENT:
      if (c == '\n')
      {
        /* Comments are terminated by newline */
	*p= 0;
5930 5931
        DBUG_PRINT("exit", ("Found newline in comment at line: %d",
                            cur_file->lineno));
5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944
	DBUG_RETURN(0);
      }
      break;

    case R_LINE_START:
      if (c == '#' || c == '-')
      {
        /* A # or - in the first position of the line - this is a comment */
	state = R_COMMENT;
      }
      else if (my_isspace(charset_info, c))
      {
	if (c == '\n')
5945
        {
5946 5947 5948 5949 5950 5951 5952 5953 5954
          if (last_char == '\n')
          {
            /* Two new lines in a row, return empty line */
            DBUG_PRINT("info", ("Found two new lines in a row"));
            *p++= c;
            *p= 0;
            DBUG_RETURN(0);
          }

5955 5956 5957 5958 5959
          /* Query hasn't started yet */
	  start_lineno= cur_file->lineno;
          DBUG_PRINT("info", ("Query hasn't started yet, start_lineno: %d",
                              start_lineno));
        }
5960 5961

        /* Skip all space at begining of line */
5962 5963 5964 5965 5966
	skip_char= 1;
      }
      else if (end_of_query(c))
      {
	*p= 0;
5967 5968
        DBUG_PRINT("exit", ("Found delimiter '%s' at line: %d",
                            delimiter, cur_file->lineno));
5969 5970 5971 5972 5973 5974 5975
	DBUG_RETURN(0);
      }
      else if (c == '}')
      {
        /* A "}" need to be by itself in the begining of a line to terminate */
        *p++= c;
	*p= 0;
5976 5977
        DBUG_PRINT("exit", ("Found '}' in begining of a line at line: %d",
                            cur_file->lineno));
5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001
	DBUG_RETURN(0);
      }
      else if (c == '\'' || c == '"' || c == '`')
      {
        last_quote= c;
	state= R_Q;
      }
      else
	state= R_NORMAL;
      break;

    case R_Q:
      if (c == last_quote)
	state= R_NORMAL;
      else if (c == '\\')
	state= R_SLASH_IN_Q;
      break;

    case R_SLASH_IN_Q:
      state= R_Q;
      break;

    }

6002 6003
    last_char= c;

6004 6005 6006 6007 6008
    if (!skip_char)
    {
      /* Could be a multibyte character */
      /* This code is based on the code in "sql_load.cc" */
#ifdef USE_MB
6009
      int charlen = my_mbcharlen(charset_info, (unsigned char) c);
6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020
      /* We give up if multibyte character is started but not */
      /* completed before we pass buf_end */
      if ((charlen > 1) && (p + charlen) <= buf_end)
      {
	int i;
	char* mb_start = p;

	*p++ = c;

	for (i= 1; i < charlen; i++)
	{
6021
	  c= my_getc(cur_file->file);
6022 6023 6024 6025 6026 6027 6028 6029
	  if (feof(cur_file->file))
	    goto found_eof;
	  *p++ = c;
	}
	if (! my_ismbchar(charset_info, mb_start, p))
	{
	  /* It was not a multiline char, push back the characters */
	  /* We leave first 'c', i.e. pretend it was a normal char */
6030
	  while (p-1 > mb_start)
6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058
	    my_ungetc(*--p);
	}
      }
      else
#endif
	*p++= c;
    }
  }
  die("The input buffer is too small for this query.x\n" \
      "check your query or increase MAX_QUERY and recompile");
  DBUG_RETURN(0);
}


/*
  Convert the read query to result format version 1

  That is: After newline, all spaces need to be skipped
  unless the previous char was a quote

  This is due to an old bug that has now been fixed, but the
  version 1 output format is preserved by using this function

*/

void convert_to_format_v1(char* query)
{
  int last_c_was_quote= 0;
6059
  char *p= query, *to= query;
6060 6061 6062 6063 6064 6065 6066
  char *end= strend(query);
  char last_c;

  while (p <= end)
  {
    if (*p == '\n' && !last_c_was_quote)
    {
6067
      *to++ = *p++; /* Save the newline */
6068 6069 6070 6071 6072 6073 6074 6075 6076 6077

      /* Skip any spaces on next line */
      while (*p && my_isspace(charset_info, *p))
        p++;

      last_c_was_quote= 0;
    }
    else if (*p == '\'' || *p == '"' || *p == '`')
    {
      last_c= *p;
6078
      *to++ = *p++;
6079 6080 6081

      /* Copy anything until the next quote of same type */
      while (*p && *p != last_c)
6082
        *to++ = *p++;
6083

6084
      *to++ = *p++;
6085 6086 6087 6088 6089

      last_c_was_quote= 1;
    }
    else
    {
6090
      *to++ = *p++;
6091 6092 6093 6094 6095 6096 6097 6098
      last_c_was_quote= 0;
    }
  }
}


/*
  Check for unexpected "junk" after the end of query
6099 6100
  This is normally caused by missing delimiters or when
  switching between different delimiters
6101 6102
*/

6103
void check_eol_junk_line(const char *line)
6104
{
6105 6106 6107
  const char *p= line;
  DBUG_ENTER("check_eol_junk_line");
  DBUG_PRINT("enter", ("line: %s", line));
6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122

  /* Check for extra delimiter */
  if (*p && !strncmp(p, delimiter, delimiter_length))
    die("Extra delimiter \"%s\" found", delimiter);

  /* Allow trailing # comment */
  if (*p && *p != '#')
  {
    if (*p == '\n')
      die("Missing delimiter");
    die("End of line junk detected: \"%s\"", p);
  }
  DBUG_VOID_RETURN;
}

6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152
void check_eol_junk(const char *eol)
{
  const char *p= eol;
  DBUG_ENTER("check_eol_junk");
  DBUG_PRINT("enter", ("eol: %s", eol));

  /* Skip past all spacing chars and comments */
  while (*p && (my_isspace(charset_info, *p) || *p == '#' || *p == '\n'))
  {
    /* Skip past comments started with # and ended with newline */
    if (*p && *p == '#')
    {
      p++;
      while (*p && *p != '\n')
        p++;
    }

    /* Check this line */
    if (*p && *p == '\n')
      check_eol_junk_line(p);

    if (*p)
      p++;
  }

  check_eol_junk_line(p);

  DBUG_VOID_RETURN;
}

6153

6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166
bool is_delimiter(const char* p)
{
  uint match= 0;
  char* delim= delimiter;
  while (*p && *p == *delim++)
  {
    match++;
    p++;
  }

  return (match == delimiter_length);
}

6167 6168 6169 6170 6171

/*
  Create a command from a set of lines

  SYNOPSIS
6172 6173
    read_command()
    command_ptr pointer where to return the new query
6174 6175

  DESCRIPTION
6176 6177
    Converts lines returned by read_line into a command, this involves
    parsing the first word in the read line to find the command type.
6178 6179 6180 6181 6182 6183 6184

  A -- comment may contain a valid query as the first word after the
  comment start. Thus it's always checked to see if that is the case.
  The advantage with this approach is to be able to execute commands
  terminated by new line '\n' regardless how many "delimiter" it contain.
*/

6185
#define MAX_QUERY (256*1024*2) /* 256K -- a test in sp-big is >128K */
6186 6187 6188 6189 6190 6191 6192 6193 6194 6195
static char read_command_buf[MAX_QUERY];

int read_command(struct st_command** command_ptr)
{
  char *p= read_command_buf;
  struct st_command* command;
  DBUG_ENTER("read_command");

  if (parser.current_line < parser.read_lines)
  {
6196
    get_dynamic(&q_lines, (uchar*) command_ptr, parser.current_line) ;
6197 6198 6199
    DBUG_RETURN(0);
  }
  if (!(*command_ptr= command=
6200 6201
        (struct st_command*) my_malloc(sizeof(*command),
                                       MYF(MY_WME|MY_ZEROFILL))) ||
6202
      insert_dynamic(&q_lines, (uchar*) &command))
6203
    die("Out of memory");
6204
  command->type= Q_UNKNOWN;
6205

6206 6207
  read_command_buf[0]= 0;
  if (read_line(read_command_buf, sizeof(read_command_buf)))
monty@mysql.com's avatar
monty@mysql.com committed
6208
  {
6209
    check_eol_junk(read_command_buf);
monty@mysql.com's avatar
monty@mysql.com committed
6210
    DBUG_RETURN(1);
monty@mysql.com's avatar
monty@mysql.com committed
6211
  }
6212

6213 6214
  if (opt_result_format_version == 1)
    convert_to_format_v1(read_command_buf);
6215

6216
  DBUG_PRINT("info", ("query: '%s'", read_command_buf));
6217 6218
  if (*p == '#')
  {
6219
    command->type= Q_COMMENT;
6220
  }
6221
  else if (p[0] == '-' && p[1] == '-')
6222
  {
6223
    command->type= Q_COMMENT_WITH_COMMAND;
6224
    p+= 2; /* Skip past -- */
6225
  }
6226 6227 6228 6229
  else if (*p == '\n')
  {
    command->type= Q_EMPTY_LINE;
  }
6230

6231
  /* Skip leading spaces */
6232
  while (*p && my_isspace(charset_info, *p))
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
6233
    p++;
6234 6235

  if (!(command->query_buf= command->query= my_strdup(p, MYF(MY_WME))))
6236
    die("Out of memory");
6237

6238 6239 6240
  /*
    Calculate first word length(the command), terminated
    by 'space' , '(' or 'delimiter' */
6241
  p= command->query;
6242
  while (*p && !my_isspace(charset_info, *p) && *p != '(' && !is_delimiter(p))
6243
    p++;
6244
  command->first_word_len= (uint) (p - command->query);
6245 6246
  DBUG_PRINT("info", ("first_word: %.*s",
                      command->first_word_len, command->query));
6247 6248

  /* Skip spaces between command and first argument */
6249
  while (*p && my_isspace(charset_info, *p))
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
6250
    p++;
6251
  command->first_argument= p;
6252

6253 6254
  command->end= strend(command->query);
  command->query_len= (command->end - command->query);
6255
  parser.read_lines++;
monty@mysql.com's avatar
monty@mysql.com committed
6256
  DBUG_RETURN(0);
6257 6258
}

6259 6260 6261

static struct my_option my_long_options[] =
{
6262 6263
  {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
   0, 0, 0, 0, 0, 0},
6264 6265
  {"basedir", 'b', "Basedir for tests.", &opt_basedir,
   &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6266
  {"character-sets-dir", OPT_CHARSETS_DIR,
6267 6268
   "Directory for character set files.", &opt_charsets_dir,
   &opt_charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6269
  {"compress", 'C', "Use the compressed server/client protocol.",
6270
   &opt_compress, &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
6271
   0, 0, 0},
6272
  {"cursor-protocol", OPT_CURSOR_PROTOCOL, "Use cursors for prepared statements.",
6273
   &cursor_protocol, &cursor_protocol, 0,
6274
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
6275
  {"database", 'D', "Database to use.", &opt_db, &opt_db, 0,
6276 6277 6278 6279 6280 6281 6282 6283
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#ifdef DBUG_OFF
  {"debug", '#', "This is a non-debug version. Catch this and exit",
   0,0, 0, GET_DISABLED, OPT_ARG, 0, 0, 0, 0, 0, 0},
#else
  {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
6284
  {"debug-check", OPT_DEBUG_CHECK, "Check memory and open file usage at exit.",
6285
   &debug_check_flag, &debug_check_flag, 0,
6286 6287
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"debug-info", OPT_DEBUG_INFO, "Print some debug info at exit.",
6288
   &debug_info_flag, &debug_info_flag,
6289
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
6290
  {"host", 'h', "Connect to host.", &opt_host, &opt_host, 0,
6291
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6292 6293 6294 6295
  {"include", 'i', "Include SQL before each test case.", &opt_include,
   &opt_include, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"logdir", OPT_LOG_DIR, "Directory for log files", &opt_logdir,
   &opt_logdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6296
  {"mark-progress", OPT_MARK_PROGRESS,
Staale Smedseng's avatar
Staale Smedseng committed
6297
   "Write line number and elapsed time to <testname>.progress.",
6298
   &opt_mark_progress, &opt_mark_progress, 0,
6299 6300
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"max-connect-retries", OPT_MAX_CONNECT_RETRIES,
Staale Smedseng's avatar
Staale Smedseng committed
6301
   "Maximum number of attempts to connect to server.",
6302
   &opt_max_connect_retries, &opt_max_connect_retries, 0,
6303
   GET_INT, REQUIRED_ARG, 500, 1, 10000, 0, 0, 0},
6304 6305
  {"max-connections", OPT_MAX_CONNECTIONS,
   "Max number of open connections to server",
6306
   &opt_max_connections, &opt_max_connections, 0,
6307
   GET_INT, REQUIRED_ARG, 128, 8, 5120, 0, 0, 0},
6308 6309
  {"password", 'p', "Password to use when connecting to server.",
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
6310 6311
  {"protocol", OPT_MYSQL_PROTOCOL, "The protocol of connection (tcp,socket,pipe,memory).",
   0, 0, 0, GET_STR,  REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6312 6313 6314 6315 6316 6317
  {"port", 'P', "Port number to use for connection or 0 for default to, in "
   "order of preference, my.cnf, $MYSQL_TCP_PORT, "
#if MYSQL_PORT_DEFAULT == 0
   "/etc/services, "
#endif
   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
6318
   &opt_port, &opt_port, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
Staale Smedseng's avatar
Staale Smedseng committed
6319 6320
  {"ps-protocol", OPT_PS_PROTOCOL, 
   "Use prepared-statement protocol for communication.",
6321
   &ps_protocol, &ps_protocol, 0,
6322
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
6323 6324
  {"quiet", 's', "Suppress all normal output.", &silent,
   &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
6325 6326
  {"record", 'r', "Record output of test_file into result file.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
Staale Smedseng's avatar
Staale Smedseng committed
6327
  {"result-file", 'R', "Read/store result from/in this file.",
6328
   &result_file_name, &result_file_name, 0,
6329
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6330 6331
  {"result-format-version", OPT_RESULT_FORMAT_VERSION,
   "Version of the result file format to use",
6332 6333
   &opt_result_format_version,
   &opt_result_format_version, 0,
6334
   GET_INT, REQUIRED_ARG, 1, 1, 2, 0, 0, 0},
paul@snake-hub.snake.net's avatar
paul@snake-hub.snake.net committed
6335
  {"server-arg", 'A', "Send option value to embedded server as a parameter.",
6336
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6337
  {"server-file", 'F', "Read embedded server arguments from file.",
6338
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6339
  {"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,
6340 6341
   "Base name of shared memory.", &shared_memory_base_name, 
   &shared_memory_base_name, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 
6342
   0, 0, 0},
6343
  {"silent", 's', "Suppress all normal output. Synonym for --quiet.",
6344
   &silent, &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
Staale Smedseng's avatar
Staale Smedseng committed
6345
  {"sleep", 'T', "Always sleep this many seconds on sleep commands.",
6346
   &opt_sleep, &opt_sleep, 0, GET_INT, REQUIRED_ARG, -1, -1, 0,
6347
   0, 0, 0},
Staale Smedseng's avatar
Staale Smedseng committed
6348
  {"socket", 'S', "The socket file to use for connection.",
6349
   &unix_sock, &unix_sock, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
6350
   0, 0, 0},
Staale Smedseng's avatar
Staale Smedseng committed
6351
  {"sp-protocol", OPT_SP_PROTOCOL, "Use stored procedures for select.",
6352
   &sp_protocol, &sp_protocol, 0,
6353
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
6354
#include "sslopt-longopts.h"
6355
  {"tail-lines", OPT_TAIL_LINES,
Staale Smedseng's avatar
Staale Smedseng committed
6356
   "Number of lines of the result to include in a failure report.",
6357
   &opt_tail_lines, &opt_tail_lines, 0,
6358
   GET_INT, REQUIRED_ARG, 0, 0, 10000, 0, 0, 0},
6359 6360
  {"test-file", 'x', "Read test from/in this file (default stdin).",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
Staale Smedseng's avatar
Staale Smedseng committed
6361
  {"timer-file", 'm', "File where the timing in microseconds is stored.",
kent@mysql.com's avatar
kent@mysql.com committed
6362
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6363
  {"tmpdir", 't', "Temporary directory where sockets are put.",
6364
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6365
  {"user", 'u', "User for login.", &opt_user, &opt_user, 0,
6366
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6367
  {"verbose", 'v', "Write more.", &verbose, &verbose, 0,
6368 6369 6370
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"version", 'V', "Output version information and exit.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
Staale Smedseng's avatar
Staale Smedseng committed
6371
  {"view-protocol", OPT_VIEW_PROTOCOL, "Use views for select.",
6372
   &view_protocol, &view_protocol, 0,
6373
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
6374 6375
  {"connect_timeout", OPT_CONNECT_TIMEOUT,
   "Number of seconds before connection timeout.",
6376
   &opt_connect_timeout, &opt_connect_timeout, 0, GET_UINT, REQUIRED_ARG,
6377
   120, 0, 3600 * 12, 0, 0, 0},
6378 6379 6380
  {"plugin_dir", OPT_PLUGIN_DIR, "Directory for client-side plugins.",
   (uchar**) &opt_plugin_dir, (uchar**) &opt_plugin_dir, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6381
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
6382 6383
};

6384

6385
void print_version(void)
6386 6387 6388 6389 6390
{
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,MTEST_VERSION,
	 MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
}

6391 6392 6393
void usage()
{
  print_version();
6394
  puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000, 2010"));
6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425
  printf("Runs a test against the mysql server and compares output with a results file.\n\n");
  printf("Usage: %s [OPTIONS] [database] < test_file\n", my_progname);
  my_print_help(my_long_options);
  printf("  --no-defaults       Don't read default options from any options file.\n");
  my_print_variables(my_long_options);
}


/*
  Read arguments for embedded server and put them into
  embedded_server_args[]
*/

void read_embedded_server_arguments(const char *name)
{
  char argument[1024],buff[FN_REFLEN], *str=0;
  FILE *file;

  if (!test_if_hard_path(name))
  {
    strxmov(buff, opt_basedir, name, NullS);
    name=buff;
  }
  fn_format(buff, name, "", "", MY_UNPACK_FILENAME);

  if (!embedded_server_arg_count)
  {
    embedded_server_arg_count=1;
    embedded_server_args[0]= (char*) "";		/* Progname */
  }
  if (!(file=my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
6426
    die("Failed to open file '%s'", buff);
6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445

  while (embedded_server_arg_count < MAX_EMBEDDED_SERVER_ARGS &&
	 (str=fgets(argument,sizeof(argument), file)))
  {
    *(strend(str)-1)=0;				/* Remove end newline */
    if (!(embedded_server_args[embedded_server_arg_count]=
	  (char*) my_strdup(str,MYF(MY_WME))))
    {
      my_fclose(file,MYF(0));
      die("Out of memory");

    }
    embedded_server_arg_count++;
  }
  my_fclose(file,MYF(0));
  if (str)
    die("Too many arguments in option file: %s",name);

  return;
6446 6447
}

6448 6449

static my_bool
Bjorn Munch's avatar
Bjorn Munch committed
6450
get_one_option(int optid, const struct my_option *opt, char *argument)
6451
{
6452
  switch(optid) {
6453
  case '#':
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6454
#ifndef DBUG_OFF
6455
    DBUG_PUSH(argument ? argument : "d:t:S:i:O,/tmp/mysqltest.trace");
6456
    debug_check_flag= 1;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6457
#endif
6458 6459 6460 6461 6462
    break;
  case 'r':
    record = 1;
    break;
  case 'x':
6463 6464 6465
  {
    char buff[FN_REFLEN];
    if (!test_if_hard_path(argument))
6466
    {
6467 6468
      strxmov(buff, opt_basedir, argument, NullS);
      argument= buff;
6469
    }
6470 6471 6472
    fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
    DBUG_ASSERT(cur_file == file_stack && cur_file->file == 0);
    if (!(cur_file->file=
6473
          fopen(buff, "rb")))
6474
      die("Could not open '%s' for reading, errno: %d", buff, errno);
6475 6476 6477 6478
    cur_file->file_name= my_strdup(buff, MYF(MY_FAE));
    cur_file->lineno= 1;
    break;
  }
kent@mysql.com's avatar
kent@mysql.com committed
6479
  case 'm':
6480 6481 6482
  {
    static char buff[FN_REFLEN];
    if (!test_if_hard_path(argument))
kent@mysql.com's avatar
kent@mysql.com committed
6483
    {
6484 6485
      strxmov(buff, opt_basedir, argument, NullS);
      argument= buff;
kent@mysql.com's avatar
kent@mysql.com committed
6486
    }
6487 6488 6489 6490 6491
    fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
    timer_file= buff;
    unlink(timer_file);	     /* Ignore error, may not exist */
    break;
  }
6492
  case 'p':
6493 6494
    if (argument == disabled_my_option)
      argument= (char*) "";			// Don't require password
6495 6496
    if (argument)
    {
6497
      my_free(opt_pass);
6498
      opt_pass= my_strdup(argument, MYF(MY_FAE));
6499
      while (*argument) *argument++= 'x';		/* Destroy argument */
6500
      tty_password= 0;
6501 6502 6503 6504
    }
    else
      tty_password= 1;
    break;
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
6505
#include <sslopt-case.h>
6506 6507 6508 6509 6510 6511 6512 6513 6514
  case 't':
    strnmov(TMPDIR, argument, sizeof(TMPDIR));
    break;
  case 'A':
    if (!embedded_server_arg_count)
    {
      embedded_server_arg_count=1;
      embedded_server_args[0]= (char*) "";
    }
6515
    if (embedded_server_arg_count == MAX_EMBEDDED_SERVER_ARGS-1 ||
6516 6517
        !(embedded_server_args[embedded_server_arg_count++]=
          my_strdup(argument, MYF(MY_FAE))))
6518 6519 6520 6521
    {
      die("Can't use server argument");
    }
    break;
6522 6523 6524 6525 6526
  case OPT_LOG_DIR:
    /* Check that the file exists */
    if (access(opt_logdir, F_OK) != 0)
      die("The specified log directory does not exist: '%s'", opt_logdir);
    break;
6527
  case 'F':
6528
    read_embedded_server_arguments(argument);
6529
    break;
6530 6531 6532
  case OPT_RESULT_FORMAT_VERSION:
    set_result_format_version(opt_result_format_version);
    break;
6533 6534 6535
  case 'V':
    print_version();
    exit(0);
6536
  case OPT_MYSQL_PROTOCOL:
6537
#ifndef EMBEDDED_LIBRARY
6538 6539
    opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,
                                    opt->name);
6540
#endif
6541
    break;
6542 6543
  case '?':
    usage();
6544
    exit(0);
6545 6546 6547 6548 6549
  }
  return 0;
}


6550 6551
int parse_args(int argc, char **argv)
{
6552 6553 6554
  if (load_defaults("my",load_default_groups,&argc,&argv))
    exit(1);

6555
  default_argv= argv;
6556

6557
  if ((handle_options(&argc, &argv, my_long_options, get_one_option)))
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6558
    exit(1);
6559 6560 6561 6562 6563 6564 6565

  if (argc > 1)
  {
    usage();
    exit(1);
  }
  if (argc == 1)
6566
    opt_db= *argv;
6567
  if (tty_password)
6568
    opt_pass= get_tty_password(NullS);          /* purify tested */
6569 6570 6571 6572
  if (debug_info_flag)
    my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
  if (debug_check_flag)
    my_end_arg= MY_CHECK_ERROR;
6573

6574 6575 6576 6577 6578 6579 6580 6581

  if (!record)
  {
    /* Check that the result file exists */
    if (result_file_name && access(result_file_name, F_OK) != 0)
      die("The specified result file '%s' does not exist", result_file_name);
  }

6582 6583 6584
  return 0;
}

6585 6586 6587 6588
/*
  Write the content of str into file

  SYNOPSIS
6589
  str_to_file2
6590 6591 6592
  fname - name of file to truncate/create and write to
  str - content to write to file
  size - size of content witten to file
6593
  append - append to file instead of overwriting old file
6594
*/
6595

6596
void str_to_file2(const char *fname, char *str, int size, my_bool append)
6597 6598
{
  int fd;
6599
  char buff[FN_REFLEN];
6600
  int flags= O_WRONLY | O_CREAT;
6601 6602 6603
  if (!test_if_hard_path(fname))
  {
    strxmov(buff, opt_basedir, fname, NullS);
6604
    fname= buff;
6605
  }
6606 6607
  fn_format(buff, fname, "", "", MY_UNPACK_FILENAME);

6608 6609 6610
  if (!append)
    flags|= O_TRUNC;
  if ((fd= my_open(buff, flags,
6611
                   MYF(MY_WME | MY_FFNF))) < 0)
6612
    die("Could not open '%s' for writing, errno: %d", buff, errno);
6613
  if (append && my_seek(fd, 0, SEEK_END, MYF(0)) == MY_FILEPOS_ERROR)
6614
    die("Could not find end of file '%s', errno: %d", buff, errno);
6615
  if (my_write(fd, (uchar*)str, size, MYF(MY_WME|MY_FNABP)))
6616
    die("write failed, errno: %d", errno);
6617 6618 6619
  my_close(fd, MYF(0));
}

6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634
/*
  Write the content of str into file

  SYNOPSIS
  str_to_file
  fname - name of file to truncate/create and write to
  str - content to write to file
  size - size of content witten to file
*/

void str_to_file(const char *fname, char *str, int size)
{
  str_to_file2(fname, str, size, FALSE);
}

6635 6636

void check_regerr(my_regex_t* r, int err)
6637
{
6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665
  char err_buf[1024];

  if (err)
  {
    my_regerror(err,r,err_buf,sizeof(err_buf));
    die("Regex error: %s\n", err_buf);
  }
}


#ifdef __WIN__

DYNAMIC_ARRAY patterns;

/*
  init_win_path_patterns

  DESCRIPTION
  Setup string patterns that will be used to detect filenames that
  needs to be converted from Win to Unix format

*/

void init_win_path_patterns()
{
  /* List of string patterns to match in order to find paths */
  const char* paths[] = { "$MYSQL_TEST_DIR",
                          "$MYSQL_TMP_DIR",
6666
                          "$MYSQLTEST_VARDIR",
6667
                          "$MASTER_MYSOCK",
6668 6669
                          "$MYSQL_SHAREDIR",
                          "$MYSQL_LIBDIR",
6670
                          "./test/" };
6671
  int num_paths= sizeof(paths)/sizeof(char*);
6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690
  int i;
  char* p;

  DBUG_ENTER("init_win_path_patterns");

  my_init_dynamic_array(&patterns, sizeof(const char*), 16, 16);

  /* Loop through all paths in the array */
  for (i= 0; i < num_paths; i++)
  {
    VAR* v;
    if (*(paths[i]) == '$')
    {
      v= var_get(paths[i], 0, 0, 0);
      p= my_strdup(v->str_val, MYF(MY_FAE));
    }
    else
      p= my_strdup(paths[i], MYF(MY_FAE));

6691 6692 6693
    /* Don't insert zero length strings in patterns array */
    if (strlen(p) == 0)
    {
6694
      my_free(p);
6695 6696 6697
      continue;
    }

6698
    if (insert_dynamic(&patterns, (uchar*) &p))
6699
      die("Out of memory");
6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717

    DBUG_PRINT("info", ("p: %s", p));
    while (*p)
    {
      if (*p == '/')
        *p='\\';
      p++;
    }
  }
  DBUG_VOID_RETURN;
}

void free_win_path_patterns()
{
  uint i= 0;
  for (i=0 ; i < patterns.elements ; i++)
  {
    const char** pattern= dynamic_element(&patterns, i, const char**);
6718
    my_free((void *) *pattern);
6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746
  }
  delete_dynamic(&patterns);
}

/*
  fix_win_paths

  DESCRIPTION
  Search the string 'val' for the patterns that are known to be
  strings that contain filenames. Convert all \ to / in the
  filenames that are found.

  Ex:
  val = 'Error "c:\mysql\mysql-test\var\test\t1.frm" didn't exist'
  => $MYSQL_TEST_DIR is found by strstr
  => all \ from c:\mysql\m... until next space is converted into /
*/

void fix_win_paths(const char *val, int len)
{
  uint i;
  char *p;

  DBUG_ENTER("fix_win_paths");
  for (i= 0; i < patterns.elements; i++)
  {
    const char** pattern= dynamic_element(&patterns, i, const char**);
    DBUG_PRINT("info", ("pattern: %s", *pattern));
6747

6748
    /* Search for the path in string */
Magnus Svensson's avatar
Magnus Svensson committed
6749
    while ((p= strstr((char*)val, *pattern)))
6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773
    {
      DBUG_PRINT("info", ("Found %s in val p: %s", *pattern, p));

      while (*p && !my_isspace(charset_info, *p))
      {
        if (*p == '\\')
          *p= '/';
        p++;
      }
      DBUG_PRINT("info", ("Converted \\ to /, p: %s", p));
    }
  }
  DBUG_PRINT("exit", (" val: %s, len: %d", val, len));
  DBUG_VOID_RETURN;
}
#endif



/*
  Append the result for one field to the dynamic string ds
*/

void append_field(DYNAMIC_STRING *ds, uint col_idx, MYSQL_FIELD* field,
6774
                  char* val, ulonglong len, my_bool is_null)
6775
{
6776 6777
  char null[]= "NULL";

6778 6779 6780 6781 6782 6783 6784
  if (col_idx < max_replace_column && replace_column[col_idx])
  {
    val= replace_column[col_idx];
    len= strlen(val);
  }
  else if (is_null)
  {
6785
    val= null;
6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798
    len= 4;
  }
#ifdef __WIN__
  else if ((field->type == MYSQL_TYPE_DOUBLE ||
            field->type == MYSQL_TYPE_FLOAT ) &&
           field->decimals >= 31)
  {
    /* Convert 1.2e+018 to 1.2e+18 and 1.2e-018 to 1.2e-18 */
    char *start= strchr(val, 'e');
    if (start && strlen(start) >= 5 &&
        (start[1] == '-' || start[1] == '+') && start[2] == '0')
    {
      start+=2; /* Now points at first '0' */
6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810
      if (field->flags & ZEROFILL_FLAG)
      {
        /* Move all chars before the first '0' one step right */
        memmove(val + 1, val, start - val);
        *val= '0';
      }
      else
      {
        /* Move all chars after the first '0' one step left */
        memmove(start, start + 1, strlen(start));
        len--;
      }
6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821
    }
  }
#endif

  if (!display_result_vertically)
  {
    if (col_idx)
      dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_mem(ds, val, (int)len);
  }
  else
6822
  {
6823 6824 6825 6826
    dynstr_append(ds, field->name);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_mem(ds, val, (int)len);
    dynstr_append_mem(ds, "\n", 1);
6827 6828 6829
  }
}

6830

6831 6832
/*
  Append all results to the dynamic string separated with '\t'
6833
  Values may be converted with 'replace_column'
6834 6835
*/

6836
void append_result(DYNAMIC_STRING *ds, MYSQL_RES *res)
6837 6838
{
  MYSQL_ROW row;
6839
  uint num_fields= mysql_num_fields(res);
6840 6841 6842
  MYSQL_FIELD *fields= mysql_fetch_fields(res);
  ulong *lengths;

6843 6844
  while ((row = mysql_fetch_row(res)))
  {
6845
    uint i;
6846 6847
    lengths = mysql_fetch_lengths(res);
    for (i = 0; i < num_fields; i++)
6848
      append_field(ds, i, &fields[i],
6849
                   row[i], lengths[i], !row[i]);
6850 6851
    if (!display_result_vertically)
      dynstr_append_mem(ds, "\n", 1);
6852 6853 6854
  }
}

6855

6856
/*
6857 6858
  Append all results from ps execution to the dynamic string separated
  with '\t'. Values may be converted with 'replace_column'
6859
*/
6860

6861 6862
void append_stmt_result(DYNAMIC_STRING *ds, MYSQL_STMT *stmt,
                        MYSQL_FIELD *fields, uint num_fields)
6863
{
6864
  MYSQL_BIND *my_bind;
6865 6866 6867
  my_bool *is_null;
  ulong *length;
  uint i;
6868

6869
  /* Allocate array with bind structs, lengths and NULL flags */
6870
  my_bind= (MYSQL_BIND*) my_malloc(num_fields * sizeof(MYSQL_BIND),
6871 6872 6873 6874 6875
				MYF(MY_WME | MY_FAE | MY_ZEROFILL));
  length= (ulong*) my_malloc(num_fields * sizeof(ulong),
			     MYF(MY_WME | MY_FAE));
  is_null= (my_bool*) my_malloc(num_fields * sizeof(my_bool),
				MYF(MY_WME | MY_FAE));
6876

6877 6878 6879 6880
  /* Allocate data for the result of each field */
  for (i= 0; i < num_fields; i++)
  {
    uint max_length= fields[i].max_length + 1;
6881
    my_bind[i].buffer_type= MYSQL_TYPE_STRING;
6882
    my_bind[i].buffer= my_malloc(max_length, MYF(MY_WME | MY_FAE));
6883 6884 6885
    my_bind[i].buffer_length= max_length;
    my_bind[i].is_null= &is_null[i];
    my_bind[i].length= &length[i];
6886

6887
    DBUG_PRINT("bind", ("col[%d]: buffer_type: %d, buffer_length: %lu",
6888
			i, my_bind[i].buffer_type, my_bind[i].buffer_length));
6889
  }
6890

6891
  if (mysql_stmt_bind_result(stmt, my_bind))
6892 6893 6894 6895 6896 6897
    die("mysql_stmt_bind_result failed: %d: %s",
	mysql_stmt_errno(stmt), mysql_stmt_error(stmt));

  while (mysql_stmt_fetch(stmt) == 0)
  {
    for (i= 0; i < num_fields; i++)
6898
      append_field(ds, i, &fields[i], (char*)my_bind[i].buffer,
6899
                   *my_bind[i].length, *my_bind[i].is_null);
6900 6901 6902 6903 6904 6905 6906
    if (!display_result_vertically)
      dynstr_append_mem(ds, "\n", 1);
  }

  if (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
    die("fetch didn't end with MYSQL_NO_DATA from statement: %d %s",
	mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
6907

6908 6909 6910
  for (i= 0; i < num_fields; i++)
  {
    /* Free data for output */
6911
    my_free(my_bind[i].buffer);
6912 6913
  }
  /* Free array with bind structs, lengths and NULL flags */
6914 6915 6916
  my_free(my_bind);
  my_free(length);
  my_free(is_null);
6917 6918 6919
}


6920 6921 6922 6923 6924 6925 6926
/*
  Append metadata for fields to output
*/

void append_metadata(DYNAMIC_STRING *ds,
                     MYSQL_FIELD *field,
                     uint num_fields)
6927
{
6928 6929 6930 6931 6932 6933 6934 6935
  MYSQL_FIELD *field_end;
  dynstr_append(ds,"Catalog\tDatabase\tTable\tTable_alias\tColumn\t"
                "Column_alias\tType\tLength\tMax length\tIs_null\t"
                "Flags\tDecimals\tCharsetnr\n");

  for (field_end= field+num_fields ;
       field < field_end ;
       field++)
6936
  {
6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967
    dynstr_append_mem(ds, field->catalog,
                      field->catalog_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->db, field->db_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->org_table,
                      field->org_table_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->table,
                      field->table_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->org_name,
                      field->org_name_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->name, field->name_length);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->type);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->length);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->max_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, (char*) (IS_NOT_NULL(field->flags) ?
                                   "N" : "Y"), 1);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->flags);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->decimals);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->charsetnr);
    dynstr_append_mem(ds, "\n", 1);
6968
  }
6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982
}


/*
  Append affected row count and other info to output
*/

void append_info(DYNAMIC_STRING *ds, ulonglong affected_rows,
                 const char *info)
{
  char buf[40], buff2[21];
  sprintf(buf,"affected rows: %s\n", llstr(affected_rows, buff2));
  dynstr_append(ds, buf);
  if (info)
6983
  {
6984 6985 6986
    dynstr_append(ds, "info: ");
    dynstr_append(ds, info);
    dynstr_append_mem(ds, "\n", 1);
6987
  }
6988 6989
}

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6990

6991 6992 6993 6994 6995 6996 6997 6998 6999 7000
/*
  Display the table headings with the names tab separated
*/

void append_table_headings(DYNAMIC_STRING *ds,
                           MYSQL_FIELD *field,
                           uint num_fields)
{
  uint col_idx;
  for (col_idx= 0; col_idx < num_fields; col_idx++)
7001
  {
7002 7003 7004
    if (col_idx)
      dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append(ds, field[col_idx].name);
7005
  }
7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020
  dynstr_append_mem(ds, "\n", 1);
}

/*
  Fetch warnings from server and append to ds

  RETURN VALUE
  Number of warnings appended to ds
*/

int append_warnings(DYNAMIC_STRING *ds, MYSQL* mysql)
{
  uint count;
  MYSQL_RES *warn_res;
  DBUG_ENTER("append_warnings");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
7021

7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050
  if (!(count= mysql_warning_count(mysql)))
    DBUG_RETURN(0);

  /*
    If one day we will support execution of multi-statements
    through PS API we should not issue SHOW WARNINGS until
    we have not read all results...
  */
  DBUG_ASSERT(!mysql_more_results(mysql));

  if (mysql_real_query(mysql, "SHOW WARNINGS", 13))
    die("Error running query \"SHOW WARNINGS\": %s", mysql_error(mysql));

  if (!(warn_res= mysql_store_result(mysql)))
    die("Warning count is %u but didn't get any warnings",
	count);

  append_result(ds, warn_res);
  mysql_free_result(warn_res);

  DBUG_PRINT("warnings", ("%s", ds->str));

  DBUG_RETURN(count);
}


/*
  Run query using MySQL C API

7051 7052 7053 7054 7055 7056 7057 7058
  SYNOPSIS
    run_query_normal()
    mysql	mysql handle
    command	current command pointer
    flags	flags indicating if we should SEND and/or REAP
    query	query string to execute
    query_len	length query string to execute
    ds		output buffer where to store result form query
7059 7060
*/

holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
7061
void run_query_normal(struct st_connection *cn, struct st_command *command,
7062 7063 7064 7065
                      int flags, char *query, int query_len,
                      DYNAMIC_STRING *ds, DYNAMIC_STRING *ds_warnings)
{
  MYSQL_RES *res= 0;
7066
  MYSQL *mysql= &cn->mysql;
7067 7068 7069 7070 7071 7072
  int err= 0, counter= 0;
  DBUG_ENTER("run_query_normal");
  DBUG_PRINT("enter",("flags: %d", flags));
  DBUG_PRINT("enter", ("query: '%-.60s'", query));

  if (flags & QUERY_SEND_FLAG)
7073
  {
7074 7075 7076
    /*
      Send the query
    */
7077
    if (do_send_query(cn, query, query_len))
7078 7079 7080 7081 7082
    {
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
      goto end;
    }
7083
  }
7084
  if (!(flags & QUERY_REAP_FLAG))
7085 7086
  {
    cn->pending= TRUE;
7087
    DBUG_VOID_RETURN;
7088 7089
  }
  
7090
  do
7091
  {
7092 7093 7094 7095
    /*
      When  on first result set, call mysql_read_query_result to retrieve
      answer to the query sent earlier
    */
7096
    if ((counter==0) && do_read_query_result(cn))
7097
    {
7098 7099
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
7100 7101
      goto end;

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
7102
    }
7103

7104
    /*
7105
      Store the result of the query if it will return any fields
7106
    */
7107
    if (mysql_field_count(mysql) && ((res= mysql_store_result(mysql)) == 0))
7108
    {
7109 7110
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
7111
      goto end;
7112
    }
7113

7114
    if (!disable_result_log)
7115
    {
7116
      if (res)
7117
      {
7118
	MYSQL_FIELD *fields= mysql_fetch_fields(res);
7119
	uint num_fields= mysql_num_fields(res);
7120

7121
	if (display_metadata)
7122
          append_metadata(ds, fields, num_fields);
7123

7124
	if (!display_result_vertically)
7125 7126
	  append_table_headings(ds, fields, num_fields);

7127
	append_result(ds, res);
7128
      }
7129

kent@mysql.com's avatar
kent@mysql.com committed
7130
      /*
7131
        Need to call mysql_affected_rows() before the "new"
7132
        query to find the warnings.
kent@mysql.com's avatar
kent@mysql.com committed
7133 7134
      */
      if (!disable_info)
7135
	append_info(ds, mysql_affected_rows(mysql), mysql_info(mysql));
kent@mysql.com's avatar
kent@mysql.com committed
7136

7137 7138 7139 7140 7141 7142
      /*
        Add all warnings to the result. We can't do this if we are in
        the middle of processing results from multi-statement, because
        this will break protocol.
      */
      if (!disable_warnings && !mysql_more_results(mysql))
7143
      {
7144
	if (append_warnings(ds_warnings, mysql) || ds_warnings->length)
7145 7146
	{
	  dynstr_append_mem(ds, "Warnings:\n", 10);
7147
	  dynstr_append_mem(ds, ds_warnings->str, ds_warnings->length);
7148
	}
7149
      }
7150
    }
7151

7152
    if (res)
7153
    {
7154
      mysql_free_result(res);
7155 7156
      res= 0;
    }
7157 7158
    counter++;
  } while (!(err= mysql_next_result(mysql)));
7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169
  if (err > 0)
  {
    /* We got an error from mysql_next_result, maybe expected */
    handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		 mysql_sqlstate(mysql), ds);
    goto end;
  }
  DBUG_ASSERT(err == -1); /* Successful and there are no more results */

  /* If we come here the query is both executed and read successfully */
  handle_no_error(command);
7170

7171
end:
7172

7173
  cn->pending= FALSE;
7174 7175 7176 7177 7178
  /*
    We save the return code (mysql_errno(mysql)) from the last call sent
    to the server into the mysqltest builtin variable $mysql_errno. This
    variable then can be used from the test case itself.
  */
7179
  var_set_errno(mysql_errno(mysql));
7180
  DBUG_VOID_RETURN;
7181 7182 7183
}


7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233
/*
  Check whether given error is in list of expected errors

  SYNOPSIS
    match_expected_error()

  PARAMETERS
    command        the current command (and its expect-list)
    err_errno      error number of the error that actually occurred
    err_sqlstate   SQL-state that was thrown, or NULL for impossible
                   (file-ops, diff, etc.)

  RETURNS
    -1 for not in list, index in list of expected errors otherwise

  NOTE
    If caller needs to know whether the list was empty, they should
    check command->expected_errors.count.
*/

static int match_expected_error(struct st_command *command,
                                unsigned int err_errno,
                                const char *err_sqlstate)
{
  uint i;

  for (i= 0 ; (uint) i < command->expected_errors.count ; i++)
  {
    if ((command->expected_errors.err[i].type == ERR_ERRNO) &&
        (command->expected_errors.err[i].code.errnum == err_errno))
      return i;

    if (command->expected_errors.err[i].type == ERR_SQLSTATE)
    {
      /*
        NULL is quite likely, but not in conjunction with a SQL-state expect!
      */
      if (unlikely(err_sqlstate == NULL))
        die("expecting a SQL-state (%s) from query '%s' which cannot produce one...",
            command->expected_errors.err[i].code.sqlstate, command->query);

      if (strncmp(command->expected_errors.err[i].code.sqlstate,
                  err_sqlstate, SQLSTATE_LENGTH) == 0)
        return i;
    }
  }
  return -1;
}


7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245
/*
  Handle errors which occurred during execution

  SYNOPSIS
  handle_error()
  q     - query context
  err_errno - error number
  err_error - error message
  err_sqlstate - sql state
  ds    - dynamic string which is used for output buffer

  NOTE
7246 7247
    If there is an unexpected error this function will abort mysqltest
    immediately.
7248 7249 7250 7251 7252 7253
*/

void handle_error(struct st_command *command,
                  unsigned int err_errno, const char *err_error,
                  const char *err_sqlstate, DYNAMIC_STRING *ds)
{
7254
  int i;
7255 7256 7257

  DBUG_ENTER("handle_error");

7258
  if (command->require_file[0])
7259 7260 7261 7262 7263 7264 7265 7266
  {
    /*
      The query after a "--require" failed. This is fine as long the server
      returned a valid reponse. Don't allow 2013 or 2006 to trigger an
      abort_not_supported_test
    */
    if (err_errno == CR_SERVER_LOST ||
        err_errno == CR_SERVER_GONE_ERROR)
7267 7268
      die("require query '%s' failed: %d: %s", command->query,
          err_errno, err_error);
7269 7270

    /* Abort the run of this test, pass the failed query as reason */
7271
    abort_not_supported_test("Query '%s' failed, required functionality " \
7272 7273 7274 7275 7276 7277 7278 7279
                             "not supported", command->query);
  }

  if (command->abort_on_error)
    die("query '%s' failed: %d: %s", command->query, err_errno, err_error);

  DBUG_PRINT("info", ("expected_errors.count: %d",
                      command->expected_errors.count));
7280 7281 7282 7283

  i= match_expected_error(command, err_errno, err_sqlstate);

  if (i >= 0)
7284
  {
7285
    if (!disable_result_log)
7286
    {
7287
      if (command->expected_errors.count == 1)
7288
      {
7289 7290 7291 7292 7293 7294
        /* Only log error if there is one possible error */
        dynstr_append_mem(ds, "ERROR ", 6);
        replace_dynstr_append(ds, err_sqlstate);
        dynstr_append_mem(ds, ": ", 2);
        replace_dynstr_append(ds, err_error);
        dynstr_append_mem(ds,"\n",1);
7295
      }
7296 7297 7298 7299 7300
      /* Don't log error if we may not get an error */
      else if (command->expected_errors.err[0].type == ERR_SQLSTATE ||
               (command->expected_errors.err[0].type == ERR_ERRNO &&
                command->expected_errors.err[0].code.errnum != 0))
        dynstr_append(ds,"Got one of the listed errors\n");
7301
    }
7302 7303
    /* OK */
    DBUG_VOID_RETURN;
7304 7305 7306
  }

  DBUG_PRINT("info",("i: %d  expected_errors: %d", i,
7307
                     command->expected_errors.count));
7308 7309 7310 7311 7312 7313 7314 7315 7316 7317

  if (!disable_result_log)
  {
    dynstr_append_mem(ds, "ERROR ",6);
    replace_dynstr_append(ds, err_sqlstate);
    dynstr_append_mem(ds, ": ", 2);
    replace_dynstr_append(ds, err_error);
    dynstr_append_mem(ds, "\n", 1);
  }

7318
  if (command->expected_errors.count > 0)
7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332
  {
    if (command->expected_errors.err[0].type == ERR_ERRNO)
      die("query '%s' failed with wrong errno %d: '%s', instead of %d...",
          command->query, err_errno, err_error,
          command->expected_errors.err[0].code.errnum);
    else
      die("query '%s' failed with wrong sqlstate %s: '%s', instead of %s...",
          command->query, err_sqlstate, err_error,
	  command->expected_errors.err[0].code.sqlstate);
  }

  DBUG_VOID_RETURN;
}

7333 7334

/*
7335 7336 7337 7338 7339 7340 7341 7342
  Handle absence of errors after execution

  SYNOPSIS
  handle_no_error()
  q - context of query

  RETURN VALUE
  error - function will not return
7343 7344
*/

7345
void handle_no_error(struct st_command *command)
7346
{
7347
  DBUG_ENTER("handle_no_error");
7348

7349 7350
  if (command->expected_errors.err[0].type == ERR_ERRNO &&
      command->expected_errors.err[0].code.errnum != 0)
7351
  {
7352 7353 7354
    /* Error code we wanted was != 0, i.e. not an expected success */
    die("query '%s' succeeded - should have failed with errno %d...",
        command->query, command->expected_errors.err[0].code.errnum);
7355
  }
7356 7357
  else if (command->expected_errors.err[0].type == ERR_SQLSTATE &&
           strcmp(command->expected_errors.err[0].code.sqlstate,"00000") != 0)
7358
  {
7359 7360 7361
    /* SQLSTATE we wanted was != "00000", i.e. not an expected success */
    die("query '%s' succeeded - should have failed with sqlstate %s...",
        command->query, command->expected_errors.err[0].code.sqlstate);
7362
  }
7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391

  DBUG_VOID_RETURN;
}


/*
  Run query using prepared statement C API

  SYNPOSIS
  run_query_stmt
  mysql - mysql handle
  command - currrent command pointer
  query - query string to execute
  query_len - length query string to execute
  ds - output buffer where to store result form query

  RETURN VALUE
  error - function will not return
*/

void run_query_stmt(MYSQL *mysql, struct st_command *command,
                    char *query, int query_len, DYNAMIC_STRING *ds,
                    DYNAMIC_STRING *ds_warnings)
{
  MYSQL_RES *res= NULL;     /* Note that here 'res' is meta data result set */
  MYSQL_STMT *stmt;
  DYNAMIC_STRING ds_prepare_warnings;
  DYNAMIC_STRING ds_execute_warnings;
  DBUG_ENTER("run_query_stmt");
7392 7393
  DBUG_PRINT("query", ("'%-.60s'", query));

7394 7395 7396 7397
  /*
    Init a new stmt if it's not already one created for this connection
  */
  if(!(stmt= cur_con->stmt))
7398
  {
7399 7400 7401
    if (!(stmt= mysql_stmt_init(mysql)))
      die("unable to init stmt structure");
    cur_con->stmt= stmt;
7402 7403
  }

7404 7405
  /* Init dynamic strings for warnings */
  if (!disable_warnings)
7406
  {
7407 7408
    init_dynamic_string(&ds_prepare_warnings, NULL, 0, 256);
    init_dynamic_string(&ds_execute_warnings, NULL, 0, 256);
7409 7410 7411
  }

  /*
7412
    Prepare the query
7413
  */
7414
  if (mysql_stmt_prepare(stmt, query, query_len))
7415
  {
7416 7417 7418
    handle_error(command,  mysql_stmt_errno(stmt),
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
    goto end;
7419 7420
  }

7421 7422 7423 7424 7425 7426
  /*
    Get the warnings from mysql_stmt_prepare and keep them in a
    separate string
  */
  if (!disable_warnings)
    append_warnings(&ds_prepare_warnings, mysql);
7427 7428

  /*
7429
    No need to call mysql_stmt_bind_param() because we have no
7430 7431 7432
    parameter markers.
  */

7433 7434
#if MYSQL_VERSION_ID >= 50000
  if (cursor_protocol_enabled)
7435
  {
7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453
    /*
      Use cursor when retrieving result
    */
    ulong type= CURSOR_TYPE_READ_ONLY;
    if (mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type))
      die("mysql_stmt_attr_set(STMT_ATTR_CURSOR_TYPE) failed': %d %s",
          mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
  }
#endif

  /*
    Execute the query
  */
  if (mysql_stmt_execute(stmt))
  {
    handle_error(command, mysql_stmt_errno(stmt),
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
    goto end;
7454 7455
  }

7456 7457 7458 7459 7460 7461 7462
  /*
    When running in cursor_protocol get the warnings from execute here
    and keep them in a separate string for later.
  */
  if (cursor_protocol_enabled && !disable_warnings)
    append_warnings(&ds_execute_warnings, mysql);

7463 7464
  /*
    We instruct that we want to update the "max_length" field in
7465 7466
    mysql_stmt_store_result(), this is our only way to know how much
    buffer to allocate for result data
7467 7468 7469
  */
  {
    my_bool one= 1;
7470 7471 7472
    if (mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &one))
      die("mysql_stmt_attr_set(STMT_ATTR_UPDATE_MAX_LENGTH) failed': %d %s",
          mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
7473 7474 7475 7476 7477
  }

  /*
    If we got here the statement succeeded and was expected to do so,
    get data. Note that this can still give errors found during execution!
7478
    Store the result of the query if if will return any fields
7479
  */
7480
  if (mysql_stmt_field_count(stmt) && mysql_stmt_store_result(stmt))
7481
  {
7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497
    handle_error(command, mysql_stmt_errno(stmt),
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
    goto end;
  }

  /* If we got here the statement was both executed and read successfully */
  handle_no_error(command);
  if (!disable_result_log)
  {
    /*
      Not all statements creates a result set. If there is one we can
      now create another normal result set that contains the meta
      data. This set can be handled almost like any other non prepared
      statement result set.
    */
    if ((res= mysql_stmt_result_metadata(stmt)) != NULL)
7498
    {
7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514
      /* Take the column count from meta info */
      MYSQL_FIELD *fields= mysql_fetch_fields(res);
      uint num_fields= mysql_num_fields(res);

      if (display_metadata)
        append_metadata(ds, fields, num_fields);

      if (!display_result_vertically)
        append_table_headings(ds, fields, num_fields);

      append_stmt_result(ds, stmt, fields, num_fields);

      mysql_free_result(res);     /* Free normal result set with meta data */

      /* Clear prepare warnings */
      dynstr_set(&ds_prepare_warnings, NULL);
7515 7516 7517
    }
    else
    {
7518 7519 7520
      /*
	This is a query without resultset
      */
7521
    }
7522

7523
    /*
7524 7525
      Fetch info before fetching warnings, since it will be reset
      otherwise.
7526
    */
7527

7528
    if (!disable_info)
7529
      append_info(ds, mysql_stmt_affected_rows(stmt), mysql_info(mysql));
7530

7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541
    if (!disable_warnings)
    {
      /* Get the warnings from execute */

      /* Append warnings to ds - if there are any */
      if (append_warnings(&ds_execute_warnings, mysql) ||
          ds_execute_warnings.length ||
          ds_prepare_warnings.length ||
          ds_warnings->length)
      {
        dynstr_append_mem(ds, "Warnings:\n", 10);
Alexander Nozdrin's avatar
Alexander Nozdrin committed
7542 7543 7544 7545 7546 7547 7548 7549 7550
        if (ds_warnings->length)
          dynstr_append_mem(ds, ds_warnings->str,
                            ds_warnings->length);
        if (ds_prepare_warnings.length)
          dynstr_append_mem(ds, ds_prepare_warnings.str,
                            ds_prepare_warnings.length);
        if (ds_execute_warnings.length)
          dynstr_append_mem(ds, ds_execute_warnings.str,
                            ds_execute_warnings.length);
7551 7552
      }
    }
7553 7554
  }

7555 7556
end:
  if (!disable_warnings)
7557
  {
7558 7559
    dynstr_free(&ds_prepare_warnings);
    dynstr_free(&ds_execute_warnings);
7560 7561
  }

7562 7563 7564 7565 7566 7567 7568 7569

  /* Close the statement if - no reconnect, need new prepare */
  if (mysql->reconnect)
  {
    mysql_stmt_close(stmt);
    cur_con->stmt= NULL;
  }

7570
  /*
7571 7572 7573
    We save the return code (mysql_stmt_errno(stmt)) from the last call sent
    to the server into the mysqltest builtin variable $mysql_errno. This
    variable then can be used from the test case itself.
7574
  */
7575 7576

  var_set_errno(mysql_stmt_errno(stmt));
7577

7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595
  DBUG_VOID_RETURN;
}



/*
  Create a util connection if one does not already exists
  and use that to run the query
  This is done to avoid implict commit when creating/dropping objects such
  as view, sp etc.
*/

int util_query(MYSQL* org_mysql, const char* query){

  MYSQL* mysql;
  DBUG_ENTER("util_query");

  if(!(mysql= cur_con->util_mysql))
7596
  {
7597 7598 7599
    DBUG_PRINT("info", ("Creating util_mysql"));
    if (!(mysql= mysql_init(mysql)))
      die("Failed in mysql_init()");
7600

7601 7602 7603 7604
    if (opt_connect_timeout)
      mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT,
                    (void *) &opt_connect_timeout);

7605 7606
    /* enable local infile, in non-binary builds often disabled by default */
    mysql_options(mysql, MYSQL_OPT_LOCAL_INFILE, 0);
7607 7608 7609
    safe_connect(mysql, "util", org_mysql->host, org_mysql->user,
                 org_mysql->passwd, org_mysql->db, org_mysql->port,
                 org_mysql->unix_socket);
7610

7611 7612
    cur_con->util_mysql= mysql;
  }
7613

7614
 DBUG_RETURN(mysql_query(mysql, query));
7615
}
7616 7617 7618



7619 7620
/*
  Run query
7621

7622 7623 7624 7625 7626
  SYNPOSIS
    run_query()
     mysql	mysql handle
     command	currrent command pointer

7627 7628 7629 7630
  flags control the phased/stages of query execution to be performed
  if QUERY_SEND_FLAG bit is on, the query will be sent. If QUERY_REAP_FLAG
  is on the result will be read - for regular query, both bits must be on
*/
7631

holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
7632
void run_query(struct st_connection *cn, struct st_command *command, int flags)
7633
{
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
7634
  MYSQL *mysql= &cn->mysql;
7635
  DYNAMIC_STRING *ds;
7636
  DYNAMIC_STRING *save_ds= NULL;
7637
  DYNAMIC_STRING ds_result;
7638
  DYNAMIC_STRING ds_sorted;
7639 7640 7641 7642 7643 7644 7645
  DYNAMIC_STRING ds_warnings;
  DYNAMIC_STRING eval_query;
  char *query;
  int query_len;
  my_bool view_created= 0, sp_created= 0;
  my_bool complete_query= ((flags & QUERY_SEND_FLAG) &&
                           (flags & QUERY_REAP_FLAG));
7646
  DBUG_ENTER("run_query");
7647

7648 7649 7650
  if (cn->pending && (flags & QUERY_SEND_FLAG))
    die ("Cannot run query on connection between send and reap");

7651 7652 7653
  if (!(flags & QUERY_SEND_FLAG) && !cn->pending)
    die ("Cannot reap on a connection without pending send");
  
7654
  init_dynamic_string(&ds_warnings, NULL, 0, 256);
7655 7656 7657
  /*
    Evaluate query if this is an eval command
  */
7658
  if (command->type == Q_EVAL || command->type == Q_SEND_EVAL)
7659
  {
7660 7661 7662 7663
    init_dynamic_string(&eval_query, "", command->query_len+256, 1024);
    do_eval(&eval_query, command->query, command->end, FALSE);
    query = eval_query.str;
    query_len = eval_query.length;
7664
  }
7665
  else
7666
  {
7667 7668
    query = command->query;
    query_len = strlen(query);
7669 7670
  }

7671
  /*
7672
    When command->require_file is set the output of _this_ query
7673 7674 7675 7676
    should be compared with an already existing file
    Create a temporary dynamic string to contain the output from
    this query.
  */
7677
  if (command->require_file[0])
7678 7679 7680 7681 7682 7683
  {
    init_dynamic_string(&ds_result, "", 1024, 1024);
    ds= &ds_result;
  }
  else
    ds= &ds_res;
7684

7685 7686 7687 7688 7689 7690 7691 7692 7693
  /*
    Log the query into the output buffer
  */
  if (!disable_query_log && (flags & QUERY_SEND_FLAG))
  {
    replace_dynstr_append_mem(ds, query, query_len);
    dynstr_append_mem(ds, delimiter, delimiter_length);
    dynstr_append_mem(ds, "\n", 1);
  }
7694

7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716
  if (view_protocol_enabled &&
      complete_query &&
      match_re(&view_re, query))
  {
    /*
      Create the query as a view.
      Use replace since view can exist from a failed mysqltest run
    */
    DYNAMIC_STRING query_str;
    init_dynamic_string(&query_str,
			"CREATE OR REPLACE VIEW mysqltest_tmp_v AS ",
			query_len+64, 256);
    dynstr_append_mem(&query_str, query, query_len);
    if (util_query(mysql, query_str.str))
    {
      /*
	Failed to create the view, this is not fatal
	just run the query the normal way
      */
      DBUG_PRINT("view_create_error",
		 ("Failed to create view '%s': %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql)));
7717

7718 7719 7720 7721 7722 7723 7724 7725 7726 7727 7728 7729
      /* Log error to create view */
      verbose_msg("Failed to create view '%s' %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql));
    }
    else
    {
      /*
	Yes, it was possible to create this query as a view
      */
      view_created= 1;
      query= (char*)"SELECT * FROM mysqltest_tmp_v";
      query_len = strlen(query);
7730

7731 7732 7733 7734 7735 7736
      /*
        Collect warnings from create of the view that should otherwise
        have been produced when the SELECT was executed
      */
      append_warnings(&ds_warnings, cur_con->util_mysql);
    }
7737

7738
    dynstr_free(&query_str);
7739 7740 7741

  }

7742 7743 7744 7745 7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765
  if (sp_protocol_enabled &&
      complete_query &&
      match_re(&sp_re, query))
  {
    /*
      Create the query as a stored procedure
      Drop first since sp can exist from a failed mysqltest run
    */
    DYNAMIC_STRING query_str;
    init_dynamic_string(&query_str,
			"DROP PROCEDURE IF EXISTS mysqltest_tmp_sp;",
			query_len+64, 256);
    util_query(mysql, query_str.str);
    dynstr_set(&query_str, "CREATE PROCEDURE mysqltest_tmp_sp()\n");
    dynstr_append_mem(&query_str, query, query_len);
    if (util_query(mysql, query_str.str))
    {
      /*
	Failed to create the stored procedure for this query,
	this is not fatal just run the query the normal way
      */
      DBUG_PRINT("sp_create_error",
		 ("Failed to create sp '%s': %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql)));
7766

7767 7768 7769
      /* Log error to create sp */
      verbose_msg("Failed to create sp '%s' %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql));
7770

7771 7772
    }
    else
7773
    {
7774 7775 7776 7777
      sp_created= 1;

      query= (char*)"CALL mysqltest_tmp_sp()";
      query_len = strlen(query);
7778
    }
7779
    dynstr_free(&query_str);
7780 7781
  }

7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793
  if (display_result_sorted)
  {
    /*
       Collect the query output in a separate string
       that can be sorted before it's added to the
       global result string
    */
    init_dynamic_string(&ds_sorted, "", 1024, 1024);
    save_ds= ds; /* Remember original ds */
    ds= &ds_sorted;
  }

7794 7795 7796 7797 7798
  /*
    Find out how to run this query

    Always run with normal C API if it's not a complete
    SEND + REAP
7799

7800 7801 7802 7803 7804 7805 7806 7807
    If it is a '?' in the query it may be a SQL level prepared
    statement already and we can't do it twice
  */
  if (ps_protocol_enabled &&
      complete_query &&
      match_re(&ps_re, query))
    run_query_stmt(mysql, command, query, query_len, ds, &ds_warnings);
  else
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
7808
    run_query_normal(cn, command, flags, query, query_len,
7809 7810
		     ds, &ds_warnings);

7811 7812 7813 7814
  dynstr_free(&ds_warnings);
  if (command->type == Q_EVAL)
    dynstr_free(&eval_query);

7815 7816 7817 7818 7819 7820 7821
  if (display_result_sorted)
  {
    /* Sort the result set and append it to result */
    dynstr_append_sorted(save_ds, &ds_sorted);
    ds= save_ds;
    dynstr_free(&ds_sorted);
  }
7822 7823

  if (sp_created)
7824
  {
7825 7826
    if (util_query(mysql, "DROP PROCEDURE mysqltest_tmp_sp "))
      die("Failed to drop sp: %d: %s", mysql_errno(mysql), mysql_error(mysql));
7827 7828
  }

7829 7830 7831 7832 7833 7834 7835
  if (view_created)
  {
    if (util_query(mysql, "DROP VIEW mysqltest_tmp_v "))
      die("Failed to drop view: %d: %s",
	  mysql_errno(mysql), mysql_error(mysql));
  }

7836
  if (command->require_file[0])
7837
  {
7838 7839 7840 7841 7842
    /* A result file was specified for _this_ query
       and the output should be checked against an already
       existing file which has been specified using --require or --result
    */
    check_require(ds, command->require_file);
7843 7844
  }

7845 7846
  if (ds == &ds_result)
    dynstr_free(&ds_result);
7847
  DBUG_VOID_RETURN;
7848 7849
}

7850
/****************************************************************************/
7851
/*
7852
  Functions to detect different SQL statements
7853 7854
*/

7855
char *re_eprint(int err)
7856
{
7857 7858 7859 7860 7861 7862
  static char epbuf[100];
  size_t len= my_regerror(REG_ITOA|err, (my_regex_t *)NULL,
			  epbuf, sizeof(epbuf));
  assert(len <= sizeof(epbuf));
  return(epbuf);
}
7863

7864 7865 7866 7867 7868
void init_re_comp(my_regex_t *re, const char* str)
{
  int err= my_regcomp(re, str, (REG_EXTENDED | REG_ICASE | REG_NOSUB),
                      &my_charset_latin1);
  if (err)
7869
  {
7870 7871 7872
    char erbuf[100];
    int len= my_regerror(err, re, erbuf, sizeof(erbuf));
    die("error %s, %d/%d `%s'\n",
Sergey Glukhov's avatar
Sergey Glukhov committed
7873
	re_eprint(err), (int)len, (int)sizeof(erbuf), erbuf);
7874 7875 7876
  }
}

7877
void init_re(void)
7878
{
7879 7880 7881 7882
  /*
    Filter for queries that can be run using the
    MySQL Prepared Statements C API
  */
7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896
  const char *ps_re_str =
    "^("
    "[[:space:]]*REPLACE[[:space:]]|"
    "[[:space:]]*INSERT[[:space:]]|"
    "[[:space:]]*UPDATE[[:space:]]|"
    "[[:space:]]*DELETE[[:space:]]|"
    "[[:space:]]*SELECT[[:space:]]|"
    "[[:space:]]*CREATE[[:space:]]+TABLE[[:space:]]|"
    "[[:space:]]*DO[[:space:]]|"
    "[[:space:]]*SET[[:space:]]+OPTION[[:space:]]|"
    "[[:space:]]*DELETE[[:space:]]+MULTI[[:space:]]|"
    "[[:space:]]*UPDATE[[:space:]]+MULTI[[:space:]]|"
    "[[:space:]]*INSERT[[:space:]]+SELECT[[:space:]])";

7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912
  /*
    Filter for queries that can be run using the
    Stored procedures
  */
  const char *sp_re_str =ps_re_str;

  /*
    Filter for queries that can be run as views
  */
  const char *view_re_str =
    "^("
    "[[:space:]]*SELECT[[:space:]])";

  init_re_comp(&ps_re, ps_re_str);
  init_re_comp(&sp_re, sp_re_str);
  init_re_comp(&view_re, view_re_str);
7913 7914 7915
}


7916
int match_re(my_regex_t *re, char *str)
7917
{
7918
  int err= my_regexec(re, str, (size_t)0, NULL, 0);
7919 7920 7921 7922 7923

  if (err == 0)
    return 1;
  else if (err == REG_NOMATCH)
    return 0;
7924

7925 7926
  {
    char erbuf[100];
7927 7928
    int len= my_regerror(err, re, erbuf, sizeof(erbuf));
    die("error %s, %d/%d `%s'\n",
Sergey Glukhov's avatar
Sergey Glukhov committed
7929
	re_eprint(err), (int)len, (int)sizeof(erbuf), erbuf);
7930
  }
7931
  return 0;
7932 7933
}

7934
void free_re(void)
7935
{
kent@mysql.com's avatar
kent@mysql.com committed
7936
  my_regfree(&ps_re);
7937 7938 7939
  my_regfree(&sp_re);
  my_regfree(&view_re);
  my_regex_end();
7940 7941 7942 7943
}

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

7944
void get_command_type(struct st_command* command)
7945
{
7946 7947
  char save;
  uint type;
7948
  DBUG_ENTER("get_command_type");
monty@mysql.com's avatar
monty@mysql.com committed
7949

7950
  if (*command->query == '}')
7951
  {
7952
    command->type = Q_END_BLOCK;
monty@mysql.com's avatar
monty@mysql.com committed
7953
    DBUG_VOID_RETURN;
7954 7955
  }

7956 7957 7958 7959
  save= command->query[command->first_word_len];
  command->query[command->first_word_len]= 0;
  type= find_type(command->query, &command_typelib, 1+2);
  command->query[command->first_word_len]= save;
7960
  if (type > 0)
7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973
  {
    command->type=(enum enum_commands) type;		/* Found command */

    /*
      Look for case where "query" was explicitly specified to
      force command being sent to server
    */
    if (type == Q_QUERY)
    {
      /* Skip the "query" part */
      command->query= command->first_argument;
    }
  }
7974
  else
7975
  {
7976 7977 7978 7979 7980 7981 7982 7983 7984
    /* No mysqltest command matched */

    if (command->type != Q_COMMENT_WITH_COMMAND)
    {
      /* A query that will sent to mysqld */
      command->type= Q_QUERY;
    }
    else
    {
7985 7986 7987 7988
      /* -- "comment" that didn't contain a mysqltest command */
      die("Found line beginning with --  that didn't contain "\
          "a valid mysqltest command, check your syntax or "\
          "use # if you intended to write a comment");
7989
    }
7990
  }
7991 7992 7993 7994 7995 7996

  /* Set expected error on command */
  memcpy(&command->expected_errors, &saved_expected_errors,
         sizeof(saved_expected_errors));
  DBUG_PRINT("info", ("There are %d expected errors",
                      command->expected_errors.count));
monty@mysql.com's avatar
monty@mysql.com committed
7997
  DBUG_VOID_RETURN;
7998
}
7999

monty@mysql.com's avatar
monty@mysql.com committed
8000

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
8001

8002 8003
/*
  Record how many milliseconds it took to execute the test file
8004
  up until the current line and write it to .progress file
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
8005

8006
*/
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
8007

8008 8009
void mark_progress(struct st_command* command __attribute__((unused)),
                   int line)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
8010
{
8011 8012 8013
  static ulonglong progress_start= 0; // < Beware
  DYNAMIC_STRING ds_progress;

8014 8015 8016 8017 8018
  char buf[32], *end;
  ulonglong timer= timer_now();
  if (!progress_start)
    progress_start= timer;
  timer-= progress_start;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
8019

8020 8021 8022
  if (init_dynamic_string(&ds_progress, "", 256, 256))
    die("Out of memory");

8023 8024 8025 8026
  /* Milliseconds since start */
  end= longlong2str(timer, buf, 10);
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));
  dynstr_append_mem(&ds_progress, "\t", 1);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
8027

8028 8029 8030 8031
  /* Parser line number */
  end= int10_to_str(line, buf, 10);
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));
  dynstr_append_mem(&ds_progress, "\t", 1);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
8032

8033 8034 8035
  /* Filename */
  dynstr_append(&ds_progress, cur_file->file_name);
  dynstr_append_mem(&ds_progress, ":", 1);
8036

8037 8038 8039 8040 8041 8042
  /* Line in file */
  end= int10_to_str(cur_file->lineno, buf, 10);
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));


  dynstr_append_mem(&ds_progress, "\n", 1);
8043

8044 8045 8046 8047
  progress_file.write(&ds_progress);

  dynstr_free(&ds_progress);

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
8048
}
8049

8050
#ifdef HAVE_STACKTRACE
8051

8052
static void dump_backtrace(void)
8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068
{
  struct st_connection *conn= cur_con;

  my_safe_print_str("read_command_buf", read_command_buf,
                    sizeof(read_command_buf));
  if (conn)
  {
    my_safe_print_str("conn->name", conn->name, conn->name_len);
#ifdef EMBEDDED_LIBRARY
    my_safe_print_str("conn->cur_query", conn->cur_query, conn->cur_query_len);
#endif
  }
  fputs("Attempting backtrace...\n", stderr);
  my_print_stacktrace(NULL, my_thread_stack_size);
}

8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081
#else

static void dump_backtrace(void)
{
  fputs("Backtrace not available.\n", stderr);
}

#endif

static sig_handler signal_handler(int sig)
{
  fprintf(stderr, "mysqltest got " SIGNAL_FMT "\n", sig);
  dump_backtrace();
Luis Soares's avatar
Luis Soares committed
8082 8083 8084 8085 8086 8087 8088

  fprintf(stderr, "Writing a core file...\n");
  fflush(stderr);
  my_write_core(sig);
#ifndef __WIN__
  exit(1);			// Shouldn't get here but just in case
#endif
8089 8090
}

8091 8092 8093 8094 8095 8096 8097
#ifdef __WIN__

LONG WINAPI exception_filter(EXCEPTION_POINTERS *exp)
{
  __try
  {
    my_set_exception_pointers(exp);
8098
    signal_handler(exp->ExceptionRecord->ExceptionCode);
8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134
  }
  __except(EXCEPTION_EXECUTE_HANDLER)
  {
    fputs("Got exception in exception handler!\n", stderr);
  }

  return EXCEPTION_CONTINUE_SEARCH;
}


static void init_signal_handling(void)
{
  UINT mode;

  /* Set output destination of messages to the standard error stream. */
  _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
  _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
  _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
  _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
  _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
  _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);

  /* Do not not display the a error message box. */
  mode= SetErrorMode(0) | SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX;
  SetErrorMode(mode);

  SetUnhandledExceptionFilter(exception_filter);
}

#else /* __WIN__ */

static void init_signal_handling(void)
{
  struct sigaction sa;
  DBUG_ENTER("init_signal_handling");

8135
#ifdef HAVE_STACKTRACE
8136
  my_init_stacktrace();
8137
#endif
8138 8139 8140 8141 8142

  sa.sa_flags = SA_RESETHAND | SA_NODEFER;
  sigemptyset(&sa.sa_mask);
  sigprocmask(SIG_SETMASK, &sa.sa_mask, NULL);

8143
  sa.sa_handler= signal_handler;
8144 8145 8146 8147 8148 8149 8150 8151

  sigaction(SIGSEGV, &sa, NULL);
  sigaction(SIGABRT, &sa, NULL);
#ifdef SIGBUS
  sigaction(SIGBUS, &sa, NULL);
#endif
  sigaction(SIGILL, &sa, NULL);
  sigaction(SIGFPE, &sa, NULL);
8152 8153

  DBUG_VOID_RETURN;
8154 8155 8156
}

#endif /* !__WIN__ */
8157

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
8158
int main(int argc, char **argv)
8159
{
8160
  struct st_command *command;
8161
  my_bool q_send_flag= 0, abort_flag= 0;
8162
  uint command_executed= 0, last_command_executed= 0;
8163
  char save_file[FN_REFLEN];
8164 8165
  MY_INIT(argv[0]);

8166 8167 8168
  save_file[0]= 0;
  TMPDIR[0]= 0;

8169 8170
  init_signal_handling();

8171 8172 8173
  /* Init expected errors */
  memset(&saved_expected_errors, 0, sizeof(saved_expected_errors));

8174 8175 8176 8177 8178 8179
#ifdef EMBEDDED_LIBRARY
  /* set appropriate stack for the 'query' threads */
  (void) pthread_attr_init(&cn_thd_attrib);
  pthread_attr_setstacksize(&cn_thd_attrib, DEFAULT_THREAD_STACK);
#endif /*EMBEDDED_LIBRARY*/

8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193 8194
  /* Init file stack */
  memset(file_stack, 0, sizeof(file_stack));
  file_stack_end=
    file_stack + (sizeof(file_stack)/sizeof(struct st_test_file)) - 1;
  cur_file= file_stack;

  /* Init block stack */
  memset(block_stack, 0, sizeof(block_stack));
  block_stack_end=
    block_stack + (sizeof(block_stack)/sizeof(struct st_block)) - 1;
  cur_block= block_stack;
  cur_block->ok= TRUE; /* Outer block should always be executed */
  cur_block->cmd= cmd_none;

  my_init_dynamic_array(&q_lines, sizeof(struct st_command*), 1024, 1024);
kent@mysql.com's avatar
kent@mysql.com committed
8195

Konstantin Osipov's avatar
Konstantin Osipov committed
8196 8197
  if (my_hash_init(&var_hash, charset_info,
                   1024, 0, 0, get_var_key, var_free, MYF(0)))
8198
    die("Variable hash initialization failed");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
8199

8200 8201 8202 8203 8204 8205 8206 8207
  var_set_string("MYSQL_SERVER_VERSION", MYSQL_SERVER_VERSION);
  var_set_string("MYSQL_SYSTEM_TYPE", SYSTEM_TYPE);
  var_set_string("MYSQL_MACHINE_TYPE", MACHINE_TYPE);
  if (sizeof(void *) == 8) {
    var_set_string("MYSQL_SYSTEM_ARCHITECTURE", "64");
  } else {
    var_set_string("MYSQL_SYSTEM_ARCHITECTURE", "32");
  }
8208

8209
  memset(&master_pos, 0, sizeof(master_pos));
8210

8211 8212 8213
  parser.current_line= parser.read_lines= 0;
  memset(&var_reg, 0, sizeof(var_reg));

8214
  init_builtin_echo();
8215
#ifdef __WIN__
8216
#ifndef USE_CYGWIN
8217
  is_windows= 1;
8218
#endif
8219 8220 8221
  init_tmp_sh_file();
  init_win_path_patterns();
#endif
8222

8223 8224
  init_dynamic_string(&ds_res, "", 2048, 2048);

8225
  parse_args(argc, argv);
8226

8227
  log_file.open(opt_logdir, result_file_name, ".log");
8228
  verbose_msg("Logging to '%s'.", log_file.file_name());
8229
  if (opt_mark_progress)
8230
  {
8231
    progress_file.open(opt_logdir, result_file_name, ".progress");
8232 8233
    verbose_msg("Tracing progress in '%s'.", progress_file.file_name());
  }
8234

8235 8236 8237 8238 8239 8240 8241
  /* Init connections, allocate 1 extra as buffer + 1 for default */
  connections= (struct st_connection*)
    my_malloc((opt_max_connections+2) * sizeof(struct st_connection),
              MYF(MY_WME | MY_ZEROFILL));
  connections_end= connections + opt_max_connections +1;
  next_con= connections + 1;
  
8242 8243 8244 8245 8246
  var_set_int("$PS_PROTOCOL", ps_protocol);
  var_set_int("$SP_PROTOCOL", sp_protocol);
  var_set_int("$VIEW_PROTOCOL", view_protocol);
  var_set_int("$CURSOR_PROTOCOL", cursor_protocol);

8247 8248
  DBUG_PRINT("info",("result_file: '%s'",
                     result_file_name ? result_file_name : ""));
8249 8250
  verbose_msg("Results saved in '%s'.", 
              result_file_name ? result_file_name : "");
8251 8252 8253
  if (mysql_server_init(embedded_server_arg_count,
			embedded_server_args,
			(char**) embedded_server_groups))
8254
    die("Can't initialize MySQL server");
8255
  server_initialized= 1;
8256
  if (cur_file == file_stack && cur_file->file == 0)
8257
  {
8258 8259
    cur_file->file= stdin;
    cur_file->file_name= my_strdup("<stdin>", MYF(MY_WME));
8260
    cur_file->lineno= 1;
8261
  }
8262
  var_set_string("MYSQLTEST_FILE", cur_file->file_name);
8263 8264 8265 8266 8267 8268 8269
  init_re();
  ps_protocol_enabled= ps_protocol;
  sp_protocol_enabled= sp_protocol;
  view_protocol_enabled= view_protocol;
  cursor_protocol_enabled= cursor_protocol;
  /* Cursor protcol implies ps protocol */
  if (cursor_protocol_enabled)
8270
    ps_protocol_enabled= 1;
8271

8272
  st_connection *con= connections;
8273 8274 8275
#ifdef EMBEDDED_LIBRARY
  init_connection_thd(con);
#endif /*EMBEDDED_LIBRARY*/
8276
  if (!( mysql_init(&con->mysql)))
8277
    die("Failed in mysql_init()");
8278 8279 8280
  if (opt_connect_timeout)
    mysql_options(&con->mysql, MYSQL_OPT_CONNECT_TIMEOUT,
                  (void *) &opt_connect_timeout);
8281
  if (opt_compress)
8282 8283 8284
    mysql_options(&con->mysql,MYSQL_OPT_COMPRESS,NullS);
  mysql_options(&con->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
  mysql_options(&con->mysql, MYSQL_SET_CHARSET_NAME,
8285 8286
                charset_info->csname);
  if (opt_charsets_dir)
8287
    mysql_options(&con->mysql, MYSQL_SET_CHARSET_DIR,
8288
                  opt_charsets_dir);
bar@mysql.com's avatar
bar@mysql.com committed
8289

8290 8291 8292
  if (opt_protocol)
    mysql_options(&con->mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);

Konstantin Osipov's avatar
Konstantin Osipov committed
8293
#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
8294

gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
8295
  if (opt_use_ssl)
8296
  {
8297
    mysql_ssl_set(&con->mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
8298
		  opt_ssl_capath, opt_ssl_cipher);
8299
#if MYSQL_VERSION_ID >= 50000
8300 8301
    /* Turn on ssl_verify_server_cert only if host is "localhost" */
    opt_ssl_verify_server_cert= opt_host && !strcmp(opt_host, "localhost");
8302
    mysql_options(&con->mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
8303 8304 8305
                  &opt_ssl_verify_server_cert);
#endif
  }
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
8306
#endif
8307

8308 8309 8310 8311 8312
#ifdef HAVE_SMEM
  if (shared_memory_base_name)
    mysql_options(&con->mysql,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name);
#endif

8313
  if (!(con->name = my_strdup("default", MYF(MY_WME))))
8314
    die("Out of memory");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
8315

8316
  safe_connect(&con->mysql, con->name, opt_host, opt_user, opt_pass,
8317
               opt_db, opt_port, unix_sock);
8318

8319 8320
  /* Use all time until exit if no explicit 'start_timer' */
  timer_start= timer_now();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
8321

8322 8323 8324 8325 8326
  /*
    Initialize $mysql_errno with -1, so we can
    - distinguish it from valid values ( >= 0 ) and
    - detect if there was never a command sent to the server
  */
8327 8328
  var_set_errno(-1);

8329
  set_current_connection(con);
8330

8331 8332 8333 8334 8335
  if (opt_include)
  {
    open_file(opt_include);
  }

8336
  verbose_msg("Start processing test commands from '%s' ...", cur_file->file_name);
8337
  while (!read_command(&command) && !abort_flag)
8338 8339
  {
    int current_line_inc = 1, processed = 0;
8340 8341
    if (command->type == Q_UNKNOWN || command->type == Q_COMMENT_WITH_COMMAND)
      get_command_type(command);
8342 8343 8344 8345 8346

    if (parsing_disabled &&
        command->type != Q_ENABLE_PARSING &&
        command->type != Q_DISABLE_PARSING)
    {
8347
      /* Parsing is disabled, silently convert this line to a comment */
8348 8349 8350
      command->type= Q_COMMENT;
    }

8351 8352 8353 8354
    /* (Re-)set abort_on_error for this command */
    command->abort_on_error= (command->expected_errors.count == 0 &&
                              abort_on_error);
    
8355 8356
    /* delimiter needs to be executed so we can continue to parse */
    my_bool ok_to_do= cur_block->ok || command->type == Q_DELIMITER;
8357 8358 8359 8360 8361 8362 8363 8364
    /*
      Some commands need to be "done" the first time if they may get
      re-iterated over in a true context. This can only happen if there's 
      a while loop at some level above the current block.
    */
    if (!ok_to_do)
    {
      if (command->type == Q_SOURCE ||
8365
          command->type == Q_ERROR ||
8366 8367 8368 8369 8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381
          command->type == Q_WRITE_FILE ||
          command->type == Q_APPEND_FILE ||
	  command->type == Q_PERL)
      {
	for (struct st_block *stb= cur_block-1; stb >= block_stack; stb--)
	{
	  if (stb->cmd == cmd_while)
	  {
	    ok_to_do= 1;
	    break;
	  }
	}
      }
    }

    if (ok_to_do)
8382
    {
8383
      command->last_argument= command->first_argument;
8384
      processed = 1;
8385 8386 8387 8388 8389
      switch (command->type) {
      case Q_CONNECT:
        do_connect(command);
        break;
      case Q_CONNECTION: select_connection(command); break;
8390
      case Q_DISCONNECT:
8391
      case Q_DIRTY_CLOSE:
8392
	do_close_connection(command); break;
8393
      case Q_ENABLE_QUERY_LOG:   disable_query_log=0; break;
8394
      case Q_DISABLE_QUERY_LOG:  disable_query_log=1; break;
8395 8396
      case Q_ENABLE_ABORT_ON_ERROR:  abort_on_error=1; break;
      case Q_DISABLE_ABORT_ON_ERROR: abort_on_error=0; break;
8397 8398
      case Q_ENABLE_RESULT_LOG:  disable_result_log=0; break;
      case Q_DISABLE_RESULT_LOG: disable_result_log=1; break;
8399 8400
      case Q_ENABLE_CONNECT_LOG:   disable_connect_log=0; break;
      case Q_DISABLE_CONNECT_LOG:  disable_connect_log=1; break;
8401 8402
      case Q_ENABLE_WARNINGS:    disable_warnings=0; break;
      case Q_DISABLE_WARNINGS:   disable_warnings=1; break;
8403 8404
      case Q_ENABLE_INFO:        disable_info=0; break;
      case Q_DISABLE_INFO:       disable_info=1; break;
8405
      case Q_ENABLE_METADATA:    display_metadata=1; break;
8406
      case Q_DISABLE_METADATA:   display_metadata=0; break;
8407 8408 8409 8410 8411 8412 8413 8414 8415
      case Q_SOURCE: do_source(command); break;
      case Q_SLEEP: do_sleep(command, 0); break;
      case Q_REAL_SLEEP: do_sleep(command, 1); break;
      case Q_WAIT_FOR_SLAVE_TO_STOP: do_wait_for_slave_to_stop(command); break;
      case Q_INC: do_modify_var(command, DO_INC); break;
      case Q_DEC: do_modify_var(command, DO_DEC); break;
      case Q_ECHO: do_echo(command); command_executed++; break;
      case Q_SYSTEM: do_system(command); break;
      case Q_REMOVE_FILE: do_remove_file(command); break;
8416
      case Q_REMOVE_FILES_WILDCARD: do_remove_files_wildcard(command); break;
8417 8418
      case Q_MKDIR: do_mkdir(command); break;
      case Q_RMDIR: do_rmdir(command); break;
8419 8420 8421 8422 8423 8424 8425
      case Q_LIST_FILES: do_list_files(command); break;
      case Q_LIST_FILES_WRITE_FILE:
        do_list_files_write_file_command(command, FALSE);
        break;
      case Q_LIST_FILES_APPEND_FILE:
        do_list_files_write_file_command(command, TRUE);
        break;
8426 8427
      case Q_FILE_EXIST: do_file_exist(command); break;
      case Q_WRITE_FILE: do_write_file(command); break;
8428
      case Q_APPEND_FILE: do_append_file(command); break;
8429
      case Q_DIFF_FILES: do_diff_files(command); break;
8430
      case Q_SEND_QUIT: do_send_quit(command); break;
8431
      case Q_CHANGE_USER: do_change_user(command); break;
8432
      case Q_CAT_FILE: do_cat_file(command); break;
8433
      case Q_COPY_FILE: do_copy_file(command); break;
8434
      case Q_MOVE_FILE: do_move_file(command); break;
8435
      case Q_CHMOD_FILE: do_chmod_file(command); break;
8436
      case Q_PERL: do_perl(command); break;
8437
      case Q_RESULT_FORMAT_VERSION: do_result_format_version(command); break;
8438
      case Q_DELIMITER:
8439
        do_delimiter(command);
8440
	break;
8441 8442 8443 8444 8445 8446
      case Q_DISPLAY_VERTICAL_RESULTS:
        display_result_vertically= TRUE;
        break;
      case Q_DISPLAY_HORIZONTAL_RESULTS:
	display_result_vertically= FALSE;
        break;
8447
      case Q_SORTED_RESULT:
8448 8449 8450 8451 8452 8453
        /*
          Turn on sorting of result set, will be reset after next
          command
        */
	display_result_sorted= TRUE;
        break;
8454 8455 8456 8457 8458 8459 8460
      case Q_LOWERCASE:
        /*
          Turn on lowercasing of result, will be reset after next
          command
        */
        display_result_lower= TRUE;
        break;
8461
      case Q_LET: do_let(command); break;
8462
      case Q_EVAL_RESULT:
8463
        die("'eval_result' command  is deprecated");
8464
      case Q_EVAL:
8465 8466
      case Q_QUERY_VERTICAL:
      case Q_QUERY_HORIZONTAL:
8467
	if (command->query == command->query_buf)
monty@mysql.com's avatar
monty@mysql.com committed
8468
        {
8469
          /* Skip the first part of command, i.e query_xxx */
8470 8471
	  command->query= command->first_argument;
          command->first_word_len= 0;
monty@mysql.com's avatar
monty@mysql.com committed
8472
        }
8473
	/* fall through */
8474
      case Q_QUERY:
8475
      case Q_REAP:
8476
      {
8477 8478 8479 8480
	my_bool old_display_result_vertically= display_result_vertically;
        /* Default is full query, both reap and send  */
        int flags= QUERY_REAP_FLAG | QUERY_SEND_FLAG;

8481 8482 8483 8484 8485 8486 8487 8488 8489 8490
        if (q_send_flag)
        {
          /* Last command was an empty 'send' */
          flags= QUERY_SEND_FLAG;
          q_send_flag= 0;
        }
        else if (command->type == Q_REAP)
        {
          flags= QUERY_REAP_FLAG;
        }
8491 8492

        /* Check for special property for this query */
8493
        display_result_vertically|= (command->type == Q_QUERY_VERTICAL);
8494

8495
	if (save_file[0])
8496
	{
8497
	  strmake(command->require_file, save_file, sizeof(save_file) - 1);
8498
	  save_file[0]= 0;
8499
	}
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
8500
	run_query(cur_con, command, flags);
8501 8502
	command_executed++;
        command->last_argument= command->end;
8503 8504 8505 8506

        /* Restore settings */
	display_result_vertically= old_display_result_vertically;

8507
	break;
8508
      }
8509
      case Q_SEND:
8510
      case Q_SEND_EVAL:
8511 8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524
        if (!*command->first_argument)
        {
          /*
            This is a send without arguments, it indicates that _next_ query
            should be send only
          */
          q_send_flag= 1;
          break;
        }

        /* Remove "send" if this is first iteration */
	if (command->query == command->query_buf)
	  command->query= command->first_argument;

8525
	/*
8526 8527 8528
	  run_query() can execute a query partially, depending on the flags.
	  QUERY_SEND_FLAG flag without QUERY_REAP_FLAG tells it to just send
          the query and read the result some time later when reap instruction
8529
	  is given on this connection.
8530
        */
8531
	run_query(cur_con, command, QUERY_SEND_FLAG);
8532 8533
	command_executed++;
        command->last_argument= command->end;
8534
	break;
8535 8536
      case Q_REQUIRE:
	do_get_file_name(command, save_file, sizeof(save_file));
8537
	break;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
8538
      case Q_ERROR:
8539
        do_get_errcodes(command);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
8540
	break;
8541
      case Q_REPLACE:
8542
	do_get_replace(command);
8543
	break;
8544 8545 8546
      case Q_REPLACE_REGEX:
        do_get_replace_regex(command);
        break;
8547
      case Q_REPLACE_COLUMN:
8548
	do_get_replace_column(command);
8549
	break;
8550
      case Q_SAVE_MASTER_POS: do_save_master_pos(); break;
8551
      case Q_SYNC_WITH_MASTER: do_sync_with_master(command); break;
8552 8553 8554
      case Q_SYNC_SLAVE_WITH_MASTER:
      {
	do_save_master_pos();
8555 8556
	if (*command->first_argument)
	  select_connection(command);
8557
	else
8558
	  select_connection_name("slave");
8559
	do_sync_with_master2(command, 0);
8560 8561
	break;
      }
8562 8563
      case Q_COMMENT:
      {
8564
        command->last_argument= command->end;
8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580

        /* Don't output comments in v1 */
        if (opt_result_format_version == 1)
          break;

        /* Don't output comments if query logging is off */
        if (disable_query_log)
          break;

        /* Write comment's with two starting #'s to result file */
        const char* p= command->query;
        if (p && *p == '#' && *(p+1) == '#')
        {
          dynstr_append_mem(&ds_res, command->query, command->query_len);
          dynstr_append(&ds_res, "\n");
        }
8581
	break;
8582 8583 8584 8585 8586 8587 8588 8589 8590 8591 8592 8593
      }
      case Q_EMPTY_LINE:
        /* Don't output newline in v1 */
        if (opt_result_format_version == 1)
          break;

        /* Don't output newline if query logging is off */
        if (disable_query_log)
          break;

        dynstr_append(&ds_res, "\n");
        break;
8594
      case Q_PING:
8595 8596
        handle_command_error(command, mysql_ping(&cur_con->mysql));
        break;
8597
      case Q_SEND_SHUTDOWN:
8598 8599 8600 8601
        handle_command_error(command,
                             mysql_shutdown(&cur_con->mysql,
                                            SHUTDOWN_DEFAULT));
        break;
8602 8603
      case Q_SHUTDOWN_SERVER:
        do_shutdown_server(command);
8604
        break;
8605
      case Q_EXEC:
8606 8607
	do_exec(command);
	command_executed++;
8608
	break;
kent@mysql.com's avatar
kent@mysql.com committed
8609 8610 8611 8612 8613 8614 8615 8616
      case Q_START_TIMER:
	/* Overwrite possible earlier start of timer */
	timer_start= timer_now();
	break;
      case Q_END_TIMER:
	/* End timer before ending mysqltest */
	timer_output();
	break;
8617
      case Q_CHARACTER_SET:
8618
	do_set_charset(command);
kent@mysql.com's avatar
kent@mysql.com committed
8619
	break;
8620 8621
      case Q_DISABLE_PS_PROTOCOL:
        ps_protocol_enabled= 0;
8622 8623
        /* Close any open statements */
        close_statements();
8624 8625 8626 8627
        break;
      case Q_ENABLE_PS_PROTOCOL:
        ps_protocol_enabled= ps_protocol;
        break;
8628
      case Q_DISABLE_RECONNECT:
8629
        set_reconnect(&cur_con->mysql, 0);
8630 8631
        break;
      case Q_ENABLE_RECONNECT:
8632
        set_reconnect(&cur_con->mysql, 1);
8633 8634
        /* Close any open statements - no reconnect, need new prepare */
        close_statements();
8635 8636 8637 8638 8639 8640
        break;
      case Q_DISABLE_PARSING:
        if (parsing_disabled == 0)
          parsing_disabled= 1;
        else
          die("Parsing is already disabled");
8641
        break;
8642 8643 8644 8645 8646 8647 8648 8649 8650 8651 8652
      case Q_ENABLE_PARSING:
        /*
          Ensure we don't get parsing_disabled < 0 as this would accidentally
          disable code we don't want to have disabled
        */
        if (parsing_disabled == 1)
          parsing_disabled= 0;
        else
          die("Parsing is already enabled");
        break;
      case Q_DIE:
8653
        /* Abort test with error code and error message */
8654 8655
        die("%s", command->first_argument);
        break;
8656 8657 8658 8659
      case Q_EXIT:
        /* Stop processing any more commands */
        abort_flag= 1;
        break;
8660 8661 8662
      case Q_SKIP:
        abort_not_supported_test("%s", command->first_argument);
        break;
8663

8664 8665 8666 8667
      case Q_RESULT:
        die("result, deprecated command");
        break;

8668 8669
      default:
        processed= 0;
8670
        break;
8671 8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683 8684 8685 8686
      }
    }

    if (!processed)
    {
      current_line_inc= 0;
      switch (command->type) {
      case Q_WHILE: do_block(cmd_while, command); break;
      case Q_IF: do_block(cmd_if, command); break;
      case Q_END_BLOCK: do_done(command); break;
      default: current_line_inc = 1; break;
      }
    }
    else
      check_eol_junk(command->last_argument);

8687 8688
    if (command->type != Q_ERROR &&
        command->type != Q_COMMENT)
8689 8690
    {
      /*
8691
        As soon as any non "error" command or comment has been executed,
8692 8693 8694 8695 8696
        the array with expected errors should be cleared
      */
      memset(&saved_expected_errors, 0, sizeof(saved_expected_errors));
    }

8697
    if (command_executed != last_command_executed || command->used_replace)
8698 8699 8700 8701 8702 8703
    {
      /*
        As soon as any command has been executed,
        the replace structures should be cleared
      */
      free_all_replace();
8704

8705
      /* Also reset "sorted_result" and "lowercase"*/
8706
      display_result_sorted= FALSE;
8707
      display_result_lower= FALSE;
8708 8709 8710 8711 8712 8713
    }
    last_command_executed= command_executed;

    parser.current_line += current_line_inc;
    if ( opt_mark_progress )
      mark_progress(command, parser.current_line);
8714

Serge Kozlov's avatar
Serge Kozlov committed
8715
    /* Write result from command to log file immediately */
8716
    log_file.write(&ds_res);
Serge Kozlov's avatar
Serge Kozlov committed
8717
    log_file.flush();
8718
    dynstr_set(&ds_res, 0);
8719 8720
  }

8721 8722
  log_file.close();

8723
  start_lineno= 0;
8724
  verbose_msg("... Done processing test commands.");
8725 8726 8727 8728

  if (parsing_disabled)
    die("Test ended with parsing disabled");

8729 8730
  my_bool empty_result= FALSE;
  
8731 8732 8733
  /*
    The whole test has been executed _sucessfully_.
    Time to compare result or save it to record file.
8734
    The entire output from test is in the log file
8735
  */
8736
  if (log_file.bytes_written())
8737
  {
8738
    if (result_file_name)
8739
    {
8740 8741
      /* A result file has been specified */

8742 8743
      if (record)
      {
8744 8745 8746 8747 8748 8749 8750
	/* Recording */

        /* save a copy of the log to result file */
        if (my_copy(log_file.file_name(), result_file_name, MYF(0)) != 0)
          die("Failed to copy '%s' to '%s', errno: %d",
              log_file.file_name(), result_file_name, errno);

8751 8752 8753
      }
      else
      {
8754 8755
	/* Check that the output from test is equal to result file */
	check_result();
8756 8757 8758 8759 8760
      }
    }
  }
  else
  {
8761 8762 8763 8764 8765 8766 8767 8768 8769 8770
    /* Empty output is an error *unless* we also have an empty result file */
    if (! result_file_name || record ||
        compare_files (log_file.file_name(), result_file_name))
    {
      die("The test didn't produce any output");
    }
    else 
    {
      empty_result= TRUE;  /* Meaning empty was expected */
    }
8771 8772
  }

8773 8774
  if (!command_executed && result_file_name && !empty_result)
    die("No queries executed but non-empty result file found!");
8775

8776
  verbose_msg("Test has succeeded!");
8777 8778
  timer_output();
  /* Yes, if we got this far the test has suceeded! Sakila smiles */
8779 8780
  cleanup_and_exit(0);
  return 0; /* Keep compiler happy too */
8781 8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811 8812 8813 8814 8815 8816 8817 8818 8819 8820
}


/*
  A primitive timer that give results in milliseconds if the
  --timer-file=<filename> is given. The timer result is written
  to that file when the result is available. To not confuse
  mysql-test-run with an old obsolete result, we remove the file
  before executing any commands. The time we measure is

  - If no explicit 'start_timer' or 'end_timer' is given in the
  test case, the timer measure how long we execute in mysqltest.

  - If only 'start_timer' is given we measure how long we execute
  from that point until we terminate mysqltest.

  - If only 'end_timer' is given we measure how long we execute
  from that we enter mysqltest to the 'end_timer' is command is
  executed.

  - If both 'start_timer' and 'end_timer' are given we measure
  the time between executing the two commands.
*/

void timer_output(void)
{
  if (timer_file)
  {
    char buf[32], *end;
    ulonglong timer= timer_now() - timer_start;
    end= longlong2str(timer, buf, 10);
    str_to_file(timer_file,buf, (int) (end-buf));
    /* Timer has been written to the file, don't use it anymore */
    timer_file= 0;
  }
}


ulonglong timer_now(void)
{
8821
  return my_micro_time() / 1000;
8822 8823 8824 8825 8826 8827 8828 8829 8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843
}


/*
  Get arguments for replace_columns. The syntax is:
  replace-column column_number to_string [column_number to_string ...]
  Where each argument may be quoted with ' or "
  A argument may also be a variable, in which case the value of the
  variable is replaced.
*/

void do_get_replace_column(struct st_command *command)
{
  char *from= command->first_argument;
  char *buff, *start;
  DBUG_ENTER("get_replace_columns");

  free_replace_column();
  if (!*from)
    die("Missing argument in %s", command->query);

  /* Allocate a buffer for results */
8844
  start= buff= (char*)my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
8845 8846 8847 8848 8849 8850 8851 8852 8853 8854
  while (*from)
  {
    char *to;
    uint column_number;
    to= get_string(&buff, &from, command);
    if (!(column_number= atoi(to)) || column_number > MAX_COLUMNS)
      die("Wrong column number to replace_column in '%s'", command->query);
    if (!*from)
      die("Wrong number of arguments to replace_column in '%s'", command->query);
    to= get_string(&buff, &from, command);
8855
    my_free(replace_column[column_number-1]);
8856 8857 8858
    replace_column[column_number-1]= my_strdup(to, MYF(MY_WME | MY_FAE));
    set_if_bigger(max_replace_column, column_number);
  }
8859
  my_free(start);
8860
  command->last_argument= command->end;
8861 8862

  DBUG_VOID_RETURN;
8863 8864 8865 8866 8867 8868 8869 8870 8871 8872
}


void free_replace_column()
{
  uint i;
  for (i=0 ; i < max_replace_column ; i++)
  {
    if (replace_column[i])
    {
8873
      my_free(replace_column[i]);
8874 8875 8876 8877 8878 8879 8880 8881 8882 8883 8884 8885 8886 8887 8888 8889
      replace_column[i]= 0;
    }
  }
  max_replace_column= 0;
}


/****************************************************************************/
/*
  Replace functions
*/

/* Definitions for replace result */

typedef struct st_pointer_array {		/* when using array-strings */
  TYPELIB typelib;				/* Pointer to strings */
8890
  uchar	*str;					/* Strings is here */
8891
  uint8 *flag;					/* Flag about each var. */
8892 8893 8894 8895
  uint	array_allocs,max_count,length,max_length;
} POINTER_ARRAY;

struct st_replace;
8896 8897 8898
struct st_replace *init_replace(char * *from, char * *to, uint count,
				char * word_end_chars);
int insert_pointer_name(reg1 POINTER_ARRAY *pa,char * name);
8899 8900 8901 8902 8903 8904 8905 8906 8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918 8919 8920 8921 8922 8923 8924 8925 8926 8927
void replace_strings_append(struct st_replace *rep, DYNAMIC_STRING* ds,
                            const char *from, int len);
void free_pointer_array(POINTER_ARRAY *pa);

struct st_replace *glob_replace;

/*
  Get arguments for replace. The syntax is:
  replace from to [from to ...]
  Where each argument may be quoted with ' or "
  A argument may also be a variable, in which case the value of the
  variable is replaced.
*/

void do_get_replace(struct st_command *command)
{
  uint i;
  char *from= command->first_argument;
  char *buff, *start;
  char word_end_chars[256], *pos;
  POINTER_ARRAY to_array, from_array;
  DBUG_ENTER("get_replace");

  free_replace();

  bzero((char*) &to_array,sizeof(to_array));
  bzero((char*) &from_array,sizeof(from_array));
  if (!*from)
    die("Missing argument in %s", command->query);
8928
  start= buff= (char*)my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
8929 8930 8931 8932 8933 8934 8935
  while (*from)
  {
    char *to= buff;
    to= get_string(&buff, &from, command);
    if (!*from)
      die("Wrong number of arguments to replace_result in '%s'",
          command->query);
msvensson@pilot.mysql.com's avatar
msvensson@pilot.mysql.com committed
8936 8937 8938
#ifdef __WIN__
    fix_win_paths(to, from - to);
#endif
8939 8940 8941 8942 8943 8944 8945 8946 8947 8948 8949 8950 8951 8952 8953
    insert_pointer_name(&from_array,to);
    to= get_string(&buff, &from, command);
    insert_pointer_name(&to_array,to);
  }
  for (i= 1,pos= word_end_chars ; i < 256 ; i++)
    if (my_isspace(charset_info,i))
      *pos++= i;
  *pos=0;					/* End pointer */
  if (!(glob_replace= init_replace((char**) from_array.typelib.type_names,
				  (char**) to_array.typelib.type_names,
				  (uint) from_array.typelib.count,
				  word_end_chars)))
    die("Can't initialize replace from '%s'", command->query);
  free_pointer_array(&from_array);
  free_pointer_array(&to_array);
8954
  my_free(start);
8955 8956 8957 8958
  command->last_argument= command->end;
  DBUG_VOID_RETURN;
}

8959

8960 8961 8962
void free_replace()
{
  DBUG_ENTER("free_replace");
8963 8964
  my_free(glob_replace);
  glob_replace= NULL;
8965 8966
  DBUG_VOID_RETURN;
}
8967

8968 8969

typedef struct st_replace {
8970
  my_bool found;
8971 8972 8973 8974
  struct st_replace *next[256];
} REPLACE;

typedef struct st_replace_found {
8975
  my_bool found;
8976 8977 8978 8979 8980 8981 8982
  char *replace_string;
  uint to_offset;
  int from_offset;
} REPLACE_STRING;


void replace_strings_append(REPLACE *rep, DYNAMIC_STRING* ds,
8983 8984
                            const char *str,
                            int len __attribute__((unused)))
8985 8986 8987 8988 8989 8990 8991 8992 8993 8994 8995 8996 8997 8998 8999 9000 9001
{
  reg1 REPLACE *rep_pos;
  reg2 REPLACE_STRING *rep_str;
  const char *start, *from;
  DBUG_ENTER("replace_strings_append");

  start= from= str;
  rep_pos=rep+1;
  for (;;)
  {
    /* Loop through states */
    DBUG_PRINT("info", ("Looping through states"));
    while (!rep_pos->found)
      rep_pos= rep_pos->next[(uchar) *from++];

    /* Does this state contain a string to be replaced */
    if (!(rep_str = ((REPLACE_STRING*) rep_pos))->replace_string)
9002
    {
9003 9004 9005 9006
      /* No match found */
      dynstr_append_mem(ds, start, from - start - 1);
      DBUG_PRINT("exit", ("Found no more string to replace, appended: %s", start));
      DBUG_VOID_RETURN;
9007 9008
    }

9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021
    /* Found a string that needs to be replaced */
    DBUG_PRINT("info", ("found: %d, to_offset: %d, from_offset: %d, string: %s",
                        rep_str->found, rep_str->to_offset,
                        rep_str->from_offset, rep_str->replace_string));

    /* Append part of original string before replace string */
    dynstr_append_mem(ds, start, (from - rep_str->to_offset) - start);

    /* Append replace string */
    dynstr_append_mem(ds, rep_str->replace_string,
                      strlen(rep_str->replace_string));

    if (!*(from-=rep_str->from_offset) && rep_pos->found != 2)
9022
    {
9023 9024 9025
      /* End of from string */
      DBUG_PRINT("exit", ("Found end of from string"));
      DBUG_VOID_RETURN;
9026
    }
9027 9028 9029
    DBUG_ASSERT(from <= str+len);
    start= from;
    rep_pos=rep;
9030
  }
9031
}
9032

9033

9034 9035 9036 9037 9038 9039 9040 9041 9042 9043 9044 9045 9046 9047 9048 9049 9050 9051 9052 9053 9054 9055 9056 9057 9058 9059 9060 9061 9062 9063 9064 9065 9066 9067 9068 9069 9070 9071 9072 9073 9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087 9088 9089 9090 9091 9092 9093 9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104 9105 9106 9107 9108 9109 9110 9111 9112 9113 9114 9115 9116 9117 9118 9119 9120 9121 9122 9123 9124 9125 9126 9127 9128 9129
/*
  Regex replace  functions
*/


/* Stores regex substitutions */

struct st_regex
{
  char* pattern; /* Pattern to be replaced */
  char* replace; /* String or expression to replace the pattern with */
  int icase; /* true if the match is case insensitive */
};

struct st_replace_regex
{
  DYNAMIC_ARRAY regex_arr; /* stores a list of st_regex subsitutions */

  /*
    Temporary storage areas for substitutions. To reduce unnessary copying
    and memory freeing/allocation, we pre-allocate two buffers, and alternate
    their use, one for input/one for output, the roles changing on the next
    st_regex substition. At the end of substitutions  buf points to the
    one containing the final result.
  */
  char* buf;
  char* even_buf;
  char* odd_buf;
  int even_buf_len;
  int odd_buf_len;
};

struct st_replace_regex *glob_replace_regex= 0;

int reg_replace(char** buf_p, int* buf_len_p, char *pattern, char *replace,
                char *string, int icase);



/*
  Finds the next (non-escaped) '/' in the expression.
  (If the character '/' is needed, it can be escaped using '\'.)
*/

#define PARSE_REGEX_ARG                         \
  while (p < expr_end)                          \
  {                                             \
    char c= *p;                                 \
    if (c == '/')                               \
    {                                           \
      if (last_c == '\\')                       \
      {                                         \
        buf_p[-1]= '/';                         \
      }                                         \
      else                                      \
      {                                         \
        *buf_p++ = 0;                           \
        break;                                  \
      }                                         \
    }                                           \
    else                                        \
      *buf_p++ = c;                             \
                                                \
    last_c= c;                                  \
    p++;                                        \
  }                                             \
                                                \
/*
  Initializes the regular substitution expression to be used in the
  result output of test.

  Returns: st_replace_regex struct with pairs of substitutions
*/

struct st_replace_regex* init_replace_regex(char* expr)
{
  struct st_replace_regex* res;
  char* buf,*expr_end;
  char* p;
  char* buf_p;
  uint expr_len= strlen(expr);
  char last_c = 0;
  struct st_regex reg;

  /* my_malloc() will die on fail with MY_FAE */
  res=(struct st_replace_regex*)my_malloc(
                                          sizeof(*res)+expr_len ,MYF(MY_FAE+MY_WME));
  my_init_dynamic_array(&res->regex_arr,sizeof(struct st_regex),128,128);

  buf= (char*)res + sizeof(*res);
  expr_end= expr + expr_len;
  p= expr;
  buf_p= buf;

  /* for each regexp substitution statement */
  while (p < expr_end)
9130
  {
9131 9132 9133
    bzero(&reg,sizeof(reg));
    /* find the start of the statement */
    while (p < expr_end)
9134
    {
9135 9136 9137
      if (*p == '/')
        break;
      p++;
9138
    }
9139 9140

    if (p == expr_end || ++p == expr_end)
9141
    {
9142 9143 9144 9145
      if (res->regex_arr.elements)
        break;
      else
        goto err;
9146
    }
9147 9148
    /* we found the start */
    reg.pattern= buf_p;
9149

9150 9151
    /* Find first argument -- pattern string to be removed */
    PARSE_REGEX_ARG
9152

9153 9154 9155 9156 9157 9158 9159 9160 9161 9162 9163 9164 9165 9166 9167 9168 9169 9170 9171 9172
      if (p == expr_end || ++p == expr_end)
        goto err;

    /* buf_p now points to the replacement pattern terminated with \0 */
    reg.replace= buf_p;

    /* Find second argument -- replace string to replace pattern */
    PARSE_REGEX_ARG

      if (p == expr_end)
        goto err;

    /* skip the ending '/' in the statement */
    p++;

    /* Check if we should do matching case insensitive */
    if (p < expr_end && *p == 'i')
      reg.icase= 1;

    /* done parsing the statement, now place it in regex_arr */
9173
    if (insert_dynamic(&res->regex_arr,(uchar*) &reg))
9174
      die("Out of memory");
9175
  }
9176 9177 9178 9179 9180 9181
  res->odd_buf_len= res->even_buf_len= 8192;
  res->even_buf= (char*)my_malloc(res->even_buf_len,MYF(MY_WME+MY_FAE));
  res->odd_buf= (char*)my_malloc(res->odd_buf_len,MYF(MY_WME+MY_FAE));
  res->buf= res->even_buf;

  return res;
9182

9183
err:
9184
  my_free(res);
9185 9186 9187
  die("Error parsing replace_regex \"%s\"", expr);
  return 0;
}
9188

9189
/*
9190 9191 9192 9193 9194 9195 9196 9197 9198 9199 9200 9201 9202 9203 9204 9205
  Execute all substitutions on val.

  Returns: true if substituition was made, false otherwise
  Side-effect: Sets r->buf to be the buffer with all substitutions done.

  IN:
  struct st_replace_regex* r
  char* val
  Out:
  struct st_replace_regex* r
  r->buf points at the resulting buffer
  r->even_buf and r->odd_buf might have been reallocated
  r->even_buf_len and r->odd_buf_len might have been changed

  TODO:  at some point figure out if there is a way to do everything
  in one pass
9206 9207
*/

9208
int multi_reg_replace(struct st_replace_regex* r,char* val)
9209
{
9210 9211 9212
  uint i;
  char* in_buf, *out_buf;
  int* buf_len_p;
9213

9214 9215 9216 9217
  in_buf= val;
  out_buf= r->even_buf;
  buf_len_p= &r->even_buf_len;
  r->buf= 0;
9218

9219 9220
  /* For each substitution, do the replace */
  for (i= 0; i < r->regex_arr.elements; i++)
9221
  {
9222 9223 9224
    struct st_regex re;
    char* save_out_buf= out_buf;

9225
    get_dynamic(&r->regex_arr,(uchar*)&re,i);
9226 9227 9228

    if (!reg_replace(&out_buf, buf_len_p, re.pattern, re.replace,
                     in_buf, re.icase))
9229
    {
9230 9231 9232 9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244 9245 9246
      /* if the buffer has been reallocated, make adjustements */
      if (save_out_buf != out_buf)
      {
        if (save_out_buf == r->even_buf)
          r->even_buf= out_buf;
        else
          r->odd_buf= out_buf;
      }

      r->buf= out_buf;
      if (in_buf == val)
        in_buf= r->odd_buf;

      swap_variables(char*,in_buf,out_buf);

      buf_len_p= (out_buf == r->even_buf) ? &r->even_buf_len :
        &r->odd_buf_len;
9247 9248
    }
  }
9249 9250

  return (r->buf == 0);
9251
}
9252

9253 9254 9255 9256 9257 9258 9259 9260 9261 9262
/*
  Parse the regular expression to be used in all result files
  from now on.

  The syntax is --replace_regex /from/to/i /from/to/i ...
  i means case-insensitive match. If omitted, the match is
  case-sensitive

*/
void do_get_replace_regex(struct st_command *command)
kent@mysql.com's avatar
kent@mysql.com committed
9263
{
9264 9265 9266 9267 9268
  char *expr= command->first_argument;
  free_replace_regex();
  if (!(glob_replace_regex=init_replace_regex(expr)))
    die("Could not init replace_regex");
  command->last_argument= command->end;
kent@mysql.com's avatar
kent@mysql.com committed
9269 9270
}

9271
void free_replace_regex()
kent@mysql.com's avatar
kent@mysql.com committed
9272
{
9273 9274 9275
  if (glob_replace_regex)
  {
    delete_dynamic(&glob_replace_regex->regex_arr);
9276 9277 9278
    my_free(glob_replace_regex->even_buf);
    my_free(glob_replace_regex->odd_buf);
    my_free(glob_replace_regex);
9279 9280
    glob_replace_regex=0;
  }
kent@mysql.com's avatar
kent@mysql.com committed
9281 9282
}

9283 9284


9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298
/*
  auxiluary macro used by reg_replace
  makes sure the result buffer has sufficient length
*/
#define SECURE_REG_BUF   if (buf_len < need_buf_len)                    \
  {                                                                     \
    int off= res_p - buf;                                               \
    buf= (char*)my_realloc(buf,need_buf_len,MYF(MY_WME+MY_FAE));        \
    res_p= buf + off;                                                   \
    buf_len= need_buf_len;                                              \
  }                                                                     \
                                                                        \
/*
  Performs a regex substitution
9299

9300
  IN:
9301

9302 9303 9304 9305 9306 9307 9308 9309 9310 9311 9312 9313
  buf_p - result buffer pointer. Will change if reallocated
  buf_len_p - result buffer length. Will change if the buffer is reallocated
  pattern - regexp pattern to match
  replace - replacement expression
  string - the string to perform substituions in
  icase - flag, if set to 1 the match is case insensitive
*/
int reg_replace(char** buf_p, int* buf_len_p, char *pattern,
                char *replace, char *string, int icase)
{
  my_regex_t r;
  my_regmatch_t *subs;
9314
  char *replace_end;
9315 9316 9317 9318 9319 9320 9321 9322 9323 9324 9325 9326 9327 9328 9329 9330
  char *buf= *buf_p;
  int len;
  int buf_len, need_buf_len;
  int cflags= REG_EXTENDED;
  int err_code;
  char *res_p,*str_p,*str_end;

  buf_len= *buf_len_p;
  len= strlen(string);
  str_end= string + len;

  /* start with a buffer of a reasonable size that hopefully will not
     need to be reallocated
  */
  need_buf_len= len * 2 + 1;
  res_p= buf;
9331

9332
  SECURE_REG_BUF
9333

9334 9335
  if (icase)
    cflags|= REG_ICASE;
9336

9337 9338 9339 9340 9341
  if ((err_code= my_regcomp(&r,pattern,cflags,&my_charset_latin1)))
  {
    check_regerr(&r,err_code);
    return 1;
  }
9342

9343 9344
  subs= (my_regmatch_t*)my_malloc(sizeof(my_regmatch_t) * (r.re_nsub+1),
                                  MYF(MY_WME+MY_FAE));
9345

9346 9347 9348
  *res_p= 0;
  str_p= string;
  replace_end= replace + strlen(replace);
9349

9350 9351
  /* for each pattern match instance perform a replacement */
  while (!err_code)
9352
  {
9353 9354 9355 9356 9357 9358 9359 9360 9361 9362 9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374
    /* find the match */
    err_code= my_regexec(&r,str_p, r.re_nsub+1, subs,
                         (str_p == string) ? REG_NOTBOL : 0);

    /* if regular expression error (eg. bad syntax, or out of memory) */
    if (err_code && err_code != REG_NOMATCH)
    {
      check_regerr(&r,err_code);
      my_regfree(&r);
      return 1;
    }

    /* if match found */
    if (!err_code)
    {
      char* expr_p= replace;
      int c;

      /*
        we need at least what we have so far in the buffer + the part
        before this match
      */
9375
      need_buf_len= (res_p - buf) + (int) subs[0].rm_so;
9376 9377 9378 9379 9380 9381 9382 9383 9384

      /* on this pass, calculate the memory for the result buffer */
      while (expr_p < replace_end)
      {
        int back_ref_num= -1;
        c= *expr_p;

        if (c == '\\' && expr_p + 1 < replace_end)
        {
9385
          back_ref_num= (int) (expr_p[1] - '0');
9386 9387 9388 9389 9390
        }

        /* found a valid back_ref (eg. \1)*/
        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
        {
9391
          regoff_t start_off, end_off;
9392 9393 9394
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
              (end_off=subs[back_ref_num].rm_eo) > -1)
          {
9395
            need_buf_len += (int) (end_off - start_off);
9396 9397 9398 9399 9400 9401 9402 9403 9404 9405 9406 9407 9408 9409 9410 9411 9412 9413 9414
          }
          expr_p += 2;
        }
        else
        {
          expr_p++;
          need_buf_len++;
        }
      }
      need_buf_len++;
      /*
        now that we know the size of the buffer,
        make sure it is big enough
      */
      SECURE_REG_BUF

        /* copy the pre-match part */
        if (subs[0].rm_so)
        {
9415
          memcpy(res_p, str_p, (size_t) subs[0].rm_so);
9416 9417 9418 9419 9420 9421 9422 9423 9424 9425 9426 9427 9428 9429 9430 9431 9432 9433
          res_p+= subs[0].rm_so;
        }

      expr_p= replace;

      /* copy the match and expand back_refs */
      while (expr_p < replace_end)
      {
        int back_ref_num= -1;
        c= *expr_p;

        if (c == '\\' && expr_p + 1 < replace_end)
        {
          back_ref_num= expr_p[1] - '0';
        }

        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
        {
9434
          regoff_t start_off, end_off;
9435 9436 9437
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
              (end_off=subs[back_ref_num].rm_eo) > -1)
          {
9438
            int block_len= (int) (end_off - start_off);
9439 9440 9441 9442 9443 9444 9445 9446 9447 9448 9449 9450 9451 9452 9453 9454 9455 9456 9457 9458 9459 9460 9461 9462 9463 9464 9465 9466 9467 9468 9469 9470 9471
            memcpy(res_p,str_p + start_off, block_len);
            res_p += block_len;
          }
          expr_p += 2;
        }
        else
        {
          *res_p++ = *expr_p++;
        }
      }

      /* handle the post-match part */
      if (subs[0].rm_so == subs[0].rm_eo)
      {
        if (str_p + subs[0].rm_so >= str_end)
          break;
        str_p += subs[0].rm_eo ;
        *res_p++ = *str_p++;
      }
      else
      {
        str_p += subs[0].rm_eo;
      }
    }
    else /* no match this time, just copy the string as is */
    {
      int left_in_str= str_end-str_p;
      need_buf_len= (res_p-buf) + left_in_str;
      SECURE_REG_BUF
        memcpy(res_p,str_p,left_in_str);
      res_p += left_in_str;
      str_p= str_end;
    }
9472
  }
9473
  my_free(subs);
9474 9475 9476 9477 9478 9479
  my_regfree(&r);
  *res_p= 0;
  *buf_p= buf;
  *buf_len_p= buf_len;
  return 0;
}
9480 9481


9482 9483 9484
#ifndef WORD_BIT
#define WORD_BIT (8*sizeof(uint))
#endif
9485 9486

#define SET_MALLOC_HUNC 64
9487
#define LAST_CHAR_CODE 259
9488 9489

typedef struct st_rep_set {
9490 9491
  uint	*bits;				/* Pointer to used sets */
  short next[LAST_CHAR_CODE];		/* Pointer to next sets */
9492 9493
  uint	found_len;			/* Best match to date */
  int	found_offset;
9494 9495
  uint	table_offset;
  uint	size_of_bits;			/* For convinience */
9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517 9518
} REP_SET;

typedef struct st_rep_sets {
  uint		count;			/* Number of sets */
  uint		extra;			/* Extra sets in buffer */
  uint		invisible;		/* Sets not chown */
  uint		size_of_bits;
  REP_SET	*set,*set_buffer;
  uint		*bit_buffer;
} REP_SETS;

typedef struct st_found_set {
  uint table_offset;
  int found_offset;
} FOUND_SET;

typedef struct st_follow {
  int chr;
  uint table_offset;
  uint len;
} FOLLOWS;


9519 9520 9521 9522 9523 9524 9525 9526 9527 9528 9529 9530 9531 9532
int init_sets(REP_SETS *sets,uint states);
REP_SET *make_new_set(REP_SETS *sets);
void make_sets_invisible(REP_SETS *sets);
void free_last_set(REP_SETS *sets);
void free_sets(REP_SETS *sets);
void internal_set_bit(REP_SET *set, uint bit);
void internal_clear_bit(REP_SET *set, uint bit);
void or_bits(REP_SET *to,REP_SET *from);
void copy_bits(REP_SET *to,REP_SET *from);
int cmp_bits(REP_SET *set1,REP_SET *set2);
int get_next_bit(REP_SET *set,uint lastpos);
int find_set(REP_SETS *sets,REP_SET *find);
int find_found(FOUND_SET *found_set,uint table_offset,
               int found_offset);
9533 9534
uint start_at_word(char * pos);
uint end_of_word(char * pos);
9535 9536 9537 9538

static uint found_sets=0;


9539
uint replace_len(char * str)
9540 9541 9542 9543 9544 9545 9546 9547 9548 9549 9550
{
  uint len=0;
  while (*str)
  {
    str++;
    len++;
  }
  return len;
}

/* Init a replace structure for further calls */
9551

9552 9553
REPLACE *init_replace(char * *from, char * *to,uint count,
		      char * word_end_chars)
9554
{
9555 9556 9557
  static const int SPACE_CHAR= 256;
  static const int END_OF_LINE= 258;

9558 9559 9560
  uint i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;
  int used_sets,chr,default_state;
  char used_chars[LAST_CHAR_CODE],is_word_end[256];
9561
  char * pos, *to_pos, **to_array;
9562 9563 9564 9565 9566 9567 9568 9569 9570 9571 9572 9573 9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585 9586 9587 9588 9589 9590 9591 9592 9593 9594 9595 9596
  REP_SETS sets;
  REP_SET *set,*start_states,*word_states,*new_set;
  FOLLOWS *follow,*follow_ptr;
  REPLACE *replace;
  FOUND_SET *found_set;
  REPLACE_STRING *rep_str;
  DBUG_ENTER("init_replace");

  /* Count number of states */
  for (i=result_len=max_length=0 , states=2 ; i < count ; i++)
  {
    len=replace_len(from[i]);
    if (!len)
    {
      errno=EINVAL;
      DBUG_RETURN(0);
    }
    states+=len+1;
    result_len+=(uint) strlen(to[i])+1;
    if (len > max_length)
      max_length=len;
  }
  bzero((char*) is_word_end,sizeof(is_word_end));
  for (i=0 ; word_end_chars[i] ; i++)
    is_word_end[(uchar) word_end_chars[i]]=1;

  if (init_sets(&sets,states))
    DBUG_RETURN(0);
  found_sets=0;
  if (!(found_set= (FOUND_SET*) my_malloc(sizeof(FOUND_SET)*max_length*count,
					  MYF(MY_WME))))
  {
    free_sets(&sets);
    DBUG_RETURN(0);
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
9597
  (void) make_new_set(&sets);			/* Set starting set */
9598 9599 9600 9601 9602 9603 9604
  make_sets_invisible(&sets);			/* Hide previus sets */
  used_sets=-1;
  word_states=make_new_set(&sets);		/* Start of new word */
  start_states=make_new_set(&sets);		/* This is first state */
  if (!(follow=(FOLLOWS*) my_malloc((states+2)*sizeof(FOLLOWS),MYF(MY_WME))))
  {
    free_sets(&sets);
9605
    my_free(found_set);
9606 9607 9608
    DBUG_RETURN(0);
  }

9609
  /* Init follow_ptr[] */
9610 9611 9612 9613
  for (i=0, states=1, follow_ptr=follow+1 ; i < count ; i++)
  {
    if (from[i][0] == '\\' && from[i][1] == '^')
    {
9614
      internal_set_bit(start_states,states+1);
9615 9616 9617 9618 9619 9620 9621 9622
      if (!from[i][2])
      {
	start_states->table_offset=i;
	start_states->found_offset=1;
      }
    }
    else if (from[i][0] == '\\' && from[i][1] == '$')
    {
9623 9624
      internal_set_bit(start_states,states);
      internal_set_bit(word_states,states);
9625 9626 9627 9628 9629 9630 9631 9632
      if (!from[i][2] && start_states->table_offset == (uint) ~0)
      {
	start_states->table_offset=i;
	start_states->found_offset=0;
      }
    }
    else
    {
9633
      internal_set_bit(word_states,states);
9634
      if (from[i][0] == '\\' && (from[i][1] == 'b' && from[i][2]))
9635
	internal_set_bit(start_states,states+1);
9636
      else
9637
	internal_set_bit(start_states,states);
9638 9639 9640
    }
    for (pos=from[i], len=0; *pos ; pos++)
    {
9641
      follow_ptr->chr= (uchar) *pos;
9642 9643 9644 9645 9646 9647 9648 9649 9650 9651 9652 9653 9654 9655 9656 9657 9658 9659 9660 9661 9662 9663 9664 9665 9666 9667 9668 9669 9670 9671 9672 9673 9674 9675 9676 9677 9678 9679 9680 9681 9682 9683 9684 9685 9686 9687 9688 9689 9690 9691 9692 9693 9694 9695 9696 9697 9698 9699 9700 9701 9702 9703 9704 9705 9706 9707 9708 9709 9710 9711 9712 9713 9714
      follow_ptr->table_offset=i;
      follow_ptr->len= ++len;
      follow_ptr++;
    }
    follow_ptr->chr=0;
    follow_ptr->table_offset=i;
    follow_ptr->len=len;
    follow_ptr++;
    states+=(uint) len+1;
  }


  for (set_nr=0,pos=0 ; set_nr < sets.count ; set_nr++)
  {
    set=sets.set+set_nr;
    default_state= 0;				/* Start from beginning */

    /* If end of found-string not found or start-set with current set */

    for (i= (uint) ~0; (i=get_next_bit(set,i)) ;)
    {
      if (!follow[i].chr)
      {
	if (! default_state)
	  default_state= find_found(found_set,set->table_offset,
				    set->found_offset+1);
      }
    }
    copy_bits(sets.set+used_sets,set);		/* Save set for changes */
    if (!default_state)
      or_bits(sets.set+used_sets,sets.set);	/* Can restart from start */

    /* Find all chars that follows current sets */
    bzero((char*) used_chars,sizeof(used_chars));
    for (i= (uint) ~0; (i=get_next_bit(sets.set+used_sets,i)) ;)
    {
      used_chars[follow[i].chr]=1;
      if ((follow[i].chr == SPACE_CHAR && !follow[i+1].chr &&
	   follow[i].len > 1) || follow[i].chr == END_OF_LINE)
	used_chars[0]=1;
    }

    /* Mark word_chars used if \b is in state */
    if (used_chars[SPACE_CHAR])
      for (pos= word_end_chars ; *pos ; pos++)
	used_chars[(int) (uchar) *pos] = 1;

    /* Handle other used characters */
    for (chr= 0 ; chr < 256 ; chr++)
    {
      if (! used_chars[chr])
	set->next[chr]= chr ? default_state : -1;
      else
      {
	new_set=make_new_set(&sets);
	set=sets.set+set_nr;			/* if realloc */
	new_set->table_offset=set->table_offset;
	new_set->found_len=set->found_len;
	new_set->found_offset=set->found_offset+1;
	found_end=0;

	for (i= (uint) ~0 ; (i=get_next_bit(sets.set+used_sets,i)) ; )
	{
	  if (!follow[i].chr || follow[i].chr == chr ||
	      (follow[i].chr == SPACE_CHAR &&
	       (is_word_end[chr] ||
		(!chr && follow[i].len > 1 && ! follow[i+1].chr))) ||
	      (follow[i].chr == END_OF_LINE && ! chr))
	  {
	    if ((! chr || (follow[i].chr && !follow[i+1].chr)) &&
		follow[i].len > found_end)
	      found_end=follow[i].len;
	    if (chr && follow[i].chr)
9715
	      internal_set_bit(new_set,i+1);		/* To next set */
9716
	    else
9717
	      internal_set_bit(new_set,i);
9718 9719 9720 9721 9722 9723 9724 9725 9726 9727 9728 9729 9730 9731 9732 9733
	  }
	}
	if (found_end)
	{
	  new_set->found_len=0;			/* Set for testing if first */
	  bits_set=0;
	  for (i= (uint) ~0; (i=get_next_bit(new_set,i)) ;)
	  {
	    if ((follow[i].chr == SPACE_CHAR ||
		 follow[i].chr == END_OF_LINE) && ! chr)
	      bit_nr=i+1;
	    else
	      bit_nr=i;
	    if (follow[bit_nr-1].len < found_end ||
		(new_set->found_len &&
		 (chr == 0 || !follow[bit_nr].chr)))
9734
	      internal_clear_bit(new_set,i);
9735 9736 9737 9738 9739 9740 9741 9742 9743 9744 9745 9746 9747 9748 9749 9750 9751 9752 9753 9754 9755 9756 9757 9758 9759 9760 9761 9762 9763
	    else
	    {
	      if (chr == 0 || !follow[bit_nr].chr)
	      {					/* best match  */
		new_set->table_offset=follow[bit_nr].table_offset;
		if (chr || (follow[i].chr == SPACE_CHAR ||
			    follow[i].chr == END_OF_LINE))
		  new_set->found_offset=found_end;	/* New match */
		new_set->found_len=found_end;
	      }
	      bits_set++;
	    }
	  }
	  if (bits_set == 1)
	  {
	    set->next[chr] = find_found(found_set,
					new_set->table_offset,
					new_set->found_offset);
	    free_last_set(&sets);
	  }
	  else
	    set->next[chr] = find_set(&sets,new_set);
	}
	else
	  set->next[chr] = find_set(&sets,new_set);
      }
    }
  }

9764
  /* Alloc replace structure for the replace-state-machine */
9765 9766 9767

  if ((replace=(REPLACE*) my_malloc(sizeof(REPLACE)*(sets.count)+
				    sizeof(REPLACE_STRING)*(found_sets+1)+
9768
				    sizeof(char *)*count+result_len,
9769 9770 9771
				    MYF(MY_WME | MY_ZEROFILL))))
  {
    rep_str=(REPLACE_STRING*) (replace+sets.count);
9772 9773
    to_array= (char **) (rep_str+found_sets+1);
    to_pos=(char *) (to_array+count);
9774 9775 9776 9777 9778 9779 9780 9781 9782 9783
    for (i=0 ; i < count ; i++)
    {
      to_array[i]=to_pos;
      to_pos=strmov(to_pos,to[i])+1;
    }
    rep_str[0].found=1;
    rep_str[0].replace_string=0;
    for (i=1 ; i <= found_sets ; i++)
    {
      pos=from[found_set[i-1].table_offset];
9784
      rep_str[i].found= !memcmp(pos, "\\^", 3) ? 2 : 1;
9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798
      rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
      rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
      rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+
	end_of_word(pos);
    }
    for (i=0 ; i < sets.count ; i++)
    {
      for (j=0 ; j < 256 ; j++)
	if (sets.set[i].next[j] >= 0)
	  replace[i].next[j]=replace+sets.set[i].next[j];
	else
	  replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
    }
  }
9799
  my_free(follow);
9800
  free_sets(&sets);
9801
  my_free(found_set);
9802 9803 9804 9805 9806
  DBUG_PRINT("exit",("Replace table has %d states",sets.count));
  DBUG_RETURN(replace);
}


9807
int init_sets(REP_SETS *sets,uint states)
9808 9809 9810 9811 9812 9813 9814 9815 9816
{
  bzero((char*) sets,sizeof(*sets));
  sets->size_of_bits=((states+7)/8);
  if (!(sets->set_buffer=(REP_SET*) my_malloc(sizeof(REP_SET)*SET_MALLOC_HUNC,
					      MYF(MY_WME))))
    return 1;
  if (!(sets->bit_buffer=(uint*) my_malloc(sizeof(uint)*sets->size_of_bits*
					   SET_MALLOC_HUNC,MYF(MY_WME))))
  {
9817
    my_free(sets->set);
9818 9819 9820 9821 9822
    return 1;
  }
  return 0;
}

9823
/* Make help sets invisible for nicer codeing */
9824

9825
void make_sets_invisible(REP_SETS *sets)
9826 9827 9828 9829 9830 9831
{
  sets->invisible=sets->count;
  sets->set+=sets->count;
  sets->count=0;
}

9832
REP_SET *make_new_set(REP_SETS *sets)
9833 9834 9835 9836 9837 9838 9839 9840 9841 9842 9843 9844 9845 9846 9847 9848
{
  uint i,count,*bit_buffer;
  REP_SET *set;
  if (sets->extra)
  {
    sets->extra--;
    set=sets->set+ sets->count++;
    bzero((char*) set->bits,sizeof(uint)*sets->size_of_bits);
    bzero((char*) &set->next[0],sizeof(set->next[0])*LAST_CHAR_CODE);
    set->found_offset=0;
    set->found_len=0;
    set->table_offset= (uint) ~0;
    set->size_of_bits=sets->size_of_bits;
    return set;
  }
  count=sets->count+sets->invisible+SET_MALLOC_HUNC;
9849
  if (!(set=(REP_SET*) my_realloc((uchar*) sets->set_buffer,
9850
                                  sizeof(REP_SET)*count,
9851 9852 9853 9854
				  MYF(MY_WME))))
    return 0;
  sets->set_buffer=set;
  sets->set=set+sets->invisible;
9855
  if (!(bit_buffer=(uint*) my_realloc((uchar*) sets->bit_buffer,
9856 9857 9858 9859 9860 9861 9862 9863 9864 9865 9866 9867 9868
				      (sizeof(uint)*sets->size_of_bits)*count,
				      MYF(MY_WME))))
    return 0;
  sets->bit_buffer=bit_buffer;
  for (i=0 ; i < count ; i++)
  {
    sets->set_buffer[i].bits=bit_buffer;
    bit_buffer+=sets->size_of_bits;
  }
  sets->extra=SET_MALLOC_HUNC;
  return make_new_set(sets);
}

9869
void free_last_set(REP_SETS *sets)
9870 9871 9872 9873 9874 9875
{
  sets->count--;
  sets->extra++;
  return;
}

9876
void free_sets(REP_SETS *sets)
9877
{
9878 9879
  my_free(sets->set_buffer);
  my_free(sets->bit_buffer);
9880 9881 9882
  return;
}

9883
void internal_set_bit(REP_SET *set, uint bit)
9884 9885 9886 9887 9888
{
  set->bits[bit / WORD_BIT] |= 1 << (bit % WORD_BIT);
  return;
}

9889
void internal_clear_bit(REP_SET *set, uint bit)
9890 9891 9892 9893 9894 9895
{
  set->bits[bit / WORD_BIT] &= ~ (1 << (bit % WORD_BIT));
  return;
}


9896
void or_bits(REP_SET *to,REP_SET *from)
9897 9898 9899 9900 9901 9902 9903
{
  reg1 uint i;
  for (i=0 ; i < to->size_of_bits ; i++)
    to->bits[i]|=from->bits[i];
  return;
}

9904
void copy_bits(REP_SET *to,REP_SET *from)
9905
{
9906
  memcpy((uchar*) to->bits,(uchar*) from->bits,
9907 9908 9909
	 (size_t) (sizeof(uint) * to->size_of_bits));
}

9910
int cmp_bits(REP_SET *set1,REP_SET *set2)
9911
{
9912 9913
  return memcmp(set1->bits, set2->bits,
                sizeof(uint) * set1->size_of_bits);
9914 9915 9916
}


9917
/* Get next set bit from set. */
9918

9919
int get_next_bit(REP_SET *set,uint lastpos)
9920 9921 9922 9923 9924 9925 9926 9927 9928 9929 9930 9931 9932 9933 9934 9935 9936 9937 9938 9939
{
  uint pos,*start,*end,bits;

  start=set->bits+ ((lastpos+1) / WORD_BIT);
  end=set->bits + set->size_of_bits;
  bits=start[0] & ~((1 << ((lastpos+1) % WORD_BIT)) -1);

  while (! bits && ++start < end)
    bits=start[0];
  if (!bits)
    return 0;
  pos=(uint) (start-set->bits)*WORD_BIT;
  while (! (bits & 1))
  {
    bits>>=1;
    pos++;
  }
  return pos;
}

9940 9941 9942
/* find if there is a same set in sets. If there is, use it and
   free given set, else put in given set in sets and return its
   position */
9943

9944
int find_set(REP_SETS *sets,REP_SET *find)
9945 9946 9947 9948 9949 9950 9951 9952 9953 9954 9955 9956 9957
{
  uint i;
  for (i=0 ; i < sets->count-1 ; i++)
  {
    if (!cmp_bits(sets->set+i,find))
    {
      free_last_set(sets);
      return i;
    }
  }
  return i;				/* return new postion */
}

9958 9959 9960 9961 9962 9963
/* find if there is a found_set with same table_offset & found_offset
   If there is return offset to it, else add new offset and return pos.
   Pos returned is -offset-2 in found_set_structure because it is
   saved in set->next and set->next[] >= 0 points to next set and
   set->next[] == -1 is reserved for end without replaces.
*/
9964

9965
int find_found(FOUND_SET *found_set,uint table_offset, int found_offset)
9966 9967 9968 9969 9970 9971 9972 9973 9974 9975 9976 9977
{
  int i;
  for (i=0 ; (uint) i < found_sets ; i++)
    if (found_set[i].table_offset == table_offset &&
	found_set[i].found_offset == found_offset)
      return -i-2;
  found_set[i].table_offset=table_offset;
  found_set[i].found_offset=found_offset;
  found_sets++;
  return -i-2;				/* return new postion */
}

9978
/* Return 1 if regexp starts with \b or ends with \b*/
9979

9980
uint start_at_word(char * pos)
9981
{
9982 9983
  return (((!memcmp(pos, "\\b",2) && pos[2]) ||
           !memcmp(pos, "\\^", 2)) ? 1 : 0);
9984 9985
}

9986
uint end_of_word(char * pos)
9987
{
9988
  char * end=strend(pos);
9989 9990
  return ((end > pos+2 && !memcmp(end-2, "\\b", 2)) ||
	  (end >= pos+2 && !memcmp(end-2, "\\$",2))) ? 1 : 0;
9991 9992
}

9993 9994 9995
/****************************************************************************
 * Handle replacement of strings
 ****************************************************************************/
9996

9997 9998
#define PC_MALLOC		256	/* Bytes for pointers */
#define PS_MALLOC		512	/* Bytes for data */
9999

10000
int insert_pointer_name(reg1 POINTER_ARRAY *pa,char * name)
10001
{
10002
  uint i,length,old_count;
10003
  uchar *new_pos;
10004 10005
  const char **new_array;
  DBUG_ENTER("insert_pointer_name");
10006

10007
  if (! pa->typelib.count)
10008
  {
10009 10010
    if (!(pa->typelib.type_names=(const char **)
	  my_malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
10011 10012
		     (sizeof(char *)+sizeof(*pa->flag))*
		     (sizeof(char *)+sizeof(*pa->flag))),MYF(MY_WME))))
10013
      DBUG_RETURN(-1);
10014
    if (!(pa->str= (uchar*) my_malloc((uint) (PS_MALLOC-MALLOC_OVERHEAD),
10015
				     MYF(MY_WME))))
10016
    {
10017
      my_free(pa->typelib.type_names);
10018
      DBUG_RETURN (-1);
10019
    }
10020
    pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(uchar*)+
10021
					       sizeof(*pa->flag));
10022
    pa->flag= (uint8*) (pa->typelib.type_names+pa->max_count);
10023 10024 10025
    pa->length=0;
    pa->max_length=PS_MALLOC-MALLOC_OVERHEAD;
    pa->array_allocs=1;
10026
  }
10027 10028
  length=(uint) strlen(name)+1;
  if (pa->length+length >= pa->max_length)
10029
  {
10030
    if (!(new_pos= (uchar*) my_realloc((uchar*) pa->str,
10031
                                      (uint) (pa->length+length+PS_MALLOC),
10032 10033 10034
				      MYF(MY_WME))))
      DBUG_RETURN(1);
    if (new_pos != pa->str)
10035
    {
10036 10037 10038 10039 10040
      my_ptrdiff_t diff=PTR_BYTE_DIFF(new_pos,pa->str);
      for (i=0 ; i < pa->typelib.count ; i++)
	pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
					      char*);
      pa->str=new_pos;
10041
    }
10042
    pa->max_length= pa->length+length+PS_MALLOC;
10043
  }
10044
  if (pa->typelib.count >= pa->max_count-1)
10045
  {
10046 10047 10048
    int len;
    pa->array_allocs++;
    len=(PC_MALLOC*pa->array_allocs - MALLOC_OVERHEAD);
10049
    if (!(new_array=(const char **) my_realloc((uchar*) pa->typelib.type_names,
10050
					       (uint) len/
10051 10052
                                               (sizeof(uchar*)+sizeof(*pa->flag))*
                                               (sizeof(uchar*)+sizeof(*pa->flag)),
10053 10054 10055 10056
                                               MYF(MY_WME))))
      DBUG_RETURN(1);
    pa->typelib.type_names=new_array;
    old_count=pa->max_count;
10057
    pa->max_count=len/(sizeof(uchar*) + sizeof(*pa->flag));
10058
    pa->flag= (uint8*) (pa->typelib.type_names+pa->max_count);
10059
    memcpy((uchar*) pa->flag,(char *) (pa->typelib.type_names+old_count),
10060
	   old_count*sizeof(*pa->flag));
10061
  }
10062
  pa->flag[pa->typelib.count]=0;			/* Reset flag */
10063
  pa->typelib.type_names[pa->typelib.count++]= (char*) pa->str+pa->length;
10064
  pa->typelib.type_names[pa->typelib.count]= NullS;	/* Put end-mark */
Konstantin Osipov's avatar
Konstantin Osipov committed
10065
  (void) strmov((char*) pa->str+pa->length,name);
10066 10067 10068
  pa->length+=length;
  DBUG_RETURN(0);
} /* insert_pointer_name */
monty@mysql.com's avatar
monty@mysql.com committed
10069 10070


10071
/* free pointer array */
monty@mysql.com's avatar
monty@mysql.com committed
10072

10073 10074 10075 10076 10077
void free_pointer_array(POINTER_ARRAY *pa)
{
  if (pa->typelib.count)
  {
    pa->typelib.count=0;
10078
    my_free(pa->typelib.type_names);
10079
    pa->typelib.type_names=0;
10080
    my_free(pa->str);
10081 10082
  }
} /* free_pointer_array */
monty@mysql.com's avatar
monty@mysql.com committed
10083 10084


10085
/* Functions that uses replace and replace_regex */
monty@mysql.com's avatar
monty@mysql.com committed
10086

10087 10088 10089
/* Append the string to ds, with optional replace */
void replace_dynstr_append_mem(DYNAMIC_STRING *ds,
                               const char *val, int len)
monty@mysql.com's avatar
monty@mysql.com committed
10090
{
10091
  char lower[512];
10092 10093 10094
#ifdef __WIN__
  fix_win_paths(val, len);
#endif
monty@mysql.com's avatar
monty@mysql.com committed
10095

10096 10097 10098 10099 10100 10101 10102 10103 10104 10105 10106
  if (display_result_lower) 
  {
    /* Convert to lower case, and do this first */
    char *c= lower;
    for (const char *v= val;  *v;  v++)
      *c++= my_tolower(charset_info, *v);
    *c= '\0';
    /* Copy from this buffer instead */
    val= lower;
  }
  
10107
  if (glob_replace_regex)
monty@mysql.com's avatar
monty@mysql.com committed
10108
  {
10109 10110
    /* Regex replace */
    if (!multi_reg_replace(glob_replace_regex, (char*)val))
monty@mysql.com's avatar
monty@mysql.com committed
10111
    {
10112 10113
      val= glob_replace_regex->buf;
      len= strlen(val);
monty@mysql.com's avatar
monty@mysql.com committed
10114 10115 10116
    }
  }

10117 10118 10119 10120 10121 10122 10123 10124
  if (glob_replace)
  {
    /* Normal replace */
    replace_strings_append(glob_replace, ds, val, len);
  }
  else
    dynstr_append_mem(ds, val, len);
}
monty@mysql.com's avatar
monty@mysql.com committed
10125 10126


10127 10128
/* Append zero-terminated string to ds, with optional replace */
void replace_dynstr_append(DYNAMIC_STRING *ds, const char *val)
monty@mysql.com's avatar
monty@mysql.com committed
10129
{
10130 10131
  replace_dynstr_append_mem(ds, val, strlen(val));
}
10132

10133 10134 10135 10136 10137 10138
/* Append uint to ds, with optional replace */
void replace_dynstr_append_uint(DYNAMIC_STRING *ds, uint val)
{
  char buff[22]; /* This should be enough for any int */
  char *end= longlong10_to_str(val, buff, 10);
  replace_dynstr_append_mem(ds, buff, end - buff);
monty@mysql.com's avatar
monty@mysql.com committed
10139
}
10140 10141 10142 10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156 10157 10158 10159 10160 10161 10162 10163 10164 10165 10166 10167 10168 10169 10170 10171 10172 10173 10174 10175 10176 10177 10178 10179 10180 10181 10182 10183 10184 10185 10186 10187 10188



/*
  Build a list of pointer to each line in ds_input, sort
  the list and use the sorted list to append the strings
  sorted to the output ds

  SYNOPSIS
  dynstr_append_sorted
  ds - string where the sorted output will be appended
  ds_input - string to be sorted

*/

static int comp_lines(const char **a, const char **b)
{
  return (strcmp(*a,*b));
}

void dynstr_append_sorted(DYNAMIC_STRING* ds, DYNAMIC_STRING *ds_input)
{
  unsigned i;
  char *start= ds_input->str;
  DYNAMIC_ARRAY lines;
  DBUG_ENTER("dynstr_append_sorted");

  if (!*start)
    DBUG_VOID_RETURN;  /* No input */

  my_init_dynamic_array(&lines, sizeof(const char*), 32, 32);

  /* First line is result header, skip past it */
  while (*start && *start != '\n')
    start++;
  start++; /* Skip past \n */
  dynstr_append_mem(ds, ds_input->str, start - ds_input->str);

  /* Insert line(s) in array */
  while (*start)
  {
    char* line_end= (char*)start;

    /* Find end of line */
    while (*line_end && *line_end != '\n')
      line_end++;
    *line_end= 0;

    /* Insert pointer to the line in array */
10189
    if (insert_dynamic(&lines, (uchar*) &start))
10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201 10202 10203 10204 10205 10206 10207 10208 10209
      die("Out of memory inserting lines to sort");

    start= line_end+1;
  }

  /* Sort array */
  qsort(lines.buffer, lines.elements,
        sizeof(char**), (qsort_cmp)comp_lines);

  /* Create new result */
  for (i= 0; i < lines.elements ; i++)
  {
    const char **line= dynamic_element(&lines, i, const char**);
    dynstr_append(ds, *line);
    dynstr_append(ds, "\n");
  }

  delete_dynamic(&lines);
  DBUG_VOID_RETURN;
}
10210 10211 10212 10213 10214

#ifndef HAVE_SETENV
static int setenv(const char *name, const char *value, int overwrite)
{
  size_t buflen= strlen(name) + strlen(value) + 2;
10215
  char *envvar= (char *)malloc(buflen);
10216 10217 10218 10219 10220 10221 10222 10223 10224
  if(!envvar)
    return ENOMEM;
  strcpy(envvar, name);
  strcat(envvar, "=");
  strcat(envvar, value);
  putenv(envvar);
  return 0;
}
#endif