mysqltest.cc 247 KB
Newer Older
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1
/* Copyright (C) 2000 MySQL AB
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 40
#include <m_ctype.h>
#include <my_dir.h>
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
41
#include <hash.h>
42
#include <stdarg.h>
43
#include <violite.h>
44
#include "my_regex.h" /* Our own version of regex */
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
45
#ifdef HAVE_SYS_WAIT_H
46
#include <sys/wait.h>
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
47
#endif
48 49 50
#ifdef __WIN__
#include <direct.h>
#endif
51
#include <signal.h>
52
#include <my_stacktrace.h>
53

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

61 62 63 64 65
/* Use cygwin for --exec and --system before 5.0 */
#if MYSQL_VERSION_ID < 50000
#define USE_CYGWIN
#endif

66 67 68 69 70 71 72 73 74 75
#define MAX_VAR_NAME_LENGTH    256
#define MAX_COLUMNS            256
#define MAX_EMBEDDED_SERVER_ARGS 64
#define MAX_DELIMITER_LENGTH 16

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

enum {
76 77
  OPT_SKIP_SAFEMALLOC=OPT_MAX_CLIENT_OPTION,
  OPT_PS_PROTOCOL, OPT_SP_PROTOCOL, OPT_CURSOR_PROTOCOL, OPT_VIEW_PROTOCOL,
78
  OPT_MAX_CONNECT_RETRIES, OPT_MARK_PROGRESS, OPT_LOG_DIR, OPT_TAIL_LINES
79
};
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
80

81
static int record= 0, opt_sleep= -1;
82 83
static char *opt_db= 0, *opt_pass= 0;
const char *opt_user= 0, *opt_host= 0, *unix_sock= 0, *opt_basedir= "./";
84
const char *opt_logdir= "";
85
const char *opt_include= 0, *opt_charsets_dir;
86
static int opt_port= 0;
87 88
static int opt_max_connect_retries;
static my_bool opt_compress= 0, silent= 0, verbose= 0;
89
static my_bool debug_info_flag= 0, debug_check_flag= 0;
90 91 92 93 94 95 96
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;
97 98
static my_bool display_result_vertically= FALSE,
  display_metadata= FALSE, display_result_sorted= FALSE;
99
static my_bool disable_query_log= 0, disable_result_log= 0;
100
static my_bool disable_warnings= 0;
101 102
static my_bool disable_info= 1;
static my_bool abort_on_error= 1;
103
static my_bool server_initialized= 0;
104
static my_bool is_windows= 0;
105 106 107
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;
108

109
static uint start_lineno= 0; /* Start line of current command */
110
static uint my_end_arg= 0;
111

112 113 114
/* Number of lines of the result to include in failure report */
static uint opt_tail_lines= 0;

115 116
static uint opt_connect_timeout= 0;

117 118 119 120 121 122 123 124 125 126
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
127 128
};

129
struct st_block
130
{
131 132 133 134
  int             line; /* Start line of block */
  my_bool         ok;   /* Should block be executed */
  enum block_cmd  cmd;  /* Command owning the block */
};
135

136 137
static struct st_block block_stack[32];
static struct st_block *cur_block, *block_stack_end;
138

139 140
/* Open file stack */
struct st_test_file
141 142 143
{
  FILE* file;
  const char *file_name;
144 145
  uint lineno; /* Current line in file */
};
146

147 148 149
static struct st_test_file file_stack[16];
static struct st_test_file* cur_file;
static struct st_test_file* file_stack_end;
150

151

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

154 155 156 157 158 159 160
static const char *embedded_server_groups[]=
{
  "server",
  "embedded",
  "mysqltest_SERVER",
  NullS
};
161

162 163
static int embedded_server_arg_count=0;
static char *embedded_server_args[MAX_EMBEDDED_SERVER_ARGS];
164

165 166 167 168
/*
  Timer related variables
  See the timer_output() definition for details
*/
kent@mysql.com's avatar
kent@mysql.com committed
169 170 171 172 173
static char *timer_file = NULL;
static ulonglong timer_start;
static void timer_output(void);
static ulonglong timer_now(void);

174

175 176
static ulong connection_retry_sleep= 100000; /* Microseconds */

177 178 179 180 181 182 183 184
/* 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);
185

186 187
DYNAMIC_ARRAY q_lines;

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

190
struct Parser
191 192
{
  int read_lines,current_line;
193
} parser;
194

195
struct MasterPos
196 197 198 199
{
  char file[FN_REFLEN];
  ulong pos;
} master_pos;
200

201
/* if set, all results are concated and compared against this file */
202
const char *result_file_name= 0;
203

204
typedef struct
205
{
206
  char *name;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
207
  int name_len;
208
  char *str_val;
209 210 211 212
  int str_val_len;
  int int_val;
  int alloced_len;
  int int_dirty; /* do not update string if int is updated until first read */
213
  int alloced;
214
  char *env_s;
215 216 217
} VAR;

/*Perl/shell-like variable registers */
218
VAR var_reg[10];
219

220
HASH var_hash;
221

222 223 224 225 226 227
struct st_connection
{
  MYSQL mysql;
  /* Used when creating views and sp, to avoid implicit commit */
  MYSQL* util_mysql;
  char *name;
228
  size_t name_len;
229
  MYSQL_STMT* stmt;
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
230

231
#ifdef EMBEDDED_LIBRARY
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
232 233 234 235 236
  const char *cur_query;
  int cur_query_len;
  pthread_mutex_t mutex;
  pthread_cond_t cond;
  int query_done;
237
#endif /*EMBEDDED_LIBRARY*/
238 239
};
struct st_connection connections[128];
240
struct st_connection* cur_con= NULL, *next_con, *connections_end;
241

242 243 244 245 246
/*
  List of commands in mysqltest
  Must match the "command_names" array
  Add new commands before Q_UNKNOWN!
*/
247
enum enum_commands {
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
  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,
  Q_RPL_PROBE,	    Q_ENABLE_RPL_PARSE,
  Q_DISABLE_RPL_PARSE, Q_EVAL_RESULT,
  Q_ENABLE_QUERY_LOG, Q_DISABLE_QUERY_LOG,
  Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,
  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,
273
  Q_QUERY_VERTICAL, Q_QUERY_HORIZONTAL, Q_SORTED_RESULT,
274 275 276 277 278 279
  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,
280
  Q_WRITE_FILE, Q_COPY_FILE, Q_PERL, Q_DIE, Q_EXIT, Q_SKIP,
281
  Q_CHMOD_FILE, Q_APPEND_FILE, Q_CAT_FILE, Q_DIFF_FILES,
282
  Q_SEND_QUIT, Q_CHANGE_USER, Q_MKDIR, Q_RMDIR,
Sven Sandberg's avatar
Sven Sandberg committed
283
  Q_LIST_FILES, Q_LIST_FILES_WRITE_FILE, Q_LIST_FILES_APPEND_FILE,
284
  Q_SEND_SHUTDOWN, Q_SHUTDOWN_SERVER,
285
  Q_MOVE_FILE,
286 287 288 289

  Q_UNKNOWN,			       /* Unknown command.   */
  Q_COMMENT,			       /* Comments, ignored. */
  Q_COMMENT_WITH_COMMAND
290 291
};

292

293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
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",
313
  "sync_slave_with_master",
314 315 316 317 318
  "error",
  "send",
  "reap",
  "dirty_close",
  "replace_result",
319
  "replace_column",
320 321 322 323 324 325
  "ping",
  "eval",
  "rpl_probe",
  "enable_rpl_parse",
  "disable_rpl_parse",
  "eval_result",
326
  /* Enable/disable that the _query_ is logged to result file */
327 328
  "enable_query_log",
  "disable_query_log",
329
  /* Enable/disable that the _result_ from a query is logged to result file */
330 331 332
  "enable_result_log",
  "disable_result_log",
  "wait_for_slave_to_stop",
333 334 335
  "enable_warnings",
  "disable_warnings",
  "enable_info",
336
  "disable_info",
337 338
  "enable_metadata",
  "disable_metadata",
339
  "exec",
340
  "delimiter",
341 342
  "disable_abort_on_error",
  "enable_abort_on_error",
343
  "vertical_results",
344
  "horizontal_results",
345
  "query_vertical",
346
  "query_horizontal",
347
  "sorted_result",
kent@mysql.com's avatar
kent@mysql.com committed
348 349
  "start_timer",
  "end_timer",
kent@mysql.com's avatar
kent@mysql.com committed
350
  "character_set",
351 352
  "disable_ps_protocol",
  "enable_ps_protocol",
353 354
  "disable_reconnect",
  "enable_reconnect",
355
  "if",
356 357 358 359 360 361 362 363 364
  "disable_parsing",
  "enable_parsing",
  "replace_regex",
  "remove_file",
  "file_exists",
  "write_file",
  "copy_file",
  "perl",
  "die",
365
               
366 367
  /* Don't execute any more commands, compare result */
  "exit",
368
  "skip",
369
  "chmod",
370
  "append_file",
371
  "cat_file",
372
  "diff_files",
373
  "send_quit",
374
  "change_user",
375 376
  "mkdir",
  "rmdir",
377 378 379
  "list_files",
  "list_files_write_file",
  "list_files_append_file",
380 381
  "send_shutdown",
  "shutdown_server",
382
  "move_file",
383

jcole@tetra.spaceapes.com's avatar
jcole@tetra.spaceapes.com committed
384
  0
385 386
};

387 388 389 390 391 392 393 394 395

/*
  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
396
{
397 398 399 400
  ERR_EMPTY= 0,
  ERR_ERRNO,
  ERR_SQLSTATE
};
401

402 403 404 405 406 407 408 409 410
struct st_match_err
{
  enum match_err_type type;
  union
  {
    uint errnum;
    char sqlstate[SQLSTATE_LENGTH+1];  /* \0 terminated string */
  } code;
};
411

412 413 414 415 416 417
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
418

419 420 421
struct st_command
{
  char *query, *query_buf,*first_argument,*last_argument,*end;
422
  DYNAMIC_STRING content;
423
  int first_word_len, query_len;
424
  my_bool abort_on_error;
425
  struct st_expected_errors expected_errors;
426
  char require_file[FN_REFLEN];
427 428
  enum enum_commands type;
};
429

430 431
TYPELIB command_typelib= {array_elements(command_names),"",
			  command_names, 0};
432

433
DYNAMIC_STRING ds_res;
434

435 436
char builtin_echo[FN_REFLEN];

437 438
static void cleanup_and_exit(int exit_code) __attribute__((noreturn));

439
void die(const char *fmt, ...)
440
  ATTRIBUTE_FORMAT(printf, 1, 2) __attribute__((noreturn));
441
void abort_not_supported_test(const char *fmt, ...)
442
  ATTRIBUTE_FORMAT(printf, 1, 2) __attribute__((noreturn));
443
void verbose_msg(const char *fmt, ...)
444
  ATTRIBUTE_FORMAT(printf, 1, 2);
445 446
void log_msg(const char *fmt, ...)
  ATTRIBUTE_FORMAT(printf, 1, 2);
447 448 449 450 451 452 453 454 455

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);
void var_free(void* v);
VAR* var_get(const char *var_name, const char** var_name_end,
             my_bool raw, my_bool ignore_not_existing);
void eval_expr(VAR* v, const char *p, const char** p_end);
my_bool match_delimiter(int c, const char *delim, uint length);
456 457
void dump_result_to_reject_file(char *buf, int size);
void dump_warning_messages();
458 459 460 461

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

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

466 467 468 469
#ifdef __WIN__
void free_tmp_sh_file();
void free_win_path_patterns();
#endif
470 471


472 473 474 475 476 477 478 479
/* 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);
480
void free_replace();
481

482 483 484 485
/* For replace_regex */
void do_get_replace_regex(struct st_command *command);
void free_replace_regex();

486

487 488 489 490 491
void free_all_replace(){
  free_replace();
  free_replace_regex();
  free_replace_column();
}
492 493


494 495 496
class LogFile {
  FILE* m_file;
  char m_file_name[FN_REFLEN];
Magnus Svensson's avatar
Magnus Svensson committed
497
  size_t m_bytes_written;
498 499 500 501 502 503 504 505 506 507
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
508
  size_t bytes_written() const { return m_bytes_written; }
509 510 511 512

  void open(const char* dir, const char* name, const char* ext)
  {
    DBUG_ENTER("LogFile::open");
Magnus Svensson's avatar
Magnus Svensson committed
513 514
    DBUG_PRINT("enter", ("dir: '%s', name: '%s'",
                         dir, name));
515 516 517 518 519 520 521 522 523 524 525 526
    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));

527
    if ((m_file= fopen(m_file_name, "wb+")) == NULL)
528 529 530 531 532 533 534
      die("Failed to open log file %s, errno: %d", m_file_name, errno);

    DBUG_VOID_RETURN;
  }

  void close()
  {
535 536 537 538 539 540
    if (m_file) {
      if (m_file != stdout)
        fclose(m_file);
      else
        fflush(m_file);
    }
541 542 543 544 545 546
    m_file= NULL;
  }

  void flush()
  {
    if (m_file && m_file != stdout)
547 548 549 550
    {
      if (fflush(m_file))
        die("Failed to flush '%s', errno: %d", m_file_name, errno);
    }
551 552 553 554 555 556 557 558 559 560 561 562
  }

  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
563 564
      die("Failed to write %lu bytes to '%s', errno: %d",
          (unsigned long)ds->length, m_file_name, errno);
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
    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)
      {
        fprintf(stderr, "Failed to read from '%s', errno: %d\n",
                m_file_name, errno);
        DBUG_VOID_RETURN;
      }

Magnus Svensson's avatar
Magnus Svensson committed
602 603
      DBUG_PRINT("info", ("Read %lu bytes from file, buf: %s",
                          (unsigned long)bytes, buf));
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 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664

      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;


monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
665
/* Disable functions that only exist in MySQL 4.0 */
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
666
#if MYSQL_VERSION_ID < 40000
667 668 669
void mysql_enable_rpl_parse(MYSQL* mysql __attribute__((unused))) {}
void mysql_disable_rpl_parse(MYSQL* mysql __attribute__((unused))) {}
int mysql_rpl_parse_enabled(MYSQL* mysql __attribute__((unused))) { return 1; }
670
my_bool mysql_rpl_probe(MYSQL *mysql __attribute__((unused))) { return 1; }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
671
#endif
672 673 674 675
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);
676
void dynstr_append_sorted(DYNAMIC_STRING* ds, DYNAMIC_STRING* ds_input);
677

678 679 680
static int match_expected_error(struct st_command *command,
                                unsigned int err_errno,
                                const char *err_sqlstate);
681 682 683 684 685
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*);

686
#ifdef EMBEDDED_LIBRARY
687 688 689 690

/* attributes of the query thread */
pthread_attr_t cn_thd_attrib;

691
/*
692
  send_one_query executes query in separate thread, which is
693 694 695
  necessary in embedded library to run 'send' in proper way.
  This implementation doesn't handle errors returned
  by mysql_send_query. It's technically possible, though
696
  I don't see where it is needed.
697
*/
698
pthread_handler_t send_one_query(void *arg)
699
{
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
700
  struct st_connection *cn= (struct st_connection*)arg;
701 702 703 704 705 706 707 708 709 710 711 712 713

  mysql_thread_init();
  VOID(mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len));

  mysql_thread_end();
  pthread_mutex_lock(&cn->mutex);
  cn->query_done= 1;
  VOID(pthread_cond_signal(&cn->cond));
  pthread_mutex_unlock(&cn->mutex);
  pthread_exit(0);
  return 0;
}

holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
714
static int do_send_query(struct st_connection *cn, const char *q, int q_len,
715 716 717 718
                         int flags)
{
  pthread_t tid;

719
  if (flags & QUERY_REAP_FLAG)
720 721 722 723 724
    return mysql_send_query(&cn->mysql, q, q_len);

  if (pthread_mutex_init(&cn->mutex, NULL) ||
      pthread_cond_init(&cn->cond, NULL))
    die("Error in the thread library");
725

726 727 728
  cn->cur_query= q;
  cn->cur_query_len= q_len;
  cn->query_done= 0;
729
  if (pthread_create(&tid, &cn_thd_attrib, send_one_query, (void*)cn))
730 731 732 733 734
    die("Cannot start new thread for query");

  return 0;
}

735 736 737 738 739 740 741 742 743 744 745
static void wait_query_thread_end(struct st_connection *con)
{
  if (!con->query_done)
  {
    pthread_mutex_lock(&con->mutex);
    while (!con->query_done)
      pthread_cond_wait(&con->cond, &con->mutex);
    pthread_mutex_unlock(&con->mutex);
  }
}

746 747 748 749 750
#else /*EMBEDDED_LIBRARY*/

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

#endif /*EMBEDDED_LIBRARY*/
751 752 753

void do_eval(DYNAMIC_STRING *query_eval, const char *query,
             const char *query_end, my_bool pass_through_escape_chars)
754
{
755
  const char *p;
756
  register char c, next_c;
757
  register int escaped = 0;
758
  VAR *v;
monty@mysql.com's avatar
monty@mysql.com committed
759
  DBUG_ENTER("do_eval");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
760

761
  for (p= query; (c= *p) && p < query_end; ++p)
762 763 764 765 766
  {
    switch(c) {
    case '$':
      if (escaped)
      {
767
	escaped= 0;
768 769 770 771
	dynstr_append_mem(query_eval, p, 1);
      }
      else
      {
772
	if (!(v= var_get(p, &p, 0, 0)))
773 774 775 776 777
	  die("Bad variable in eval");
	dynstr_append_mem(query_eval, v->str_val, v->str_val_len);
      }
      break;
    case '\\':
778
      next_c= *(p+1);
779 780
      if (escaped)
      {
781
	escaped= 0;
782 783
	dynstr_append_mem(query_eval, p, 1);
      }
784 785 786 787 788 789 790 791 792 793 794
      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);
        }
      }
795
      else
796
	dynstr_append_mem(query_eval, p, 1);
797 798
      break;
    default:
799
      escaped= 0;
800 801
      dynstr_append_mem(query_eval, p, 1);
      break;
802
    }
803
  }
804 805 806
#ifdef __WIN__
    fix_win_paths(query_eval->str, query_eval->length);
#endif
monty@mysql.com's avatar
monty@mysql.com committed
807
  DBUG_VOID_RETURN;
808
}
809

810

811
/*
812
  Run query and dump the result to stderr in vertical format
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875

  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;
}


876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934
/*
  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
935
        fprintf(stderr, "%.*s ", (int)lengths[i],
936 937 938 939 940 941 942 943 944 945 946
                row[i] ? row[i] : "NULL");
      }
      fprintf(stderr, "\n");
    }
  }
  mysql_free_result(res);

  DBUG_VOID_RETURN;
}


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
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));
972

973 974 975
  for (i= 0; i < num_args; i++)
  {
    const struct command_arg *arg= &args[i];
976
    char delimiter;
977

978
    switch (arg->type) {
979 980 981 982 983 984
      /* A string */
    case ARG_STRING:
      /* Skip leading spaces */
      while (*ptr && *ptr == ' ')
        ptr++;
      start= ptr;
985 986 987 988 989 990 991 992 993
      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)
994 995 996 997 998 999 1000 1001 1002 1003 1004
        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);
      }
1005 1006 1007 1008 1009
      /* 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++;      

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
      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);

  }
1038 1039 1040 1041 1042 1043 1044 1045 1046
  /* Check for too many arguments passed */
  ptr= command->last_argument;
  while(ptr <= command->end)
  {
    if (*ptr && *ptr != ' ')
      die("Extra argument '%s' passed to '%.*s'",
          ptr, command->first_word_len, command->query);
    ptr++;
  }
1047 1048 1049 1050 1051 1052 1053 1054 1055
  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)
  {
1056
    int i;
1057 1058 1059 1060

    if (command->abort_on_error)
      die("command \"%.*s\" failed with error %d",
          command->first_word_len, command->query, error);
1061 1062 1063 1064

    i= match_expected_error(command, error, NULL);

    if (i >= 0)
1065
    {
1066 1067 1068
      DBUG_PRINT("info", ("command \"%.*s\" failed with expected error: %d",
                          command->first_word_len, command->query, error));
      DBUG_VOID_RETURN;
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
    }
    die("command \"%.*s\" failed with wrong error: %d",
        command->first_word_len, command->query, error);
  }
  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()
1086
{
1087 1088
  DBUG_ENTER("close_connections");
  for (--next_con; next_con >= connections; --next_con)
1089
  {
1090 1091 1092
    if (next_con->stmt)
      mysql_stmt_close(next_con->stmt);
    next_con->stmt= 0;
1093
    mysql_close(&next_con->mysql);
1094 1095
    if (next_con->util_mysql)
      mysql_close(next_con->util_mysql);
1096 1097 1098 1099 1100
    my_free(next_con->name, MYF(MY_ALLOW_ZERO_PTR));
  }
  DBUG_VOID_RETURN;
}

1101

1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
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;
}


1116
void close_files()
1117
{
1118
  DBUG_ENTER("close_files");
1119
  for (; cur_file >= file_stack; cur_file--)
1120
  {
1121
    if (cur_file->file && cur_file->file != stdin)
1122 1123
    {
      DBUG_PRINT("info", ("closing file: %s", cur_file->file_name));
1124
      my_fclose(cur_file->file, MYF(0));
1125
    }
1126
    my_free((uchar*) cur_file->file_name, MYF(MY_ALLOW_ZERO_PTR));
1127
    cur_file->file_name= 0;
1128 1129
  }
  DBUG_VOID_RETURN;
1130 1131
}

1132

1133
void free_used_memory()
1134 1135 1136
{
  uint i;
  DBUG_ENTER("free_used_memory");
1137 1138

  close_connections();
1139
  close_files();
Konstantin Osipov's avatar
Konstantin Osipov committed
1140
  my_hash_free(&var_hash);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1141

1142
  for (i= 0 ; i < q_lines.elements ; i++)
1143
  {
1144
    struct st_command **q= dynamic_element(&q_lines, i, struct st_command**);
1145
    my_free((*q)->query_buf,MYF(MY_ALLOW_ZERO_PTR));
1146 1147
    if ((*q)->content.str)
      dynstr_free(&(*q)->content);
1148
    my_free((*q),MYF(0));
1149
  }
1150
  for (i= 0; i < 10; i++)
1151 1152 1153 1154
  {
    if (var_reg[i].alloced_len)
      my_free(var_reg[i].str_val, MYF(MY_WME));
  }
1155 1156
  while (embedded_server_arg_count > 1)
    my_free(embedded_server_args[--embedded_server_arg_count],MYF(0));
1157 1158
  delete_dynamic(&q_lines);
  dynstr_free(&ds_res);
1159
  free_all_replace();
1160
  my_free(opt_pass,MYF(MY_ALLOW_ZERO_PTR));
1161
  free_defaults(default_argv);
1162 1163 1164 1165 1166
  free_re();
#ifdef __WIN__
  free_tmp_sh_file();
  free_win_path_patterns();
#endif
1167 1168 1169 1170 1171 1172

  /* 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() */
1173
  DBUG_VIOLATION_HELPER_LEAVE;
1174
  return;
1175 1176
}

1177

1178 1179 1180
static void cleanup_and_exit(int exit_code)
{
  free_used_memory();
1181
  my_end(my_end_arg);
1182

1183
  if (!silent) {
1184
    switch (exit_code) {
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
    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);
}

1203
void die(const char *fmt, ...)
1204
{
1205
  static int dying= 0;
1206
  va_list args;
1207
  DBUG_ENTER("die");
1208 1209
  DBUG_PRINT("enter", ("start_lineno: %d", start_lineno));

1210 1211 1212 1213 1214 1215 1216
  /*
    Protect against dying twice
    first time 'die' is called, try to write log files
    second time, just exit
  */
  if (dying)
    cleanup_and_exit(1);
1217
  dying= 1;
1218

1219
  /* Print the error message */
1220 1221 1222 1223 1224 1225
  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);
1226 1227
  if (fmt)
  {
1228
    va_start(args, fmt);
1229
    vfprintf(stderr, fmt, args);
1230
    va_end(args);
1231
  }
1232 1233 1234 1235
  else
    fprintf(stderr, "unknown error");
  fprintf(stderr, "\n");
  fflush(stderr);
1236

1237
  log_file.show_tail(opt_tail_lines);
1238

1239 1240 1241 1242 1243 1244 1245
  /*
    Help debugging by displaying any warnings that might have
    been produced prior to the error
  */
  if (cur_con)
    show_warnings_before_error(&cur_con->mysql);

1246
  cleanup_and_exit(1);
1247 1248
}

1249

1250
void abort_not_supported_test(const char *fmt, ...)
1251
{
1252 1253
  va_list args;
  struct st_test_file* err_file= cur_file;
1254
  DBUG_ENTER("abort_not_supported_test");
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278

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

1279
  cleanup_and_exit(62);
1280 1281
}

1282 1283 1284

void abort_not_in_this_version()
{
1285
  die("Not available in this version of mysqltest");
1286 1287 1288 1289
}


void verbose_msg(const char *fmt, ...)
1290 1291
{
  va_list args;
1292 1293 1294
  DBUG_ENTER("verbose_msg");
  if (!verbose)
    DBUG_VOID_RETURN;
1295 1296

  va_start(args, fmt);
1297
  fprintf(stderr, "mysqltest: ");
1298 1299 1300
  if (cur_file && cur_file != file_stack)
    fprintf(stderr, "In included file \"%s\": ",
            cur_file->file_name);
1301
  if (start_lineno != 0)
1302
    fprintf(stderr, "At line %u: ", start_lineno);
1303 1304 1305
  vfprintf(stderr, fmt, args);
  fprintf(stderr, "\n");
  va_end(args);
1306

1307
  DBUG_VOID_RETURN;
1308 1309
}

1310

1311 1312 1313
void log_msg(const char *fmt, ...)
{
  va_list args;
msvensson@shellback.(none)'s avatar
msvensson@shellback.(none) committed
1314
  char buff[1024];
1315 1316 1317 1318
  size_t len;
  DBUG_ENTER("log_msg");

  va_start(args, fmt);
1319
  len= my_vsnprintf(buff, sizeof(buff)-1, fmt, args);
1320 1321 1322 1323 1324 1325 1326 1327 1328
  va_end(args);

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

  DBUG_VOID_RETURN;
}


1329
/*
1330 1331 1332 1333 1334 1335 1336
  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

1337
*/
1338

1339
void cat_file(DYNAMIC_STRING* ds, const char* filename)
1340 1341
{
  int fd;
1342
  size_t len;
1343
  char buff[512];
1344

1345
  if ((fd= my_open(filename, O_RDONLY, MYF(0))) < 0)
1346
    die("Failed to open file '%s'", filename);
1347
  while((len= my_read(fd, (uchar*)&buff,
1348
                      sizeof(buff), MYF(0))) > 0)
1349
  {
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
    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);
1368
  }
1369 1370
  my_close(fd, MYF(0));
}
1371

1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393

/*
  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))
1394
  {
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
    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);
    }
1406
  }
1407

1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443
  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 *)))
1444
  {
1445 1446 1447 1448 1449 1450
    /* 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, " ");
1451
  }
1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466

  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);
}


1467 1468 1469 1470
/*
  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.
1471

1472 1473 1474 1475 1476 1477
  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.
*/

1478 1479 1480
#ifdef __WIN__

static int diff_check(const char *diff_name)
1481
{
1482
  FILE *res_file;
1483 1484
  char buf[128];
  int have_diff= 0;
1485

1486
  my_snprintf(buf, sizeof(buf), "%s -v", diff_name);
1487

1488 1489 1490 1491
  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 */
1492
  if (fgets(buf, sizeof(buf), res_file))
1493 1494
    have_diff= 1;

1495
  pclose(res_file);
1496

1497
  return have_diff;
1498
}
1499

1500 1501 1502
#endif


1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
/*
  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;
1520
  const char *diff_name = 0;
1521 1522

  if (init_dynamic_string(&ds_tmp, "", 256, 256))
1523
    die("Out of memory");
1524

1525 1526 1527
  /* determine if we have diff on Windows
     needs special processing due to return values
     on that OS
1528 1529 1530
     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.
1531
  */
Luis Soares's avatar
Luis Soares committed
1532
#ifdef __WIN__
1533 1534 1535 1536 1537 1538
  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
1539
#else
hery's avatar
hery committed
1540
  diff_name = "diff";           /* Otherwise always assume it's called diff */
1541
#endif
1542

1543
  if (diff_name)
1544
  {
1545
    /* First try with unified diff */
1546
    if (run_tool(diff_name,
1547
                 &ds_tmp, /* Get output from diff in ds_tmp */
1548
                 "-u",
1549 1550 1551 1552
                 filename1,
                 filename2,
                 "2>&1",
                 NULL) > 1) /* Most "diff" tools return >1 if error */
1553
    {
1554 1555
      dynstr_set(&ds_tmp, "");

1556
      /* Fallback to context diff with "diff -c" */
1557
      if (run_tool(diff_name,
1558
                   &ds_tmp, /* Get output from diff in ds_tmp */
1559
                   "-c",
1560 1561 1562 1563 1564
                   filename1,
                   filename2,
                   "2>&1",
                   NULL) > 1) /* Most "diff" tools return >1 if error */
      {
Luis Soares's avatar
Luis Soares committed
1565 1566 1567
	dynstr_set(&ds_tmp, "");

	/* Fallback to simple diff with "diff" */
1568
	if (run_tool(diff_name,
Luis Soares's avatar
Luis Soares committed
1569 1570 1571 1572 1573 1574
		     &ds_tmp, /* Get output from diff in ds_tmp */
		     filename1,
		     filename2,
		     "2>&1",
		     NULL) > 1) /* Most "diff" tools return >1 if error */
	    {
1575
		diff_name= 0;
Luis Soares's avatar
Luis Soares committed
1576
	    }
1577 1578
      }
    }
Luis Soares's avatar
Luis Soares committed
1579
  }  
1580

1581
  if (! diff_name)
1582 1583 1584 1585 1586 1587 1588
  {
    /*
      Fallback to dump both files to result file and inform
      about installing "diff"
    */
	dynstr_append(&ds_tmp, "\n");
    dynstr_append(&ds_tmp,
1589 1590
"\n"
"The two files differ but it was not possible to execute 'diff' in\n"
1591 1592
"order to show only the difference. Instead the whole content of the\n"
"two files was shown for you to diff manually.\n\n"
1593 1594 1595 1596 1597 1598 1599
"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");

1600 1601 1602 1603 1604 1605 1606 1607 1608
    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");
1609
  }
1610 1611 1612 1613 1614 1615

  if (ds)
  {
    /* Add the diff to output */
    dynstr_append_mem(ds, ds_tmp.str, ds_tmp.length);
  }
1616 1617
  else
  {
1618
    /* Print diff directly to stdout */
1619
    fprintf(stderr, "%s\n", ds_tmp.str);
1620
  }
1621 1622
 
  dynstr_free(&ds_tmp);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1623

1624
}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1625 1626


1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
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;
1651
  size_t len, len2;
1652
  char buff[512], buff2[512];
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1653

1654 1655 1656
  if ((fd2= my_open(filename2, O_RDONLY, MYF(0))) < 0)
  {
    my_close(fd, MYF(0));
1657
    die("Failed to open second file: '%s'", filename2);
1658
  }
1659
  while((len= my_read(fd, (uchar*)&buff,
1660 1661
                      sizeof(buff), MYF(0))) > 0)
  {
1662
    if ((len2= my_read(fd2, (uchar*)&buff2,
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681
                       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;
    }
  }
1682
  if (!error && my_read(fd2, (uchar*)&buff2,
1683 1684 1685 1686 1687 1688 1689
                        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
1690

1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
  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)
1714
    die("Failed to open first file: '%s'", filename1);
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739

  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;
1740
  char temp_file_path[FN_REFLEN];
1741 1742 1743 1744

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

1745
  if ((fd= create_temp_file(temp_file_path, TMPDIR,
1746 1747 1748 1749 1750
                            "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*/
1751
  if (my_write(fd, (uchar *) ds->str, ds->length,
1752 1753 1754 1755 1756
               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 */
1757 1758
    my_delete(temp_file_path, MYF(0));
    die("Failed to write file '%s'", temp_file_path);
1759 1760 1761 1762 1763 1764
  }

  error= compare_files2(fd, fname);

  my_close(fd, MYF(0));
  /* Remove the temporary file */
1765
  my_delete(temp_file_path, MYF(0));
1766 1767

  DBUG_RETURN(error);
1768 1769
}

1770 1771

/*
1772
  Check the content of log against result file
1773 1774 1775 1776 1777 1778 1779 1780 1781

  SYNOPSIS
  check_result

  RETURN VALUES
  error - the function will not return

*/

1782
void check_result()
1783
{
1784 1785
  const char* mess= "Result content mismatch\n";

1786
  DBUG_ENTER("check_result");
1787
  DBUG_ASSERT(result_file_name);
1788
  DBUG_PRINT("enter", ("result_file_name: %s", result_file_name));
1789

1790
  switch (compare_files(log_file.file_name(), result_file_name)) {
1791
  case RESULT_OK:
1792
    break; /* ok */
1793
  case RESULT_LENGTH_MISMATCH:
1794 1795
    mess= "Result length mismatch\n";
    /* Fallthrough */
1796
  case RESULT_CONTENT_MISMATCH:
1797
  {
1798 1799 1800 1801
    /*
      Result mismatched, dump results to .reject file
      and then show the diff
    */
1802
    char reject_file[FN_REFLEN];
1803
    size_t reject_length;
1804
    dirname_part(reject_file, result_file_name, &reject_length);
1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817

    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);
    }
1818

1819 1820 1821
    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);
1822 1823

    show_diff(NULL, result_file_name, reject_file);
1824
    die("%s", mess);
1825
    break;
1826
  }
1827 1828 1829
  default: /* impossible */
    die("Unknown error code from dyn_string_cmp()");
  }
1830 1831 1832 1833 1834

  DBUG_VOID_RETURN;
}


1835 1836 1837 1838 1839 1840
/*
  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
1841
  check_require
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
  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;
}


1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
/*
   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, '(', ')');
}


1908 1909
static uchar *get_var_key(const uchar* var, size_t *len,
                          my_bool __attribute__((unused)) t)
1910 1911 1912 1913
{
  register char* key;
  key = ((VAR*)var)->name;
  *len = ((VAR*)var)->name_len;
1914
  return (uchar*)key;
1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
}


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");

  tmp_var->name = (name) ? (char*) tmp_var + sizeof(*tmp_var) : 0;
  tmp_var->alloced = (v == 0);

1935
  if (!(tmp_var->str_val = (char*)my_malloc(val_alloc_len+1, MYF(MY_WME))))
1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
    die("Out of memory");

  memcpy(tmp_var->name, name, name_len);
  if (val)
  {
    memcpy(tmp_var->str_val, val, val_len);
    tmp_var->str_val[val_len]= 0;
  }
  tmp_var->name_len = name_len;
  tmp_var->str_val_len = val_len;
  tmp_var->alloced_len = val_alloc_len;
  tmp_var->int_val = (val) ? atoi(val) : 0;
  tmp_var->int_dirty = 0;
  tmp_var->env_s = 0;
  return tmp_var;
}


void var_free(void *v)
{
  my_free(((VAR*) v)->str_val, MYF(MY_WME));
  if (((VAR*)v)->alloced)
1958
    my_free(v, MYF(MY_WME));
1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
}


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));
1970
  my_hash_insert(&var_hash, (uchar*)v);
1971
  return v;
1972 1973
}

1974

1975
VAR* var_get(const char *var_name, const char **var_name_end, my_bool raw,
1976
	     my_bool ignore_not_existing)
1977 1978
{
  int digit;
1979
  VAR *v;
1980
  DBUG_ENTER("var_get");
1981
  DBUG_PRINT("enter", ("var_name: %s",var_name));
1982 1983

  if (*var_name != '$')
1984
    goto err;
1985
  digit = *++var_name - '0';
serg@serg.mylan's avatar
serg@serg.mylan committed
1986
  if (digit < 0 || digit >= 10)
1987
  {
1988
    const char *save_var_name = var_name, *end;
1989
    uint length;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1990
    end = (var_name_end) ? *var_name_end : 0;
1991
    while (my_isvar(charset_info,*var_name) && var_name != end)
1992
      var_name++;
1993 1994 1995 1996
    if (var_name == save_var_name)
    {
      if (ignore_not_existing)
	DBUG_RETURN(0);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1997
      die("Empty variable");
1998
    }
1999
    length= (uint) (var_name - save_var_name);
2000
    if (length >= MAX_VAR_NAME_LENGTH)
2001
      die("Too long variable name: %s", save_var_name);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2002

Konstantin Osipov's avatar
Konstantin Osipov committed
2003 2004
    if (!(v = (VAR*) my_hash_search(&var_hash, (const uchar*) save_var_name,
                                    length)))
2005
    {
2006
      char buff[MAX_VAR_NAME_LENGTH+1];
serg@serg.mylan's avatar
serg@serg.mylan committed
2007
      strmake(buff, save_var_name, length);
2008
      v= var_from_env(buff, "");
2009
    }
2010
    var_name--;	/* Point at last character */
2011
  }
2012
  else
2013
    v = var_reg + digit;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2014

2015 2016 2017 2018
  if (!raw && v->int_dirty)
  {
    sprintf(v->str_val, "%d", v->int_val);
    v->int_dirty = 0;
2019
    v->str_val_len = strlen(v->str_val);
2020
  }
2021
  if (var_name_end)
2022
    *var_name_end = var_name  ;
2023
  DBUG_RETURN(v);
2024 2025
err:
  if (var_name_end)
2026 2027
    *var_name_end = 0;
  die("Unsupported variable name: %s", var_name);
2028
  DBUG_RETURN(0);
2029 2030
}

2031 2032

VAR *var_obtain(const char *name, int len)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2033 2034
{
  VAR* v;
Konstantin Osipov's avatar
Konstantin Osipov committed
2035
  if ((v = (VAR*)my_hash_search(&var_hash, (const uchar *) name, len)))
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2036
    return v;
2037
  v = var_init(0, name, len, "", 0);
2038
  my_hash_insert(&var_hash, (uchar*)v);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2039 2040 2041
  return v;
}

2042 2043 2044 2045 2046 2047 2048 2049 2050

/*
  - 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)
2051
{
2052 2053
  int digit, env_var= 0;
  VAR *v;
2054 2055 2056 2057 2058 2059
  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)));

2060 2061 2062 2063 2064 2065 2066
  if (*var_name != '$')
    env_var= 1;
  else
    var_name++;

  digit= *var_name - '0';
  if (!(digit < 10 && digit >= 0))
2067
  {
2068
    v= var_obtain(var_name, (uint) (var_name_end - var_name));
2069
  }
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083
  else
    v= var_reg + digit;

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

  if (env_var)
  {
    char buf[1024], *old_env_s= v->env_s;
    if (v->int_dirty)
    {
      sprintf(v->str_val, "%d", v->int_val);
      v->int_dirty= 0;
      v->str_val_len= strlen(v->str_val);
    }
2084 2085 2086
    my_snprintf(buf, sizeof(buf), "%.*s=%.*s",
                v->name_len, v->name,
                v->str_val_len, v->str_val);
2087 2088 2089
    if (!(v->env_s= my_strdup(buf, MYF(MY_WME))))
      die("Out of memory");
    putenv(v->env_s);
2090
    my_free(old_env_s, MYF(MY_ALLOW_ZERO_PTR));
2091 2092 2093 2094
  }
  DBUG_VOID_RETURN;
}

2095 2096 2097 2098 2099 2100 2101 2102 2103 2104

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];
2105
  my_snprintf(buf, sizeof(buf), "%d", value);
2106 2107 2108 2109
  var_set_string(name, buf);
}


2110 2111
/*
  Store an integer (typically the returncode of the last SQL)
2112
  statement in the mysqltest builtin variable $mysql_errno
2113 2114 2115 2116
*/

void var_set_errno(int sql_errno)
{
2117
  var_set_int("$mysql_errno", sql_errno);
2118 2119
}

2120

2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
/*
  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)
{
2146
  char *end = (char*)((query_end && *query_end) ?
2147 2148 2149 2150
		      *query_end : query + strlen(query));
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL* mysql = &cur_con->mysql;
2151
  DYNAMIC_STRING ds_query;
2152 2153 2154 2155 2156 2157 2158 2159 2160
  DBUG_ENTER("var_query_set");
  LINT_INIT(res);

  while (end > query && *end != '`')
    --end;
  if (query == end)
    die("Syntax error in query, missing '`'");
  ++query;

2161 2162 2163 2164
  /* 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);

2165
  if (mysql_real_query(mysql, ds_query.str, ds_query.length))
2166
    die("Error running query '%s': %d %s", ds_query.str,
2167
	mysql_errno(mysql), mysql_error(mysql));
2168 2169
  if (!(res= mysql_store_result(mysql)))
    die("Query '%s' didn't return a result set", ds_query.str);
2170
  dynstr_free(&ds_query);
2171

2172
  if ((row= mysql_fetch_row(res)) && row[0])
2173
  {
2174
    /*
2175 2176
      Concatenate all fields in the first row with tab in between
      and assign that string to the $variable
2177 2178 2179 2180 2181
    */
    DYNAMIC_STRING result;
    uint i;
    ulong *lengths;

2182
    init_dynamic_string(&result, "", 512, 512);
2183
    lengths= mysql_fetch_lengths(res);
2184
    for (i= 0; i < mysql_num_fields(res); i++)
2185
    {
2186
      if (row[i])
2187 2188 2189 2190 2191 2192 2193 2194 2195
      {
        /* 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;
    eval_expr(var, result.str, (const char**) &end);
    dynstr_free(&result);
2196
  }
2197
  else
2198 2199 2200 2201 2202 2203 2204
    eval_expr(var, "", 0);

  mysql_free_result(res);
  DBUG_VOID_RETURN;
}


2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
/*
  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)
{
2229
  long row_no;
2230 2231 2232 2233 2234 2235 2236 2237
  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[] = {
2238 2239 2240
    {"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"}
2241 2242 2243
  };

  DBUG_ENTER("var_set_query_get_value");
2244
  LINT_INIT(res);
2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 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 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300

  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;
2301
    long rows= 0;
2302 2303 2304 2305
    const char* value= "No such row";

    while ((row= mysql_fetch_row(res)))
    {
msvensson@pilot.(none)'s avatar
msvensson@pilot.(none) committed
2306
      if (++rows == row_no)
2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328
      {

        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;
}


2329 2330 2331 2332 2333 2334 2335 2336
void var_copy(VAR *dest, VAR *src)
{
  dest->int_val= src->int_val;
  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
2337 2338
        ? (char*)my_realloc(dest->str_val, src->alloced_len, MYF(MY_WME))
        : (char*)my_malloc(src->alloced_len, MYF(MY_WME))))
2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351
    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);
}


void eval_expr(VAR *v, const char *p, const char **p_end)
{
2352 2353 2354 2355

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

2356 2357
  if (*p == '$')
  {
2358
    VAR *vp;
2359
    const char* expected_end= *p_end; // Remember var end
2360 2361
    if ((vp= var_get(p, p_end, 0, 0)))
      var_copy(v, vp);
2362 2363 2364 2365 2366

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

2369
    DBUG_VOID_RETURN;
2370
  }
2371 2372

  if (*p == '`')
2373 2374
  {
    var_query_set(v, p, p_end);
2375
    DBUG_VOID_RETURN;
2376
  }
2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394

  {
    /* 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;
    }
  }

2395 2396 2397 2398 2399
  {
    int new_val_len = (p_end && *p_end) ?
      (int) (*p_end - p) : (int) strlen(p);
    if (new_val_len + 1 >= v->alloced_len)
    {
2400
      static int MIN_VAR_ALLOC= 32;
2401 2402 2403
      v->alloced_len = (new_val_len < MIN_VAR_ALLOC - 1) ?
        MIN_VAR_ALLOC : new_val_len + 1;
      if (!(v->str_val =
2404 2405 2406
            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))))
2407 2408 2409 2410 2411 2412
        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;
    v->int_val=atoi(p);
2413
    DBUG_PRINT("info", ("atoi on '%s', returns: %d", p, v->int_val));
2414 2415
    v->int_dirty=0;
  }
2416
  DBUG_VOID_RETURN;
2417 2418
}

2419

2420
int open_file(const char *name)
2421
{
joerg@mysql.com's avatar
joerg@mysql.com committed
2422
  char buff[FN_REFLEN];
msvensson@pilot.mysql.com's avatar
msvensson@pilot.mysql.com committed
2423
  size_t length;
2424 2425
  DBUG_ENTER("open_file");
  DBUG_PRINT("enter", ("name: %s", name));
msvensson@pilot.mysql.com's avatar
msvensson@pilot.mysql.com committed
2426 2427 2428 2429 2430 2431 2432 2433 2434 2435

  /* 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;
    }
  }
2436 2437 2438 2439 2440
  if (!test_if_hard_path(name))
  {
    strxmov(buff, opt_basedir, name, NullS);
    name=buff;
  }
2441
  fn_format(buff, name, "", "", MY_UNPACK_FILENAME);
2442

2443
  if (cur_file == file_stack_end)
2444
    die("Source directives are nesting too deep");
2445
  cur_file++;
2446 2447 2448
  if (!(cur_file->file = my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(0))))
  {
    cur_file--;
2449
    die("Could not open '%s' for reading, errno: %d", buff, errno);
2450 2451
  }
  cur_file->file_name= my_strdup(buff, MYF(MY_FAE));
2452
  cur_file->lineno=1;
2453
  DBUG_RETURN(0);
2454
}
2455

2456 2457

/*
2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468
  Source and execute the given file

  SYNOPSIS
  do_source()
  query	called command

  DESCRIPTION
  source <file_name>

  Open the file <file_name> and execute it

2469 2470
*/

2471
void do_source(struct st_command *command)
2472
{
2473
  static DYNAMIC_STRING ds_filename;
2474
  const struct command_arg source_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
2475
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to source" }
2476 2477
  };
  DBUG_ENTER("do_source");
2478

2479 2480 2481
  check_command_args(command, command->first_argument, source_args,
                     sizeof(source_args)/sizeof(struct command_arg),
                     ' ');
2482

2483 2484 2485 2486 2487 2488 2489
  /*
    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
2490
  {
2491 2492
    DBUG_PRINT("info", ("sourcing file: %s", ds_filename.str));
    open_file(ds_filename.str);
2493
  }
2494 2495

  dynstr_free(&ds_filename);
2496
  DBUG_VOID_RETURN;
2497 2498
}

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

2500 2501 2502
#if defined __WIN__

#ifdef USE_CYGWIN
2503
/* Variables used for temporary sh files used for emulating Unix on Windows */
2504
char tmp_sh_name[64], tmp_sh_cmd[70];
2505
#endif
2506 2507

void init_tmp_sh_file()
2508
{
2509
#ifdef USE_CYGWIN
2510 2511 2512 2513
  /* 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);
2514
#endif
2515
}
2516

2517

2518
void free_tmp_sh_file()
2519
{
2520
#ifdef USE_CYGWIN
2521
  my_delete(tmp_sh_name, MYF(0));
2522
#endif
2523
}
2524
#endif
2525

2526

2527
FILE* my_popen(DYNAMIC_STRING *ds_cmd, const char *mode)
2528
{
2529
#if defined __WIN__ && defined USE_CYGWIN
2530 2531 2532 2533 2534 2535
  /* 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
2536 2537
}

2538

2539 2540 2541
static void init_builtin_echo(void)
{
#ifdef __WIN__
2542
  size_t echo_length;
2543 2544

  /* Look for "echo.exe" in same dir as mysqltest was started from */
2545
  dirname_part(builtin_echo, my_progname, &echo_length);
2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
  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;
}


2598 2599 2600 2601
/*
  Execute given command.

  SYNOPSIS
2602 2603
  do_exec()
  query	called command
2604 2605

  DESCRIPTION
2606
  exec <command>
2607

2608 2609 2610 2611
  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.
2612

2613 2614 2615
  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
2616
  mysqltest commmand(s) like "remove_file" for that
2617 2618
*/

2619
void do_exec(struct st_command *command)
2620
{
kent@mysql.com's avatar
kent@mysql.com committed
2621
  int error;
2622
  char buf[512];
2623
  FILE *res_file;
2624 2625
  char *cmd= command->first_argument;
  DYNAMIC_STRING ds_cmd;
monty@mysql.com's avatar
monty@mysql.com committed
2626
  DBUG_ENTER("do_exec");
2627
  DBUG_PRINT("enter", ("cmd: '%s'", cmd));
2628

2629
  /* Skip leading space */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2630
  while (*cmd && my_isspace(charset_info, *cmd))
2631 2632
    cmd++;
  if (!*cmd)
2633
    die("Missing argument in exec");
2634 2635 2636 2637
  command->last_argument= command->end;

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

2640 2641 2642 2643 2644 2645 2646
  /* 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));
  }

2647
#ifdef __WIN__
2648
#ifndef USE_CYGWIN
2649 2650 2651 2652 2653 2654
  /* 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)
    ;
2655
#endif
2656 2657
#endif

2658
  DBUG_PRINT("info", ("Executing '%s' as '%s'",
2659
                      command->first_argument, ds_cmd.str));
monty@mysql.com's avatar
monty@mysql.com committed
2660

2661
  if (!(res_file= my_popen(&ds_cmd, "r")) && command->abort_on_error)
2662 2663
  {
    dynstr_free(&ds_cmd);
2664
    die("popen(\"%s\", \"r\") failed", command->first_argument);
2665
  }
monty@mysql.com's avatar
monty@mysql.com committed
2666

2667
  while (fgets(buf, sizeof(buf), res_file))
2668
  {
2669
    if (disable_result_log)
2670 2671 2672 2673
    {
      buf[strlen(buf)-1]=0;
      DBUG_PRINT("exec_result",("%s", buf));
    }
2674
    else
2675
    {
2676
      replace_dynstr_append(&ds_res, buf);
2677
    }
kent@mysql.com's avatar
kent@mysql.com committed
2678 2679
  }
  error= pclose(res_file);
2680
  if (error > 0)
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2681
  {
2682 2683
    uint status= WEXITSTATUS(error);
    int i;
monty@mishka.local's avatar
monty@mishka.local committed
2684

2685
    if (command->abort_on_error)
2686
    {
msvensson@shellback.(none)'s avatar
msvensson@shellback.(none) committed
2687
      log_msg("exec of '%s' failed, error: %d, status: %d, errno: %d",
2688
              ds_cmd.str, error, status, errno);
2689
      dynstr_free(&ds_cmd);
2690 2691
      die("command \"%s\" failed\n\nOutput from before failure:\n%s\n",
          command->first_argument, ds_res.str);
2692
    }
monty@mishka.local's avatar
monty@mishka.local committed
2693 2694 2695

    DBUG_PRINT("info",
               ("error: %d, status: %d", error, status));
2696 2697 2698 2699 2700 2701 2702

    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
2703 2704
    {
      dynstr_free(&ds_cmd);
2705
      die("command \"%s\" failed with wrong error: %d",
2706
          command->first_argument, status);
2707
    }
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2708
  }
2709 2710
  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
2711 2712
  {
    /* Error code we wanted was != 0, i.e. not an expected success */
2713 2714
    log_msg("exec of '%s failed, error: %d, errno: %d",
            ds_cmd.str, error, errno);
2715
    dynstr_free(&ds_cmd);
2716
    die("command \"%s\" succeeded - should have failed with errno %d...",
2717
        command->first_argument, command->expected_errors.err[0].code.errnum);
2718
  }
2719

2720 2721
  dynstr_free(&ds_cmd);
  DBUG_VOID_RETURN;
2722 2723
}

2724
enum enum_operator
2725
{
2726 2727 2728
  DO_DEC,
  DO_INC
};
2729

2730

2731
/*
2732
  Decrease or increase the value of a variable
2733 2734

  SYNOPSIS
2735 2736
  do_modify_var()
  query	called command
2737
  op    operation to perform on the var
2738 2739

  DESCRIPTION
2740 2741
  dec $var_name
  inc $var_name
2742

2743 2744
*/

2745
int do_modify_var(struct st_command *command,
2746
                  enum enum_operator op)
2747
{
2748
  const char *p= command->first_argument;
2749
  VAR* v;
2750
  if (!*p)
2751
    die("Missing argument to %.*s", command->first_word_len, command->query);
2752
  if (*p != '$')
2753 2754
    die("The argument to %.*s must be a variable (start with $)",
        command->first_word_len, command->query);
2755
  v= var_get(p, &p, 1, 0);
2756
  switch (op) {
2757 2758 2759 2760 2761 2762 2763
  case DO_DEC:
    v->int_val--;
    break;
  case DO_INC:
    v->int_val++;
    break;
  default:
2764
    die("Invalid operator to do_modify_var");
2765 2766 2767
    break;
  }
  v->int_dirty= 1;
2768
  command->last_argument= (char*)++p;
2769 2770 2771
  return 0;
}

2772

2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784
/*
  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)
2785
{
2786
#if defined __WIN__ && defined USE_CYGWIN
2787 2788 2789 2790 2791 2792
  /* 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
2793
}
2794

2795 2796 2797

/*
  SYNOPSIS
2798 2799
  do_system
  command	called command
2800 2801

  DESCRIPTION
2802
  system <command>
2803

2804 2805
  Eval the query to expand any $variables in the command.
  Execute the command with the "system" command.
2806 2807 2808

*/

2809
void do_system(struct st_command *command)
2810
{
2811 2812
  DYNAMIC_STRING ds_cmd;
  DBUG_ENTER("do_system");
2813

2814 2815
  if (strlen(command->first_argument) == 0)
    die("Missing arguments to system, nothing to do!");
2816

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

2819
  /* Eval the system command, thus replacing all environment variables */
2820 2821 2822
  do_eval(&ds_cmd, command->first_argument, command->end, !is_windows);

#ifdef __WIN__
2823
#ifndef USE_CYGWIN
2824 2825 2826 2827
   /* Replace /dev/null with NUL */
   while(replace(&ds_cmd, "/dev/null", 9, "NUL", 3) == 0)
     ;
#endif
2828
#endif
2829

2830

2831 2832 2833
  DBUG_PRINT("info", ("running system command '%s' as '%s'",
                      command->first_argument, ds_cmd.str));
  if (my_system(&ds_cmd))
2834
  {
2835 2836
    if (command->abort_on_error)
      die("system command '%s' failed", command->first_argument);
2837

2838 2839 2840 2841
    /* 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");
2842
  }
2843

2844 2845 2846 2847
  command->last_argument= command->end;
  dynstr_free(&ds_cmd);
  DBUG_VOID_RETURN;
}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2848

2849

2850 2851 2852 2853
/*
  SYNOPSIS
  do_remove_file
  command	called command
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2854

2855 2856 2857 2858
  DESCRIPTION
  remove_file <file_name>
  Remove the file <file_name>
*/
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2859

2860 2861 2862
void do_remove_file(struct st_command *command)
{
  int error;
2863
  static DYNAMIC_STRING ds_filename;
2864
  const struct command_arg rm_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
2865
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to delete" }
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
  };
  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;
2878 2879 2880
}


2881 2882
/*
  SYNOPSIS
2883 2884
  do_copy_file
  command	command handle
2885 2886

  DESCRIPTION
2887 2888
  copy_file <from_file> <to_file>
  Copy <from_file> to <to_file>
2889

2890 2891
  NOTE! Will fail if <to_file> exists
*/
2892

2893
void do_copy_file(struct st_command *command)
2894
{
2895
  int error;
2896 2897
  static DYNAMIC_STRING ds_from_file;
  static DYNAMIC_STRING ds_to_file;
2898
  const struct command_arg copy_file_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
2899 2900
    { "from_file", ARG_STRING, TRUE, &ds_from_file, "Filename to copy from" },
    { "to_file", ARG_STRING, TRUE, &ds_to_file, "Filename to copy to" }
2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915
  };
  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;
2916 2917
}

2918

2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954
/*
  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;
}


2955 2956 2957 2958 2959 2960
/*
  SYNOPSIS
  do_chmod_file
  command	command handle

  DESCRIPTION
msvensson@pilot.mysql.com's avatar
msvensson@pilot.mysql.com committed
2961
  chmod <octal> <file_name>
2962
  Change file permission of <file_name>
2963 2964 2965 2966 2967

*/

void do_chmod_file(struct st_command *command)
{
2968
  long mode= 0;
2969
  int err_code;
2970 2971
  static DYNAMIC_STRING ds_mode;
  static DYNAMIC_STRING ds_file;
2972
  const struct command_arg chmod_file_args[] = {
2973 2974
    { "mode", ARG_STRING, TRUE, &ds_mode, "Mode of file(octal) ex. 0660"}, 
    { "filename", ARG_STRING, TRUE, &ds_file, "Filename of file to modify" }
2975 2976 2977 2978 2979 2980 2981 2982 2983
  };
  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 */
2984 2985
  if (ds_mode.length != 4 ||
      str2int(ds_mode.str, 8, 0, INT_MAX, &mode) == NullS)
2986 2987
    die("You must write a 4 digit octal number for mode");

2988
  DBUG_PRINT("info", ("chmod %o %s", (uint)mode, ds_file.str));
2989 2990 2991 2992
  err_code= chmod(ds_file.str, mode);
  if (err_code < 0)
    err_code= 1;
  handle_command_error(command, err_code);
2993 2994 2995 2996 2997 2998
  dynstr_free(&ds_mode);
  dynstr_free(&ds_file);
  DBUG_VOID_RETURN;
}


2999
/*
3000 3001 3002 3003 3004 3005 3006
  SYNOPSIS
  do_file_exists
  command	called command

  DESCRIPTION
  fiile_exist <file_name>
  Check if file <file_name> exists
3007 3008
*/

3009
void do_file_exist(struct st_command *command)
3010
{
3011
  int error;
3012
  static DYNAMIC_STRING ds_filename;
3013
  const struct command_arg file_exist_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3014
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to check if it exist" }
3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027
  };
  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;
3028 3029
}

3030

3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045
/*
  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[] = {
3046
    {"dirname", ARG_STRING, TRUE, &ds_dirname, "Directory to create"}
3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075
  };
  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[] = {
3076
    {"dirname", ARG_STRING, TRUE, &ds_dirname, "Directory to remove"}
3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091
  };
  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;
}


3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 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 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211
/*
  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);
  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;
    dynstr_append(ds, file->name);
    dynstr_append(ds, "\n");
  }
  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");

  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");

  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;
}


3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222
/*
  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)
3223
{
3224 3225 3226
  if (line_buffer_pos == line_buffer)
    return fgetc(file);
  return *--line_buffer_pos;
3227 3228
}

3229

3230
void my_ungetc(int c)
3231
{
3232
  *line_buffer_pos++= (char) c;
3233 3234
}

3235

3236 3237
void read_until_delimiter(DYNAMIC_STRING *ds,
                          DYNAMIC_STRING *ds_delimiter)
3238
{
3239
  char c;
3240
  DBUG_ENTER("read_until_delimiter");
3241 3242
  DBUG_PRINT("enter", ("delimiter: %s, length: %u",
                       ds_delimiter->str, (uint) ds_delimiter->length));
3243 3244 3245 3246 3247 3248 3249 3250 3251 3252

  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')
3253
    {
3254 3255
      cur_file->lineno++;

3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268
      /* 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");
    }

3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281
    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;
3282 3283 3284
}


3285 3286 3287 3288 3289 3290
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
3291 3292
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to write to" },
    { "delimiter", ARG_STRING, FALSE, &ds_delimiter, "Delimiter to read until" }
3293 3294 3295 3296 3297 3298 3299 3300 3301
  };
  DBUG_ENTER("do_write_file");

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

3302 3303 3304 3305 3306 3307
  if (!append && access(ds_filename.str, F_OK) == 0)
  {
    /* The file should not be overwritten */
    die("File already exist: '%s'", ds_filename.str);
  }

3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325
  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);
  }
3326 3327 3328 3329 3330 3331
  dynstr_free(&ds_filename);
  dynstr_free(&ds_delimiter);
  DBUG_VOID_RETURN;
}


3332 3333
/*
  SYNOPSIS
3334 3335
  do_write_file
  command	called command
3336 3337

  DESCRIPTION
3338 3339 3340 3341 3342
  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
3343

3344 3345 3346 3347 3348
  --write_file <file_name>;
  <what to write line 1>
  <...>
  < what to write line n>
  EOF
3349

3350 3351
  Write everything between the "write_file" command and 'delimiter'
  to "file_name"
3352

3353
  NOTE! Will fail if <file_name> exists
3354

3355
  Default <delimiter> is EOF
3356

3357
*/
3358

3359
void do_write_file(struct st_command *command)
3360
{
3361 3362
  do_write_file_command(command, FALSE);
}
3363 3364


3365 3366 3367 3368
/*
  SYNOPSIS
  do_append_file
  command	called command
3369

3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392
  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);
3393 3394
}

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

3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411
/*
  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)
{
  static DYNAMIC_STRING ds_filename;
  const struct command_arg cat_file_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3412
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to read from" }
3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423
  };
  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));

3424 3425
  cat_file(&ds_res, ds_filename.str);

3426 3427 3428 3429 3430
  dynstr_free(&ds_filename);
  DBUG_VOID_RETURN;
}


3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448
/*
  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
3449 3450
    { "file1", ARG_STRING, TRUE, &ds_filename, "First file to diff" },
    { "file2", ARG_STRING, TRUE, &ds_filename2, "Second file to diff" }
3451 3452 3453 3454 3455 3456 3457 3458 3459
  };
  DBUG_ENTER("do_diff_files");

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

3460 3461 3462 3463 3464 3465 3466 3467
  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);

3468 3469
  if ((error= compare_files(ds_filename.str, ds_filename2.str)) &&
      match_expected_error(command, error, NULL) < 0)
3470
  {
3471
    /* Compare of the two files failed, append them to output
3472 3473
       so the failure can be analyzed, but only if it was not
       expected to fail.
3474 3475
    */
    show_diff(&ds_res, ds_filename.str, ds_filename2.str);
3476 3477 3478
    log_file.write(&ds_res);
    log_file.flush();
    dynstr_set(&ds_res, 0);
3479 3480 3481 3482 3483 3484 3485 3486
  }

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

3487

3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500
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 */
}

3501

3502 3503 3504 3505 3506 3507 3508 3509 3510
/*
  SYNOPSIS
  do_send_quit
  command	called command

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

*/
3511 3512 3513 3514 3515 3516 3517 3518 3519 3520

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)
3521
    die("Missing connection name in send_quit");
3522 3523 3524 3525 3526 3527 3528 3529
  name= p;
  while (*p && !my_isspace(charset_info,*p))
    p++;

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

3530 3531 3532
  if (!(con= find_connection_by_name(name)))
    die("connection '%s' not found in connection pool", name);

3533
  simple_command(&con->mysql,COM_QUIT,0,0,1);
3534 3535

  DBUG_VOID_RETURN;
3536 3537 3538
}


3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572
/*
  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 keyword to make the NetWare compiler happy. */
  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),
                     ',');

3573 3574 3575 3576 3577 3578
  if (cur_con->stmt)
  {
    mysql_stmt_close(cur_con->stmt);
    cur_con->stmt= NULL;
  }

3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601
  if (!ds_user.length)
    dynstr_set(&ds_user, mysql->user);

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

  if (!ds_db.length)
    dynstr_set(&ds_db, mysql->db);

  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;
}


3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612
/*
  SYNOPSIS
  do_perl
  command	command handle

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

3614 3615 3616 3617 3618 3619 3620 3621
  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
3622
{
3623
  int error;
3624
  File fd;
3625
  FILE *res_file;
3626 3627
  char buf[FN_REFLEN];
  char temp_file_path[FN_REFLEN];
3628 3629
  static DYNAMIC_STRING ds_script;
  static DYNAMIC_STRING ds_delimiter;
3630
  const struct command_arg perl_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
3631
    { "delimiter", ARG_STRING, FALSE, &ds_delimiter, "Delimiter to read until" }
3632 3633
  };
  DBUG_ENTER("do_perl");
3634

3635 3636 3637 3638 3639
  check_command_args(command,
                     command->first_argument,
                     perl_args,
                     sizeof(perl_args)/sizeof(struct command_arg),
                     ' ');
3640

3641 3642 3643
  /* 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
3644

3645 3646
  init_dynamic_string(&ds_script, "", 1024, 1024);
  read_until_delimiter(&ds_script, &ds_delimiter);
3647

3648
  DBUG_PRINT("info", ("Executing perl: %s", ds_script.str));
3649

3650 3651 3652 3653 3654 3655
  /* 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));
3656

3657
  str_to_file(temp_file_path, ds_script.str, ds_script.length);
3658

3659 3660
  /* Format the "perl <filename>" command */
  my_snprintf(buf, sizeof(buf), "perl %s", temp_file_path);
3661

3662 3663
  if (!(res_file= popen(buf, "r")) && command->abort_on_error)
    die("popen(\"%s\", \"r\") failed", buf);
3664

3665
  while (fgets(buf, sizeof(buf), res_file))
3666
  {
3667
    if (disable_result_log)
3668
    {
3669 3670
      buf[strlen(buf)-1]=0;
      DBUG_PRINT("exec_result",("%s", buf));
3671 3672
    }
    else
3673
    {
3674
      replace_dynstr_append(&ds_res, buf);
3675 3676
    }
  }
3677
  error= pclose(res_file);
3678 3679 3680 3681

  /* Remove the temporary file */
  my_delete(temp_file_path, MYF(0));

3682 3683 3684 3685
  handle_command_error(command, WEXITSTATUS(error));
  dynstr_free(&ds_script);
  dynstr_free(&ds_delimiter);
  DBUG_VOID_RETURN;
3686 3687 3688 3689
}


/*
3690 3691 3692
  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 \
3693

3694 3695 3696
  SYNOPSIS
  do_echo()
  command  called command
3697

3698 3699 3700
  DESCRIPTION
  echo text
  Print the text after echo until end of command to result file
3701

3702 3703
  echo $<var_name>
  Print the content of the variable <var_name> to result file
3704

3705 3706 3707 3708 3709 3710 3711 3712 3713
  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)
3714
{
3715
  DYNAMIC_STRING ds_echo;
3716
  DBUG_ENTER("do_echo");
3717 3718 3719 3720 3721 3722 3723

  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;
3724
  DBUG_RETURN(0);
3725 3726
}

3727

3728
void do_wait_for_slave_to_stop(struct st_command *c __attribute__((unused)))
3729
{
3730 3731 3732
  static int SLAVE_POLL_INTERVAL= 300000;
  MYSQL* mysql = &cur_con->mysql;
  for (;;)
3733
  {
3734
    MYSQL_RES *UNINIT_VAR(res);
3735 3736 3737 3738 3739 3740 3741 3742
    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])
3743
    {
3744 3745
      mysql_free_result(res);
      die("Strange result from query while probing slave for stop");
3746
    }
3747 3748 3749 3750 3751
    done = !strcmp(row[1],"OFF");
    mysql_free_result(res);
    if (done)
      break;
    my_sleep(SLAVE_POLL_INTERVAL);
3752
  }
3753
  return;
3754 3755
}

3756

3757
void do_sync_with_master2(struct st_command *command, long offset)
3758
{
3759 3760 3761 3762
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL *mysql= &cur_con->mysql;
  char query_buf[FN_REFLEN+128];
3763
  int timeout= 300; /* seconds */
3764

3765 3766
  if (!master_pos.file[0])
    die("Calling 'sync_with_master' without calling 'save_master_pos'");
3767

3768 3769
  sprintf(query_buf, "select master_pos_wait('%s', %ld, %d)",
          master_pos.file, master_pos.pos + offset, timeout);
3770

3771 3772 3773
  if (mysql_query(mysql, query_buf))
    die("failed in '%s': %d: %s", query_buf, mysql_errno(mysql),
        mysql_error(mysql));
3774

3775 3776 3777
  if (!(res= mysql_store_result(mysql)))
    die("mysql_store_result() returned NULL for '%s'", query_buf);
  if (!(row= mysql_fetch_row(res)))
3778 3779
  {
    mysql_free_result(res);
3780
    die("empty result in %s", query_buf);
3781
  }
3782 3783 3784 3785 3786 3787 3788 3789 3790

  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)
3791
  {
3792 3793 3794 3795 3796 3797 3798
    /* 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)
3799
    {
3800 3801 3802 3803 3804 3805 3806 3807 3808 3809
      /*
        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);

3810
    }
3811 3812 3813 3814 3815 3816 3817 3818

    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);
3819
  }
3820

3821 3822
  return;
}
3823

3824
void do_sync_with_master(struct st_command *command)
3825
{
3826 3827 3828 3829
  long offset= 0;
  char *p= command->first_argument;
  const char *offset_start= p;
  if (*offset_start)
3830
  {
3831 3832
    for (; my_isdigit(charset_info, *p); p++)
      offset = offset * 10 + *p - '0';
3833

3834 3835 3836 3837
    if(*p && !my_isspace(charset_info, *p))
      die("Invalid integer argument \"%s\"", offset_start);
    command->last_argument= p;
  }
3838
  do_sync_with_master2(command, offset);
3839
  return;
3840 3841
}

3842 3843 3844 3845 3846 3847

/*
  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()
3848
{
3849 3850 3851 3852 3853
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL *mysql = &cur_con->mysql;
  const char *query;
  int rpl_parse;
3854
  DBUG_ENTER("do_save_master_pos");
3855

3856 3857
  rpl_parse = mysql_rpl_parse_enabled(mysql);
  mysql_disable_rpl_parse(mysql);
3858

3859 3860 3861 3862 3863
#ifdef HAVE_NDB_BINLOG
  /*
    Wait for ndb binlog to be up-to-date with all changes
    done on the local mysql server
  */
3864
  {
3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877
    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)
3878
    {
3879
      ulonglong start_epoch= 0, handled_epoch= 0,
3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981
	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)
          sleep(1);
        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);
3982
	if (latest_handled_binlog_epoch > handled_epoch)
3983
	  count= 0;
3984
	handled_epoch= latest_handled_binlog_epoch;
3985 3986 3987 3988 3989 3990 3991 3992 3993
	count++;
	if (latest_handled_binlog_epoch >= start_epoch)
          do_continue= 0;
        else if (count > 30)
	{
	  break;
        }
        mysql_free_result(res);
      }
3994 3995
    }
  }
3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011
#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);

  if (rpl_parse)
    mysql_enable_rpl_parse(mysql);

4012
  DBUG_RETURN(0);
4013 4014
}

4015

4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035
/*
  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)
4036
{
4037 4038 4039 4040
  char *p= command->first_argument;
  char *var_name, *var_name_end;
  DYNAMIC_STRING let_rhs_expr;
  DBUG_ENTER("do_let");
4041

4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057
  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
4058

4059 4060 4061
  /* Find start of <var_val> */
  while (*p && my_isspace(charset_info,*p))
    p++;
4062

4063
  do_eval(&let_rhs_expr, p, command->end, FALSE);
4064

4065 4066 4067 4068 4069 4070
  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;
4071 4072
}

4073

4074
int do_rpl_probe(struct st_command *command __attribute__((unused)))
4075
{
4076 4077 4078 4079 4080
  DBUG_ENTER("do_rpl_probe");
  if (mysql_rpl_probe(&cur_con->mysql))
    die("Failed in mysql_rpl_probe(): '%s'", mysql_error(&cur_con->mysql));
  DBUG_RETURN(0);
}
4081

4082 4083 4084 4085

int do_enable_rpl_parse(struct st_command *command __attribute__((unused)))
{
  mysql_enable_rpl_parse(&cur_con->mysql);
4086 4087 4088
  return 0;
}

4089

4090
int do_disable_rpl_parse(struct st_command *command __attribute__((unused)))
4091
{
4092 4093 4094
  mysql_disable_rpl_parse(&cur_con->mysql);
  return 0;
}
4095 4096


4097 4098
/*
  Sleep the number of specified seconds
4099

4100 4101 4102 4103 4104
  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
4105

4106 4107 4108
  DESCRIPTION
  sleep <seconds>
  real_sleep <seconds>
4109

4110 4111 4112 4113 4114 4115 4116 4117
  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.
*/
4118

4119 4120 4121 4122 4123 4124
int do_sleep(struct st_command *command, my_bool real_sleep)
{
  int error= 0;
  char *p= command->first_argument;
  char *sleep_start, *sleep_end= command->end;
  double sleep_val;
4125

4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138
  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,
        command->query,command->first_argument);
  sleep_val= my_strtod(sleep_start, &sleep_end, &error);
  if (error)
    die("Invalid argument to %.*s \"%s\"", command->first_word_len,
        command->query, command->first_argument);
4139

4140 4141 4142 4143 4144 4145 4146 4147
  /* 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));
  command->last_argument= sleep_end;
4148
  return 0;
4149 4150
}

4151

4152 4153
void do_get_file_name(struct st_command *command,
                      char* dest, uint dest_max_len)
4154
{
4155 4156 4157 4158 4159 4160 4161 4162 4163
  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;
4164
  strmake(dest, name, dest_max_len - 1);
4165 4166
}

4167 4168

void do_set_charset(struct st_command *command)
4169
{
4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184
  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);
4185 4186 4187
}


4188 4189 4190 4191 4192 4193 4194 4195
/*
  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)
{
4196
  MYSQL_RES *res= NULL;
4197 4198
  MYSQL_ROW row;

4199
  if (mysql_query(mysql, query))
4200 4201
    die("'%s' failed: %d %s", query,
        mysql_errno(mysql), mysql_error(mysql));
4202 4203 4204 4205 4206
  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)
4207 4208 4209 4210 4211
  {
    mysql_free_result(res);
    ds= 0;
    return 1;
  }
4212
  init_dynamic_string(ds, (row[column] ? row[column] : "NULL"), ~0, 32);
4213 4214 4215 4216 4217
  mysql_free_result(res);
  return 0;
}


4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238
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
}



4239 4240 4241 4242 4243 4244 4245
/*
  Shutdown the server of current connection and
  make sure it goes away within <timeout> seconds

  NOTE! Currently only works with local server

  SYNOPSIS
4246
  do_shutdown_server()
4247 4248 4249
  command  called command

  DESCRIPTION
4250
  shutdown [<timeout>]
4251 4252 4253

*/

4254
void do_shutdown_server(struct st_command *command)
4255 4256
{
  int timeout=60, pid;
4257
  DYNAMIC_STRING ds_pidfile_name;
4258 4259
  MYSQL* mysql = &cur_con->mysql;
  static DYNAMIC_STRING ds_timeout;
4260 4261
  const struct command_arg shutdown_args[] = {
    {"timeout", ARG_STRING, FALSE, &ds_timeout, "Timeout before killing server"}
4262
  };
4263
  DBUG_ENTER("do_shutdown_server");
4264

4265 4266
  check_command_args(command, command->first_argument, shutdown_args,
                     sizeof(shutdown_args)/sizeof(struct command_arg),
4267 4268 4269 4270 4271 4272 4273 4274
                     ' ');

  if (ds_timeout.length)
  {
    timeout= atoi(ds_timeout.str);
    if (timeout == 0)
      die("Illegal argument for timeout: '%s'", ds_timeout.str);
  }
4275
  dynstr_free(&ds_timeout);
4276 4277 4278

  /* Get the servers pid_file name and use it to read pid */
  if (query_get_string(mysql, "SHOW VARIABLES LIKE 'pid_file'", 1,
4279
                       &ds_pidfile_name))
4280 4281 4282 4283 4284 4285 4286
    die("Failed to get pid_file from server");

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

4287 4288
    if ((fd= my_open(ds_pidfile_name.str, O_RDONLY, MYF(0))) < 0)
      die("Failed to open file '%s'", ds_pidfile_name.str);
4289 4290
    dynstr_free(&ds_pidfile_name);

4291 4292 4293 4294 4295 4296
    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));
4297

4298 4299 4300
    pid= atoi(buff);
    if (pid == 0)
      die("Pidfile didn't contain a valid number");
4301 4302 4303
  }
  DBUG_PRINT("info", ("Got pid %d", pid));

4304
  /* Tell server to shutdown if timeout > 0*/
4305
  if (timeout && mysql_shutdown(mysql, SHUTDOWN_DEFAULT))
4306 4307 4308 4309
    die("mysql_shutdown failed");

  /* Check that server dies */
  while(timeout--){
4310
    if (my_kill(pid, 0) < 0){
4311
      DBUG_PRINT("info", ("Process %d does not exist anymore", pid));
4312
      DBUG_VOID_RETURN;
4313 4314
    }
    DBUG_PRINT("info", ("Sleeping, timeout: %d", timeout));
4315
    my_sleep(1000000L);
4316 4317 4318 4319
  }

  /* Kill the server */
  DBUG_PRINT("info", ("Killing server, pid: %d", pid));
4320
  (void)my_kill(pid, 9);
4321 4322 4323 4324 4325 4326

  DBUG_VOID_RETURN;

}


4327 4328 4329
#if MYSQL_VERSION_ID >= 50000
/* List of error names to error codes, available from 5.0 */
typedef struct
4330
{
4331
  const char *name;
4332
  uint        code;
4333
} st_error;
4334

4335 4336 4337 4338 4339
static st_error global_error_names[] =
{
#include <mysqld_ername.h>
  { 0, 0 }
};
4340

4341 4342 4343 4344
uint get_errcode_from_name(char *error_name, char *error_end)
{
  /* SQL error as string */
  st_error *e= global_error_names;
4345 4346

  DBUG_ENTER("get_errcode_from_name");
4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359
  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))
    {
4360
      DBUG_RETURN(e->code);
4361 4362 4363 4364
    }
  }
  if (!e->name)
    die("Unknown SQL error name '%s'", error_name);
4365 4366
  DBUG_RETURN(0);
}
4367
#else
4368 4369 4370
uint get_errcode_from_name(char *error_name __attribute__((unused)),
                           char *error_end __attribute__((unused)))
{
4371
  abort_not_in_this_version();
4372
  return 0; /* Never reached */
4373
}
4374 4375
#endif

4376 4377


4378 4379 4380 4381 4382
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;
4383

4384
  DBUG_ENTER("do_get_errcodes");
4385

4386 4387
  if (!*p)
    die("Missing argument(s) to 'error'");
4388

4389 4390 4391
  do
  {
    char *end;
4392

4393 4394 4395
    /* Skip leading spaces */
    while (*p && *p == ' ')
      p++;
4396

4397 4398 4399 4400
    /* Find end */
    end= p;
    while (*end && *end != ',' && *end != ' ')
      end++;
4401

4402
    if (*p == 'S')
4403
    {
4404 4405
      char *to_ptr= to->code.sqlstate;

4406 4407 4408 4409 4410 4411
      /*
        SQLSTATE string
        - Must be SQLSTATE_LENGTH long
        - May contain only digits[0-9] and _uppercase_ letters
      */
      p++; /* Step past the S */
4412
      if ((end - p) != SQLSTATE_LENGTH)
4413
        die("The sqlstate must be exactly %d chars long", SQLSTATE_LENGTH);
4414

4415
      /* Check sqlstate string validity */
4416
      while (*p && p < end)
4417
      {
4418 4419 4420 4421 4422
        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");
4423
      }
4424

4425 4426
      *to_ptr= 0;
      to->type= ERR_SQLSTATE;
4427
      DBUG_PRINT("info", ("ERR_SQLSTATE: %s", to->code.sqlstate));
4428 4429 4430 4431
    }
    else if (*p == 's')
    {
      die("The sqlstate definition must start with an uppercase S");
4432
    }
4433 4434 4435
    else if (*p == 'E')
    {
      /* Error name string */
4436

4437 4438 4439 4440 4441 4442
      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
4443
    {
4444 4445 4446 4447 4448 4449 4450 4451
      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
4452
      {
4453 4454 4455 4456 4457 4458
        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
4459

4460 4461 4462
      /* 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
4463

4464 4465 4466
      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
4467
    }
4468 4469
    to++;
    count++;
4470

4471 4472 4473
    if (count >= (sizeof(saved_expected_errors.err) /
                  sizeof(struct st_match_err)))
      die("Too many errorcodes specified");
4474

4475 4476
    /* Set pointer to the end of the last error code */
    p= end;
4477

4478 4479 4480
    /* Find next ',' */
    while (*p && *p != ',')
      p++;
4481

4482 4483
    if (*p)
      p++; /* Step past ',' */
4484

4485
  } while (*p);
4486

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

4490 4491 4492 4493
  DBUG_PRINT("info", ("Expected errors: %d", count));
  saved_expected_errors.count= count;
  DBUG_VOID_RETURN;
}
4494 4495


4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577
/*
  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)
{
4578
  my_bool reconnect= val;
4579 4580
  DBUG_ENTER("set_reconnect");
  DBUG_PRINT("info", ("val: %d", val));
4581
#if MYSQL_VERSION_ID < 50000
4582
  mysql->reconnect= reconnect;
4583 4584 4585
#else
  mysql_options(mysql, MYSQL_OPT_RECONNECT, (char *)&reconnect);
#endif
4586
  DBUG_VOID_RETURN;
4587 4588 4589
}


4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605
/**
  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)
4606
{
4607
  DBUG_ENTER("select_connection_name");
4608
  DBUG_PRINT("enter",("name: '%s'", name));
4609
  st_connection *con= find_connection_by_name(name);
4610

4611
  if (!con)
4612
    die("connection '%s' not found in connection pool", name);
4613

4614
  set_current_connection(con);
4615

4616
  DBUG_VOID_RETURN;
4617 4618 4619
}


4620
void select_connection(struct st_command *command)
4621 4622
{
  DBUG_ENTER("select_connection");
4623 4624 4625 4626 4627 4628
  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),
4629
                     ' ');
4630

4631 4632 4633 4634
  DBUG_PRINT("info", ("changing connection: %s", ds_connection.str));
  select_connection_name(ds_connection.str);
  dynstr_free(&ds_connection);
  DBUG_VOID_RETURN;
4635 4636 4637 4638 4639 4640 4641
}


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

4642 4643 4644 4645 4646 4647 4648 4649 4650 4651
  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),
                     ' ');
4652

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

4655 4656
  if (!(con= find_connection_by_name(ds_connection.str)))
    die("connection '%s' not found in connection pool", ds_connection.str);
4657 4658 4659 4660

  DBUG_PRINT("info", ("Closing connection %s", con->name));
#ifndef EMBEDDED_LIBRARY
  if (command->type == Q_DIRTY_CLOSE)
4661
  {
4662
    if (con->mysql.net.vio)
4663
    {
4664 4665 4666 4667
      vio_delete(con->mysql.net.vio);
      con->mysql.net.vio = 0;
    }
  }
4668 4669 4670 4671 4672 4673 4674 4675
#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)
  */
  wait_query_thread_end(con);
#endif /*EMBEDDED_LIBRARY*/
4676 4677 4678
  if (con->stmt)
    mysql_stmt_close(con->stmt);
  con->stmt= 0;
4679

4680
  mysql_close(&con->mysql);
4681

4682 4683 4684
  if (con->util_mysql)
    mysql_close(con->util_mysql);
  con->util_mysql= 0;
4685

4686 4687 4688 4689 4690 4691 4692 4693 4694
  my_free(con->name, MYF(0));

  /*
    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");

4695 4696 4697 4698 4699 4700 4701
  if (con == cur_con)
  {
    /* Current connection was closed */
    var_set_int("$mysql_get_server_version", 0xFFFFFFFF);
    var_set_string("$CURRENT_CONNECTION", con->name);
  }

4702
  DBUG_VOID_RETURN;
4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737
}


/*
  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");
4738 4739 4740 4741

  verbose_msg("Connecting to server %s:%d (socket %s) as '%s'"
              ", connection '%s', attempt %d ...", 
              host, port, sock, user, name, failed_attempts);
4742 4743 4744 4745 4746 4747 4748
  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
4749 4750
      could not be contacted. Error code differs depending
      on protocol/connection type
4751 4752
    */

4753 4754
    if ((mysql_errno(mysql) == CR_CONN_HOST_ERROR ||
         mysql_errno(mysql) == CR_CONNECTION_ERROR) &&
4755
        failed_attempts < opt_max_connect_retries)
4756 4757 4758 4759
    {
      verbose_msg("Connect attempt %d/%d failed: %d: %s", failed_attempts,
                  opt_max_connect_retries, mysql_errno(mysql),
                  mysql_error(mysql));
4760
      my_sleep(connection_retry_sleep);
4761
    }
4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772
    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++;
  }
4773
  verbose_msg("... Connected.");
4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806
  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;
4807
  int failed_attempts= 0;
4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835

  ds= &ds_res;

  /* Only log if an error is expected */
  if (!command->abort_on_error &&
      !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);
  }
4836
  while (!mysql_real_connect(con, host, user, pass, db, port, sock ? sock: 0,
4837 4838
                          CLIENT_MULTI_STATEMENTS))
  {
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
    /*
      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:
4871
    var_set_errno(mysql_errno(con));
4872 4873 4874 4875 4876
    handle_error(command, mysql_errno(con), mysql_error(con),
		 mysql_sqlstate(con), ds);
    return 0; /* Not connected */
  }

4877
  var_set_errno(0);
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
  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

*/

void do_connect(struct st_command *command)
{
4910
  int con_port= opt_port;
4911
  char *con_options;
4912
  my_bool con_ssl= 0, con_compress= 0;
4913
  struct st_connection* con_slot;
4914

4915 4916 4917 4918 4919 4920 4921 4922
  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;
4923
  const struct command_arg connect_args[] = {
serg@janus.mylan's avatar
serg@janus.mylan committed
4924 4925 4926 4927 4928 4929 4930 4931
    { "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" },
    { "options", ARG_STRING, FALSE, &ds_options, "Options to use while connecting" }
4932 4933 4934 4935 4936
  };

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

4937
  strip_parentheses(command);
4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975
  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);
  }

  /* 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)
  {
4976 4977 4978 4979 4980 4981
    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;
4982 4983 4984 4985 4986 4987 4988
    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;
    else
4989 4990
      die("Illegal option to connect: %.*s", 
          (int) (end - con_options), con_options);
4991 4992 4993 4994 4995 4996
    /* Process next option */
    con_options= end;
  }

  if (find_connection_by_name(ds_connection_name.str))
    die("Connection %s already exists", ds_connection_name.str);
4997 4998 4999 5000
    
  if (next_con != connections_end)
    con_slot= next_con;
  else
5001
  {
5002
    if (!(con_slot= find_connection_by_name("-closed_connection-")))
5003 5004 5005
      die("Connection limit exhausted, you can have max %d connections",
          (int) (sizeof(connections)/sizeof(struct st_connection)));
  }
5006

5007 5008 5009
#ifdef EMBEDDED_LIBRARY
  con_slot->query_done= 1;
#endif
5010
  if (!mysql_init(&con_slot->mysql))
5011
    die("Failed on mysql_init()");
5012 5013 5014 5015 5016

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

5017
  if (opt_compress || con_compress)
5018 5019 5020
    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,
5021 5022
                charset_info->csname);
  if (opt_charsets_dir)
5023
    mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_DIR,
5024
                  opt_charsets_dir);
5025 5026 5027 5028

#ifdef HAVE_OPENSSL
  if (opt_use_ssl || con_ssl)
  {
5029
    mysql_ssl_set(&con_slot->mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
5030 5031 5032
		  opt_ssl_capath, opt_ssl_cipher);
#if MYSQL_VERSION_ID >= 50000
    /* Turn on ssl_verify_server_cert only if host is "localhost" */
5033
    opt_ssl_verify_server_cert= !strcmp(ds_host.str, "localhost");
5034
    mysql_options(&con_slot->mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
5035 5036 5037 5038 5039 5040 5041
                  &opt_ssl_verify_server_cert);
#endif
  }
#endif

  /* Use default db name */
  if (ds_database.length == 0)
5042
    dynstr_set(&ds_database, opt_db);
5043 5044 5045 5046 5047

  /* 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, "");

5048
  if (connect_n_handle_errors(command, &con_slot->mysql,
5049 5050 5051 5052 5053 5054
                              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));
5055
    if (!(con_slot->name= my_strdup(ds_connection_name.str, MYF(MY_WME))))
5056
      die("Out of memory");
5057
    con_slot->name_len= strlen(con_slot->name);
5058 5059
    set_current_connection(con_slot);

5060 5061
    if (con_slot == next_con)
      next_con++; /* if we used the next_con slot, advance the pointer */
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 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 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 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 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 5232 5233 5234 5235 5236 5237 5238 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 5266 5267 5268 5269 5270 5271 5272
  }

  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);
  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
  {
    /* Pop block from stack, goto next line */
    cur_block--;
    parser.current_line++;
  }
  return 0;
}


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

*/

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;
    DBUG_VOID_RETURN;
  }

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

  /* 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);
  eval_expr(&v, expr_start, &expr_end);

  /* Define inner block */
  cur_block++;
  cur_block->cmd= cmd;
  cur_block->ok= (v.int_val ? TRUE : FALSE);

  if (not_expr)
    cur_block->ok = !cur_block->ok;

  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)
{
5273
  char c, UNINIT_VAR(last_quote);
5274 5275 5276 5277 5278 5279 5280
  char *p= buf, *buf_end= buf + size - 1;
  int skip_char= 0;
  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;
5281
  DBUG_PRINT("info", ("Starting to read at lineno: %d", start_lineno));
5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293
  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)
      {
	my_fclose(cur_file->file, MYF(0));
        cur_file->file= 0;
      }
5294
      my_free((uchar*) cur_file->file_name, MYF(MY_ALLOW_ZERO_PTR));
5295 5296 5297 5298 5299 5300 5301 5302 5303 5304
      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;
5305
        DBUG_PRINT("info", ("end of file at line %d", cur_file->lineno));
5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327
        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;
5328 5329
        DBUG_PRINT("exit", ("Found delimiter '%s' at line %d",
                            delimiter, cur_file->lineno));
5330 5331 5332
	DBUG_RETURN(0);
      }
      else if ((c == '{' &&
5333 5334 5335 5336
                (!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))))
5337 5338 5339 5340
      {
        /* Only if and while commands can be terminated by { */
        *p++= c;
	*p= 0;
5341 5342
        DBUG_PRINT("exit", ("Found '{' indicating start of block at line %d",
                            cur_file->lineno));
5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356
	DBUG_RETURN(0);
      }
      else if (c == '\'' || c == '"' || c == '`')
      {
        last_quote= c;
	state= R_Q;
      }
      break;

    case R_COMMENT:
      if (c == '\n')
      {
        /* Comments are terminated by newline */
	*p= 0;
5357 5358
        DBUG_PRINT("exit", ("Found newline in comment at line: %d",
                            cur_file->lineno));
5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372
	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))
      {
        /* Skip all space at begining of line */
	if (c == '\n')
5373 5374 5375 5376 5377 5378
        {
          /* Query hasn't started yet */
	  start_lineno= cur_file->lineno;
          DBUG_PRINT("info", ("Query hasn't started yet, start_lineno: %d",
                              start_lineno));
        }
5379 5380 5381 5382 5383
	skip_char= 1;
      }
      else if (end_of_query(c))
      {
	*p= 0;
5384 5385
        DBUG_PRINT("exit", ("Found delimiter '%s' at line: %d",
                            delimiter, cur_file->lineno));
5386 5387 5388 5389 5390 5391 5392
	DBUG_RETURN(0);
      }
      else if (c == '}')
      {
        /* A "}" need to be by itself in the begining of a line to terminate */
        *p++= c;
	*p= 0;
5393 5394
        DBUG_PRINT("exit", ("Found '}' in begining of a line at line: %d",
                            cur_file->lineno));
5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473
	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;

    }

    if (!skip_char)
    {
      /* Could be a multibyte character */
      /* This code is based on the code in "sql_load.cc" */
#ifdef USE_MB
      int charlen = my_mbcharlen(charset_info, c);
      /* 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++)
	{
	  if (feof(cur_file->file))
	    goto found_eof;
	  c= my_getc(cur_file->file);
	  *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 */
	  while (p > mb_start)
	    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;
5474
  char *p= query, *to= query;
5475 5476 5477 5478 5479 5480 5481
  char *end= strend(query);
  char last_c;

  while (p <= end)
  {
    if (*p == '\n' && !last_c_was_quote)
    {
5482
      *to++ = *p++; /* Save the newline */
5483 5484 5485 5486 5487 5488 5489 5490 5491 5492

      /* 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;
5493
      *to++ = *p++;
5494 5495 5496

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

5499
      *to++ = *p++;
5500 5501 5502 5503 5504

      last_c_was_quote= 1;
    }
    else
    {
5505
      *to++ = *p++;
5506 5507 5508 5509 5510 5511 5512 5513
      last_c_was_quote= 0;
    }
  }
}


/*
  Check for unexpected "junk" after the end of query
5514 5515
  This is normally caused by missing delimiters or when
  switching between different delimiters
5516 5517
*/

5518
void check_eol_junk_line(const char *line)
5519
{
5520 5521 5522
  const char *p= line;
  DBUG_ENTER("check_eol_junk_line");
  DBUG_PRINT("enter", ("line: %s", line));
5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537

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

5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567
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;
}

5568

5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581
bool is_delimiter(const char* p)
{
  uint match= 0;
  char* delim= delimiter;
  while (*p && *p == *delim++)
  {
    match++;
    p++;
  }

  return (match == delimiter_length);
}

5582 5583 5584 5585 5586

/*
  Create a command from a set of lines

  SYNOPSIS
5587 5588
    read_command()
    command_ptr pointer where to return the new query
5589 5590

  DESCRIPTION
5591 5592
    Converts lines returned by read_line into a command, this involves
    parsing the first word in the read line to find the command type.
5593 5594 5595 5596 5597 5598 5599

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

5600
#define MAX_QUERY (256*1024*2) /* 256K -- a test in sp-big is >128K */
5601 5602 5603 5604 5605 5606 5607 5608 5609 5610
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)
  {
5611
    get_dynamic(&q_lines, (uchar*) command_ptr, parser.current_line) ;
5612 5613 5614
    DBUG_RETURN(0);
  }
  if (!(*command_ptr= command=
5615 5616
        (struct st_command*) my_malloc(sizeof(*command),
                                       MYF(MY_WME|MY_ZEROFILL))) ||
5617
      insert_dynamic(&q_lines, (uchar*) &command))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
5618
    die(NullS);
5619
  command->type= Q_UNKNOWN;
5620

5621 5622
  read_command_buf[0]= 0;
  if (read_line(read_command_buf, sizeof(read_command_buf)))
monty@mysql.com's avatar
monty@mysql.com committed
5623
  {
5624
    check_eol_junk(read_command_buf);
monty@mysql.com's avatar
monty@mysql.com committed
5625
    DBUG_RETURN(1);
monty@mysql.com's avatar
monty@mysql.com committed
5626
  }
5627 5628 5629 5630

  convert_to_format_v1(read_command_buf);

  DBUG_PRINT("info", ("query: %s", read_command_buf));
5631 5632
  if (*p == '#')
  {
5633
    command->type= Q_COMMENT;
5634
  }
5635
  else if (p[0] == '-' && p[1] == '-')
5636
  {
5637
    command->type= Q_COMMENT_WITH_COMMAND;
5638
    p+= 2; /* Skip past -- */
5639
  }
5640

5641
  /* Skip leading spaces */
5642
  while (*p && my_isspace(charset_info, *p))
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5643
    p++;
5644 5645

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

5648 5649 5650
  /*
    Calculate first word length(the command), terminated
    by 'space' , '(' or 'delimiter' */
5651
  p= command->query;
5652
  while (*p && !my_isspace(charset_info, *p) && *p != '(' && !is_delimiter(p))
5653
    p++;
5654
  command->first_word_len= (uint) (p - command->query);
5655 5656
  DBUG_PRINT("info", ("first_word: %.*s",
                      command->first_word_len, command->query));
5657 5658

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

5663 5664
  command->end= strend(command->query);
  command->query_len= (command->end - command->query);
5665
  parser.read_lines++;
monty@mysql.com's avatar
monty@mysql.com committed
5666
  DBUG_RETURN(0);
5667 5668
}

5669 5670 5671

static struct my_option my_long_options[] =
{
5672 5673
  {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
   0, 0, 0, 0, 0, 0},
5674 5675
  {"basedir", 'b', "Basedir for tests.", (uchar**) &opt_basedir,
   (uchar**) &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5676
  {"character-sets-dir", OPT_CHARSETS_DIR,
5677 5678
   "Directory where character sets are.", (uchar**) &opt_charsets_dir,
   (uchar**) &opt_charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5679
  {"compress", 'C', "Use the compressed server/client protocol.",
5680
   (uchar**) &opt_compress, (uchar**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
5681
   0, 0, 0},
5682
  {"cursor-protocol", OPT_CURSOR_PROTOCOL, "Use cursors for prepared statements.",
5683
   (uchar**) &cursor_protocol, (uchar**) &cursor_protocol, 0,
5684
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5685
  {"database", 'D', "Database to use.", (uchar**) &opt_db, (uchar**) &opt_db, 0,
5686 5687 5688 5689 5690 5691 5692 5693
   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
5694
  {"debug-check", OPT_DEBUG_CHECK, "Check memory and open file usage at exit.",
5695 5696 5697 5698 5699
   (uchar**) &debug_check_flag, (uchar**) &debug_check_flag, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"debug-info", OPT_DEBUG_INFO, "Print some debug info at exit.",
   (uchar**) &debug_info_flag, (uchar**) &debug_info_flag,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5700
  {"host", 'h', "Connect to host.", (uchar**) &opt_host, (uchar**) &opt_host, 0,
5701
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5702 5703 5704 5705
  {"include", 'i', "Include SQL before each test case.", (uchar**) &opt_include,
   (uchar**) &opt_include, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"logdir", OPT_LOG_DIR, "Directory for log files", (uchar**) &opt_logdir,
   (uchar**) &opt_logdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5706 5707
  {"mark-progress", OPT_MARK_PROGRESS,
   "Write linenumber and elapsed time to <testname>.progress ",
5708
   (uchar**) &opt_mark_progress, (uchar**) &opt_mark_progress, 0,
5709 5710 5711
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"max-connect-retries", OPT_MAX_CONNECT_RETRIES,
   "Max number of connection attempts when connecting to server",
5712
   (uchar**) &opt_max_connect_retries, (uchar**) &opt_max_connect_retries, 0,
5713
   GET_INT, REQUIRED_ARG, 500, 1, 10000, 0, 0, 0},
5714 5715
  {"password", 'p', "Password to use when connecting to server.",
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
5716 5717 5718 5719 5720 5721
  {"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) ").",
5722
   (uchar**) &opt_port,
5723
   (uchar**) &opt_port, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5724
  {"ps-protocol", OPT_PS_PROTOCOL, "Use prepared statements protocol for communication",
5725
   (uchar**) &ps_protocol, (uchar**) &ps_protocol, 0,
5726
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5727 5728
  {"quiet", 's', "Suppress all normal output.", (uchar**) &silent,
   (uchar**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5729 5730 5731
  {"record", 'r', "Record output of test_file into result file.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"result-file", 'R', "Read/Store result from/in this file.",
5732
   (uchar**) &result_file_name, (uchar**) &result_file_name, 0,
5733
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
paul@snake-hub.snake.net's avatar
paul@snake-hub.snake.net committed
5734
  {"server-arg", 'A', "Send option value to embedded server as a parameter.",
5735
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5736
  {"server-file", 'F', "Read embedded server arguments from file.",
5737 5738
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"silent", 's', "Suppress all normal output. Synonym for --quiet.",
5739
   (uchar**) &silent, (uchar**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5740
  {"skip-safemalloc", OPT_SKIP_SAFEMALLOC,
5741
   "Don't use the memory allocation checking.", 0, 0, 0, GET_NO_ARG, NO_ARG,
5742
   0, 0, 0, 0, 0, 0},
5743
  {"sleep", 'T', "Sleep always this many seconds on sleep commands.",
5744
   (uchar**) &opt_sleep, (uchar**) &opt_sleep, 0, GET_INT, REQUIRED_ARG, -1, -1, 0,
5745 5746
   0, 0, 0},
  {"socket", 'S', "Socket file to use for connection.",
5747
   (uchar**) &unix_sock, (uchar**) &unix_sock, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
5748
   0, 0, 0},
5749
  {"sp-protocol", OPT_SP_PROTOCOL, "Use stored procedures for select",
5750
   (uchar**) &sp_protocol, (uchar**) &sp_protocol, 0,
5751
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5752
#include "sslopt-longopts.h"
5753 5754
  {"tail-lines", OPT_TAIL_LINES,
   "Number of lines of the resul to include in a failure report",
5755
   (uchar**) &opt_tail_lines, (uchar**) &opt_tail_lines, 0,
5756
   GET_INT, REQUIRED_ARG, 0, 0, 10000, 0, 0, 0},
5757 5758
  {"test-file", 'x', "Read test from/in this file (default stdin).",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
kent@mysql.com's avatar
kent@mysql.com committed
5759 5760
  {"timer-file", 'm', "File where the timing in micro seconds is stored.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5761
  {"tmpdir", 't', "Temporary directory where sockets are put.",
5762
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5763
  {"user", 'u', "User for login.", (uchar**) &opt_user, (uchar**) &opt_user, 0,
5764
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5765
  {"verbose", 'v', "Write more.", (uchar**) &verbose, (uchar**) &verbose, 0,
5766 5767 5768
   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},
5769
  {"view-protocol", OPT_VIEW_PROTOCOL, "Use views for select",
5770
   (uchar**) &view_protocol, (uchar**) &view_protocol, 0,
5771
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5772 5773 5774 5775 5776
  {"connect_timeout", OPT_CONNECT_TIMEOUT,
   "Number of seconds before connection timeout.",
   (uchar**) &opt_connect_timeout,
   (uchar**) &opt_connect_timeout, 0, GET_UINT, REQUIRED_ARG,
   120, 0, 3600 * 12, 0, 0, 0},
5777
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
5778 5779
};

5780 5781 5782

#include <help_start.h>

5783
void print_version(void)
5784 5785 5786 5787 5788
{
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,MTEST_VERSION,
	 MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
}

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
void usage()
{
  print_version();
  printf("MySQL AB, by Sasha, Matt, Monty & Jani\n");
  printf("This software comes with ABSOLUTELY NO WARRANTY\n\n");
  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);
}

#include <help_end.h>


/*
  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))))
5827
    die("Failed to open file '%s'", buff);
5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846

  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;
5847 5848
}

5849 5850 5851 5852 5853

static my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
{
5854
  switch(optid) {
5855
  case '#':
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5856
#ifndef DBUG_OFF
5857
    DBUG_PUSH(argument ? argument : "d:t:S:i:O,/tmp/mysqltest.trace");
5858
    debug_check_flag= 1;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5859
#endif
5860 5861 5862 5863 5864
    break;
  case 'r':
    record = 1;
    break;
  case 'x':
5865 5866 5867
  {
    char buff[FN_REFLEN];
    if (!test_if_hard_path(argument))
5868
    {
5869 5870
      strxmov(buff, opt_basedir, argument, NullS);
      argument= buff;
5871
    }
5872 5873 5874 5875
    fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
    DBUG_ASSERT(cur_file == file_stack && cur_file->file == 0);
    if (!(cur_file->file=
          my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(0))))
5876
      die("Could not open '%s' for reading, errno: %d", buff, errno);
5877 5878 5879 5880
    cur_file->file_name= my_strdup(buff, MYF(MY_FAE));
    cur_file->lineno= 1;
    break;
  }
kent@mysql.com's avatar
kent@mysql.com committed
5881
  case 'm':
5882 5883 5884
  {
    static char buff[FN_REFLEN];
    if (!test_if_hard_path(argument))
kent@mysql.com's avatar
kent@mysql.com committed
5885
    {
5886 5887
      strxmov(buff, opt_basedir, argument, NullS);
      argument= buff;
kent@mysql.com's avatar
kent@mysql.com committed
5888
    }
5889 5890 5891 5892 5893
    fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
    timer_file= buff;
    unlink(timer_file);	     /* Ignore error, may not exist */
    break;
  }
5894
  case 'p':
5895 5896
    if (argument == disabled_my_option)
      argument= (char*) "";			// Don't require password
5897 5898
    if (argument)
    {
5899 5900
      my_free(opt_pass, MYF(MY_ALLOW_ZERO_PTR));
      opt_pass= my_strdup(argument, MYF(MY_FAE));
5901
      while (*argument) *argument++= 'x';		/* Destroy argument */
5902
      tty_password= 0;
5903 5904 5905 5906
    }
    else
      tty_password= 1;
    break;
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
5907
#include <sslopt-case.h>
5908 5909 5910 5911 5912 5913 5914 5915 5916
  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*) "";
    }
5917
    if (embedded_server_arg_count == MAX_EMBEDDED_SERVER_ARGS-1 ||
5918 5919
        !(embedded_server_args[embedded_server_arg_count++]=
          my_strdup(argument, MYF(MY_FAE))))
5920 5921 5922 5923
    {
      die("Can't use server argument");
    }
    break;
5924 5925 5926 5927 5928
  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;
5929
  case 'F':
5930
    read_embedded_server_arguments(argument);
5931
    break;
5932 5933 5934 5935 5936
  case OPT_SKIP_SAFEMALLOC:
#ifdef SAFEMALLOC
    sf_malloc_quick=1;
#endif
    break;
5937 5938 5939 5940 5941
  case 'V':
    print_version();
    exit(0);
  case '?':
    usage();
5942
    exit(0);
5943 5944 5945 5946 5947
  }
  return 0;
}


5948 5949 5950
int parse_args(int argc, char **argv)
{
  load_defaults("my",load_default_groups,&argc,&argv);
5951
  default_argv= argv;
5952

5953
  if ((handle_options(&argc, &argv, my_long_options, get_one_option)))
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5954
    exit(1);
5955 5956 5957 5958 5959 5960 5961

  if (argc > 1)
  {
    usage();
    exit(1);
  }
  if (argc == 1)
5962
    opt_db= *argv;
5963
  if (tty_password)
5964
    opt_pass= get_tty_password(NullS);          /* purify tested */
5965 5966 5967 5968
  if (debug_info_flag)
    my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
  if (debug_check_flag)
    my_end_arg= MY_CHECK_ERROR;
5969

5970 5971 5972 5973 5974 5975 5976 5977

  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);
  }

5978 5979 5980
  return 0;
}

5981 5982 5983 5984
/*
  Write the content of str into file

  SYNOPSIS
5985
  str_to_file2
5986 5987 5988
  fname - name of file to truncate/create and write to
  str - content to write to file
  size - size of content witten to file
5989
  append - append to file instead of overwriting old file
5990
*/
5991

5992
void str_to_file2(const char *fname, char *str, int size, my_bool append)
5993 5994
{
  int fd;
5995
  char buff[FN_REFLEN];
5996
  int flags= O_WRONLY | O_CREAT;
5997 5998 5999
  if (!test_if_hard_path(fname))
  {
    strxmov(buff, opt_basedir, fname, NullS);
6000
    fname= buff;
6001
  }
6002 6003
  fn_format(buff, fname, "", "", MY_UNPACK_FILENAME);

6004 6005 6006
  if (!append)
    flags|= O_TRUNC;
  if ((fd= my_open(buff, flags,
6007
                   MYF(MY_WME | MY_FFNF))) < 0)
6008
    die("Could not open '%s' for writing, errno: %d", buff, errno);
6009
  if (append && my_seek(fd, 0, SEEK_END, MYF(0)) == MY_FILEPOS_ERROR)
6010
    die("Could not find end of file '%s', errno: %d", buff, errno);
6011
  if (my_write(fd, (uchar*)str, size, MYF(MY_WME|MY_FNABP)))
6012
    die("write failed, errno: %d", errno);
6013 6014 6015
  my_close(fd, MYF(0));
}

6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030
/*
  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);
}

6031 6032

void check_regerr(my_regex_t* r, int err)
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 6059 6060 6061
  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",
6062
                          "$MYSQLTEST_VARDIR",
6063
                          "$MASTER_MYSOCK",
6064
                          "./test/" };
6065
  int num_paths= sizeof(paths)/sizeof(char*);
6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084
  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));

6085 6086 6087 6088 6089 6090 6091
    /* Don't insert zero length strings in patterns array */
    if (strlen(p) == 0)
    {
      my_free(p, MYF(0));
      continue;
    }

6092
    if (insert_dynamic(&patterns, (uchar*) &p))
6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111
      die(NullS);

    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**);
6112
    my_free((char*) *pattern, MYF(0));
6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140
  }
  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));
6141

6142
    /* Search for the path in string */
Magnus Svensson's avatar
Magnus Svensson committed
6143
    while ((p= strstr((char*)val, *pattern)))
6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167
    {
      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,
6168
                  char* val, ulonglong len, my_bool is_null)
6169
{
6170 6171
  char null[]= "NULL";

6172 6173 6174 6175 6176 6177 6178
  if (col_idx < max_replace_column && replace_column[col_idx])
  {
    val= replace_column[col_idx];
    len= strlen(val);
  }
  else if (is_null)
  {
6179
    val= null;
6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192
    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' */
6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204
      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--;
      }
6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215
    }
  }
#endif

  if (!display_result_vertically)
  {
    if (col_idx)
      dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_mem(ds, val, (int)len);
  }
  else
6216
  {
6217 6218 6219 6220
    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);
6221 6222 6223
  }
}

6224

6225 6226
/*
  Append all results to the dynamic string separated with '\t'
6227
  Values may be converted with 'replace_column'
6228 6229
*/

6230
void append_result(DYNAMIC_STRING *ds, MYSQL_RES *res)
6231 6232
{
  MYSQL_ROW row;
6233
  uint num_fields= mysql_num_fields(res);
6234 6235 6236
  MYSQL_FIELD *fields= mysql_fetch_fields(res);
  ulong *lengths;

6237 6238
  while ((row = mysql_fetch_row(res)))
  {
6239
    uint i;
6240 6241
    lengths = mysql_fetch_lengths(res);
    for (i = 0; i < num_fields; i++)
6242
      append_field(ds, i, &fields[i],
6243
                   row[i], lengths[i], !row[i]);
6244 6245
    if (!display_result_vertically)
      dynstr_append_mem(ds, "\n", 1);
6246 6247 6248
  }
}

6249

6250
/*
6251 6252
  Append all results from ps execution to the dynamic string separated
  with '\t'. Values may be converted with 'replace_column'
6253
*/
6254

6255 6256
void append_stmt_result(DYNAMIC_STRING *ds, MYSQL_STMT *stmt,
                        MYSQL_FIELD *fields, uint num_fields)
6257
{
6258
  MYSQL_BIND *my_bind;
6259 6260 6261
  my_bool *is_null;
  ulong *length;
  uint i;
6262

6263
  /* Allocate array with bind structs, lengths and NULL flags */
6264
  my_bind= (MYSQL_BIND*) my_malloc(num_fields * sizeof(MYSQL_BIND),
6265 6266 6267 6268 6269
				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));
6270

6271 6272 6273 6274
  /* Allocate data for the result of each field */
  for (i= 0; i < num_fields; i++)
  {
    uint max_length= fields[i].max_length + 1;
6275
    my_bind[i].buffer_type= MYSQL_TYPE_STRING;
6276
    my_bind[i].buffer= my_malloc(max_length, MYF(MY_WME | MY_FAE));
6277 6278 6279
    my_bind[i].buffer_length= max_length;
    my_bind[i].is_null= &is_null[i];
    my_bind[i].length= &length[i];
6280

6281
    DBUG_PRINT("bind", ("col[%d]: buffer_type: %d, buffer_length: %lu",
6282
			i, my_bind[i].buffer_type, my_bind[i].buffer_length));
6283
  }
6284

6285
  if (mysql_stmt_bind_result(stmt, my_bind))
6286 6287 6288 6289 6290 6291
    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++)
6292
      append_field(ds, i, &fields[i], (char*)my_bind[i].buffer,
6293
                   *my_bind[i].length, *my_bind[i].is_null);
6294 6295 6296 6297 6298 6299 6300
    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));
6301

6302 6303 6304
  for (i= 0; i < num_fields; i++)
  {
    /* Free data for output */
6305
    my_free(my_bind[i].buffer, MYF(MY_WME | MY_FAE));
6306 6307
  }
  /* Free array with bind structs, lengths and NULL flags */
6308 6309 6310
  my_free(my_bind    , MYF(MY_WME | MY_FAE));
  my_free(length  , MYF(MY_WME | MY_FAE));
  my_free(is_null , MYF(MY_WME | MY_FAE));
6311 6312 6313
}


6314 6315 6316 6317 6318 6319 6320
/*
  Append metadata for fields to output
*/

void append_metadata(DYNAMIC_STRING *ds,
                     MYSQL_FIELD *field,
                     uint num_fields)
6321
{
6322 6323 6324 6325 6326 6327 6328 6329
  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++)
6330
  {
6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361
    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);
6362
  }
6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376
}


/*
  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)
6377
  {
6378 6379 6380
    dynstr_append(ds, "info: ");
    dynstr_append(ds, info);
    dynstr_append_mem(ds, "\n", 1);
6381
  }
6382 6383
}

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

6385 6386 6387 6388 6389 6390 6391 6392 6393 6394
/*
  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++)
6395
  {
6396 6397 6398
    if (col_idx)
      dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append(ds, field[col_idx].name);
6399
  }
6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414
  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
6415

6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444
  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

6445 6446 6447 6448 6449 6450 6451 6452
  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
6453 6454
*/

holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
6455
void run_query_normal(struct st_connection *cn, struct st_command *command,
6456 6457 6458 6459
                      int flags, char *query, int query_len,
                      DYNAMIC_STRING *ds, DYNAMIC_STRING *ds_warnings)
{
  MYSQL_RES *res= 0;
6460
  MYSQL *mysql= &cn->mysql;
6461 6462 6463 6464 6465 6466
  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)
6467
  {
6468 6469 6470
    /*
      Send the query
    */
6471
    if (do_send_query(cn, query, query_len, flags))
6472 6473 6474 6475 6476
    {
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
      goto end;
    }
6477
  }
6478 6479
#ifdef EMBEDDED_LIBRARY
  /*
6480 6481
    Here we handle 'reap' command, so we need to check if the
    query's thread was finished and probably wait
6482
  */
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
6483
  else if (flags & QUERY_REAP_FLAG)
6484
    wait_query_thread_end(cn);
6485
#endif /*EMBEDDED_LIBRARY*/
6486 6487 6488
  if (!(flags & QUERY_REAP_FLAG))
    DBUG_VOID_RETURN;

6489
  do
6490
  {
6491 6492 6493 6494 6495
    /*
      When  on first result set, call mysql_read_query_result to retrieve
      answer to the query sent earlier
    */
    if ((counter==0) && mysql_read_query_result(mysql))
6496
    {
6497 6498
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
6499 6500
      goto end;

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
6501
    }
6502

6503
    /*
6504
      Store the result of the query if it will return any fields
6505
    */
6506
    if (mysql_field_count(mysql) && ((res= mysql_store_result(mysql)) == 0))
6507
    {
6508 6509
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
6510
      goto end;
6511
    }
6512

6513
    if (!disable_result_log)
6514
    {
6515
      ulonglong UNINIT_VAR(affected_rows);    /* Ok to be undef if 'disable_info' is set */
kent@mysql.com's avatar
kent@mysql.com committed
6516

6517
      if (res)
6518
      {
6519
	MYSQL_FIELD *fields= mysql_fetch_fields(res);
6520
	uint num_fields= mysql_num_fields(res);
6521

6522
	if (display_metadata)
6523
          append_metadata(ds, fields, num_fields);
6524

6525
	if (!display_result_vertically)
6526 6527
	  append_table_headings(ds, fields, num_fields);

6528
	append_result(ds, res);
6529
      }
6530

kent@mysql.com's avatar
kent@mysql.com committed
6531
      /*
6532
        Need to call mysql_affected_rows() before the "new"
kent@mysql.com's avatar
kent@mysql.com committed
6533 6534 6535
        query to find the warnings
      */
      if (!disable_info)
6536
        affected_rows= mysql_affected_rows(mysql);
kent@mysql.com's avatar
kent@mysql.com committed
6537

6538 6539 6540 6541 6542 6543
      /*
        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))
6544
      {
6545
	if (append_warnings(ds_warnings, mysql) || ds_warnings->length)
6546 6547
	{
	  dynstr_append_mem(ds, "Warnings:\n", 10);
6548
	  dynstr_append_mem(ds, ds_warnings->str, ds_warnings->length);
6549
	}
6550
      }
6551

vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
6552
      if (!disable_info)
6553
	append_info(ds, affected_rows, mysql_info(mysql));
6554
    }
6555

6556
    if (res)
6557
    {
6558
      mysql_free_result(res);
6559 6560
      res= 0;
    }
6561 6562
    counter++;
  } while (!(err= mysql_next_result(mysql)));
6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573
  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);
6574

6575
end:
6576 6577 6578 6579 6580 6581

  /*
    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.
  */
6582
  var_set_errno(mysql_errno(mysql));
6583
  DBUG_VOID_RETURN;
6584 6585 6586
}


6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636
/*
  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;
}


6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648
/*
  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
6649 6650
    If there is an unexpected error this function will abort mysqltest
    immediately.
6651 6652 6653 6654 6655 6656
*/

void handle_error(struct st_command *command,
                  unsigned int err_errno, const char *err_error,
                  const char *err_sqlstate, DYNAMIC_STRING *ds)
{
6657
  int i;
6658 6659 6660

  DBUG_ENTER("handle_error");

6661
  if (command->require_file[0])
6662 6663 6664 6665 6666 6667 6668 6669
  {
    /*
      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)
6670 6671
      die("require query '%s' failed: %d: %s", command->query,
          err_errno, err_error);
6672 6673

    /* Abort the run of this test, pass the failed query as reason */
6674
    abort_not_supported_test("Query '%s' failed, required functionality " \
6675 6676 6677 6678 6679 6680 6681 6682
                             "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));
6683 6684 6685 6686

  i= match_expected_error(command, err_errno, err_sqlstate);

  if (i >= 0)
6687
  {
6688
    if (!disable_result_log)
6689
    {
6690
      if (command->expected_errors.count == 1)
6691
      {
6692 6693 6694 6695 6696 6697
        /* 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);
6698
      }
6699 6700 6701 6702 6703
      /* 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");
6704
    }
6705 6706
    /* OK */
    DBUG_VOID_RETURN;
6707 6708 6709
  }

  DBUG_PRINT("info",("i: %d  expected_errors: %d", i,
6710
                     command->expected_errors.count));
6711 6712 6713 6714 6715 6716 6717 6718 6719 6720

  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);
  }

6721
  if (command->expected_errors.count > 0)
6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735
  {
    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;
}

6736 6737

/*
6738 6739 6740 6741 6742 6743 6744 6745
  Handle absence of errors after execution

  SYNOPSIS
  handle_no_error()
  q - context of query

  RETURN VALUE
  error - function will not return
6746 6747
*/

6748
void handle_no_error(struct st_command *command)
6749
{
6750
  DBUG_ENTER("handle_no_error");
6751

6752 6753
  if (command->expected_errors.err[0].type == ERR_ERRNO &&
      command->expected_errors.err[0].code.errnum != 0)
6754
  {
6755 6756 6757
    /* 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);
6758
  }
6759 6760
  else if (command->expected_errors.err[0].type == ERR_SQLSTATE &&
           strcmp(command->expected_errors.err[0].code.sqlstate,"00000") != 0)
6761
  {
6762 6763 6764
    /* 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);
6765
  }
6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794

  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");
6795 6796
  DBUG_PRINT("query", ("'%-.60s'", query));

6797 6798 6799 6800
  /*
    Init a new stmt if it's not already one created for this connection
  */
  if(!(stmt= cur_con->stmt))
6801
  {
6802 6803 6804
    if (!(stmt= mysql_stmt_init(mysql)))
      die("unable to init stmt structure");
    cur_con->stmt= stmt;
6805 6806
  }

6807 6808
  /* Init dynamic strings for warnings */
  if (!disable_warnings)
6809
  {
6810 6811
    init_dynamic_string(&ds_prepare_warnings, NULL, 0, 256);
    init_dynamic_string(&ds_execute_warnings, NULL, 0, 256);
6812 6813 6814
  }

  /*
6815
    Prepare the query
6816
  */
6817
  if (mysql_stmt_prepare(stmt, query, query_len))
6818
  {
6819 6820 6821
    handle_error(command,  mysql_stmt_errno(stmt),
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
    goto end;
6822 6823
  }

6824 6825 6826 6827 6828 6829
  /*
    Get the warnings from mysql_stmt_prepare and keep them in a
    separate string
  */
  if (!disable_warnings)
    append_warnings(&ds_prepare_warnings, mysql);
6830 6831

  /*
6832
    No need to call mysql_stmt_bind_param() because we have no
6833 6834 6835
    parameter markers.
  */

6836 6837
#if MYSQL_VERSION_ID >= 50000
  if (cursor_protocol_enabled)
6838
  {
6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856
    /*
      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;
6857 6858
  }

6859 6860 6861 6862 6863 6864 6865
  /*
    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);

6866 6867
  /*
    We instruct that we want to update the "max_length" field in
6868 6869
    mysql_stmt_store_result(), this is our only way to know how much
    buffer to allocate for result data
6870 6871 6872
  */
  {
    my_bool one= 1;
6873 6874 6875
    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));
6876 6877 6878 6879 6880
  }

  /*
    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!
6881
    Store the result of the query if if will return any fields
6882
  */
6883
  if (mysql_stmt_field_count(stmt) && mysql_stmt_store_result(stmt))
6884
  {
6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900
    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)
6901
    {
6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917
      /* 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);
6918 6919 6920
    }
    else
    {
6921 6922 6923
      /*
	This is a query without resultset
      */
6924
    }
6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951

    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);
	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);
      }
    }

    if (!disable_info)
      append_info(ds, mysql_affected_rows(mysql), mysql_info(mysql));

6952 6953
  }

6954 6955
end:
  if (!disable_warnings)
6956
  {
6957 6958
    dynstr_free(&ds_prepare_warnings);
    dynstr_free(&ds_execute_warnings);
6959 6960
  }

6961 6962 6963 6964 6965 6966 6967 6968

  /* Close the statement if - no reconnect, need new prepare */
  if (mysql->reconnect)
  {
    mysql_stmt_close(stmt);
    cur_con->stmt= NULL;
  }

6969
  /*
6970 6971 6972
    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.
6973
  */
6974 6975

  var_set_errno(mysql_stmt_errno(stmt));
6976

6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994
  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))
6995
  {
6996 6997 6998
    DBUG_PRINT("info", ("Creating util_mysql"));
    if (!(mysql= mysql_init(mysql)))
      die("Failed in mysql_init()");
6999

7000 7001 7002 7003
    if (opt_connect_timeout)
      mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT,
                    (void *) &opt_connect_timeout);

7004 7005
    /* enable local infile, in non-binary builds often disabled by default */
    mysql_options(mysql, MYSQL_OPT_LOCAL_INFILE, 0);
7006 7007 7008
    safe_connect(mysql, "util", org_mysql->host, org_mysql->user,
                 org_mysql->passwd, org_mysql->db, org_mysql->port,
                 org_mysql->unix_socket);
7009

7010 7011
    cur_con->util_mysql= mysql;
  }
7012

7013 7014
  return mysql_query(mysql, query);
}
7015 7016 7017



7018 7019
/*
  Run query
7020

7021 7022 7023 7024 7025
  SYNPOSIS
    run_query()
     mysql	mysql handle
     command	currrent command pointer

7026 7027 7028 7029
  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
*/
7030

holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
7031
void run_query(struct st_connection *cn, struct st_command *command, int flags)
7032
{
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
7033
  MYSQL *mysql= &cn->mysql;
7034
  DYNAMIC_STRING *ds;
7035
  DYNAMIC_STRING *save_ds= NULL;
7036
  DYNAMIC_STRING ds_result;
7037
  DYNAMIC_STRING ds_sorted;
7038 7039 7040 7041 7042 7043 7044
  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));
7045
  DBUG_ENTER("run_query");
7046

7047
  init_dynamic_string(&ds_warnings, NULL, 0, 256);
7048

7049 7050 7051 7052
  /*
    Evaluate query if this is an eval command
  */
  if (command->type == Q_EVAL)
7053
  {
7054 7055 7056 7057
    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;
7058
  }
7059
  else
7060
  {
7061 7062
    query = command->query;
    query_len = strlen(query);
7063 7064
  }

7065
  /*
7066
    When command->require_file is set the output of _this_ query
7067 7068 7069 7070
    should be compared with an already existing file
    Create a temporary dynamic string to contain the output from
    this query.
  */
7071
  if (command->require_file[0])
7072 7073 7074 7075 7076 7077
  {
    init_dynamic_string(&ds_result, "", 1024, 1024);
    ds= &ds_result;
  }
  else
    ds= &ds_res;
7078

7079 7080 7081 7082 7083 7084 7085 7086 7087
  /*
    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);
  }
7088

7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110
  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)));
7111

7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123
      /* 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);
7124

7125 7126 7127 7128 7129 7130
      /*
        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);
    }
7131

7132
    dynstr_free(&query_str);
7133 7134 7135

  }

7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159
  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)));
7160

7161 7162 7163
      /* Log error to create sp */
      verbose_msg("Failed to create sp '%s' %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql));
7164

7165 7166
    }
    else
7167
    {
7168 7169 7170 7171
      sp_created= 1;

      query= (char*)"CALL mysqltest_tmp_sp()";
      query_len = strlen(query);
7172
    }
7173
    dynstr_free(&query_str);
7174 7175
  }

7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187
  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;
  }

7188 7189 7190 7191 7192
  /*
    Find out how to run this query

    Always run with normal C API if it's not a complete
    SEND + REAP
7193

7194 7195 7196 7197 7198 7199 7200 7201
    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
7202
    run_query_normal(cn, command, flags, query, query_len,
7203 7204
		     ds, &ds_warnings);

7205 7206 7207 7208
  dynstr_free(&ds_warnings);
  if (command->type == Q_EVAL)
    dynstr_free(&eval_query);

7209 7210 7211 7212 7213 7214 7215
  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);
  }
7216 7217

  if (sp_created)
7218
  {
7219 7220
    if (util_query(mysql, "DROP PROCEDURE mysqltest_tmp_sp "))
      die("Failed to drop sp: %d: %s", mysql_errno(mysql), mysql_error(mysql));
7221 7222
  }

7223 7224 7225 7226 7227 7228 7229
  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));
  }

7230
  if (command->require_file[0])
7231
  {
7232 7233 7234 7235 7236
    /* 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);
7237 7238
  }

7239 7240
  if (ds == &ds_result)
    dynstr_free(&ds_result);
7241
  DBUG_VOID_RETURN;
7242 7243
}

7244
/****************************************************************************/
7245
/*
7246
  Functions to detect different SQL statements
7247 7248
*/

7249
char *re_eprint(int err)
7250
{
7251 7252 7253 7254 7255 7256
  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);
}
7257

7258 7259 7260 7261 7262
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)
7263
  {
7264 7265 7266
    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
7267
	re_eprint(err), (int)len, (int)sizeof(erbuf), erbuf);
7268 7269 7270
  }
}

7271
void init_re(void)
7272
{
7273 7274 7275 7276
  /*
    Filter for queries that can be run using the
    MySQL Prepared Statements C API
  */
7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290
  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:]])";

7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306
  /*
    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);
7307 7308 7309
}


7310
int match_re(my_regex_t *re, char *str)
7311
{
7312
  int err= my_regexec(re, str, (size_t)0, NULL, 0);
7313 7314 7315 7316 7317

  if (err == 0)
    return 1;
  else if (err == REG_NOMATCH)
    return 0;
7318

7319 7320
  {
    char erbuf[100];
7321 7322
    int len= my_regerror(err, re, erbuf, sizeof(erbuf));
    die("error %s, %d/%d `%s'\n",
Sergey Glukhov's avatar
Sergey Glukhov committed
7323
	re_eprint(err), (int)len, (int)sizeof(erbuf), erbuf);
7324
  }
7325
  return 0;
7326 7327
}

7328
void free_re(void)
7329
{
kent@mysql.com's avatar
kent@mysql.com committed
7330
  my_regfree(&ps_re);
7331 7332 7333
  my_regfree(&sp_re);
  my_regfree(&view_re);
  my_regex_end();
7334 7335 7336 7337
}

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

7338
void get_command_type(struct st_command* command)
7339
{
7340 7341
  char save;
  uint type;
7342
  DBUG_ENTER("get_command_type");
monty@mysql.com's avatar
monty@mysql.com committed
7343

7344
  if (*command->query == '}')
7345
  {
7346
    command->type = Q_END_BLOCK;
monty@mysql.com's avatar
monty@mysql.com committed
7347
    DBUG_VOID_RETURN;
7348 7349
  }

7350 7351 7352 7353
  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;
7354
  if (type > 0)
7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367
  {
    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;
    }
  }
7368
  else
7369
  {
7370 7371 7372 7373 7374 7375 7376 7377 7378
    /* No mysqltest command matched */

    if (command->type != Q_COMMENT_WITH_COMMAND)
    {
      /* A query that will sent to mysqld */
      command->type= Q_QUERY;
    }
    else
    {
7379 7380 7381 7382
      /* -- "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");
7383
    }
7384
  }
7385 7386 7387 7388 7389 7390 7391 7392 7393

  /* 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));
  command->abort_on_error= (command->expected_errors.count == 0 &&
                            abort_on_error);

monty@mysql.com's avatar
monty@mysql.com committed
7394
  DBUG_VOID_RETURN;
7395
}
7396

monty@mysql.com's avatar
monty@mysql.com committed
7397

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

7399 7400
/*
  Record how many milliseconds it took to execute the test file
7401
  up until the current line and write it to .progress file
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
7402

7403
*/
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
7404

7405 7406
void mark_progress(struct st_command* command __attribute__((unused)),
                   int line)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
7407
{
7408 7409 7410
  static ulonglong progress_start= 0; // < Beware
  DYNAMIC_STRING ds_progress;

7411 7412 7413 7414 7415
  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
7416

7417 7418 7419
  if (init_dynamic_string(&ds_progress, "", 256, 256))
    die("Out of memory");

7420 7421 7422 7423
  /* 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
7424

7425 7426 7427 7428
  /* 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
7429

7430 7431 7432
  /* Filename */
  dynstr_append(&ds_progress, cur_file->file_name);
  dynstr_append_mem(&ds_progress, ":", 1);
7433

7434 7435 7436 7437 7438 7439
  /* 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);
7440

7441 7442 7443 7444
  progress_file.write(&ds_progress);

  dynstr_free(&ds_progress);

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
7445
}
7446

7447
#ifdef HAVE_STACKTRACE
7448

7449
static void dump_backtrace(void)
7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465
{
  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);
}

7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478
#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
7479 7480 7481 7482 7483 7484 7485

  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
7486 7487
}

7488 7489 7490 7491 7492 7493 7494
#ifdef __WIN__

LONG WINAPI exception_filter(EXCEPTION_POINTERS *exp)
{
  __try
  {
    my_set_exception_pointers(exp);
7495
    signal_handler(exp->ExceptionRecord->ExceptionCode);
7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531
  }
  __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");

7532
#ifdef HAVE_STACKTRACE
7533
  my_init_stacktrace();
7534
#endif
7535 7536 7537 7538 7539

  sa.sa_flags = SA_RESETHAND | SA_NODEFER;
  sigemptyset(&sa.sa_mask);
  sigprocmask(SIG_SETMASK, &sa.sa_mask, NULL);

7540
  sa.sa_handler= signal_handler;
7541 7542 7543 7544 7545 7546 7547 7548

  sigaction(SIGSEGV, &sa, NULL);
  sigaction(SIGABRT, &sa, NULL);
#ifdef SIGBUS
  sigaction(SIGBUS, &sa, NULL);
#endif
  sigaction(SIGILL, &sa, NULL);
  sigaction(SIGFPE, &sa, NULL);
7549 7550

  DBUG_VOID_RETURN;
7551 7552 7553
}

#endif /* !__WIN__ */
7554

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
7555
int main(int argc, char **argv)
7556
{
7557
  struct st_command *command;
7558
  my_bool q_send_flag= 0, abort_flag= 0;
7559
  uint command_executed= 0, last_command_executed= 0;
7560
  char save_file[FN_REFLEN];
7561 7562
  MY_INIT(argv[0]);

7563 7564 7565
  save_file[0]= 0;
  TMPDIR[0]= 0;

7566 7567
  init_signal_handling();

7568 7569 7570
  /* Init expected errors */
  memset(&saved_expected_errors, 0, sizeof(saved_expected_errors));

7571 7572 7573 7574 7575 7576
  /* Init connections */
  memset(connections, 0, sizeof(connections));
  connections_end= connections +
    (sizeof(connections)/sizeof(struct st_connection)) - 1;
  next_con= connections + 1;

7577 7578 7579 7580 7581 7582
#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*/

7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597
  /* 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
7598

Konstantin Osipov's avatar
Konstantin Osipov committed
7599 7600
  if (my_hash_init(&var_hash, charset_info,
                   1024, 0, 0, get_var_key, var_free, MYF(0)))
7601
    die("Variable hash initialization failed");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
7602

7603 7604
  var_set_string("$MYSQL_SERVER_VERSION", MYSQL_SERVER_VERSION);

7605
  memset(&master_pos, 0, sizeof(master_pos));
7606

7607 7608 7609
  parser.current_line= parser.read_lines= 0;
  memset(&var_reg, 0, sizeof(var_reg));

7610
  init_builtin_echo();
7611
#ifdef __WIN__
7612
#ifndef USE_CYGWIN
7613
  is_windows= 1;
7614
#endif
7615 7616 7617
  init_tmp_sh_file();
  init_win_path_patterns();
#endif
7618

7619 7620
  init_dynamic_string(&ds_res, "", 2048, 2048);

7621
  parse_args(argc, argv);
7622

7623
  log_file.open(opt_logdir, result_file_name, ".log");
7624
  verbose_msg("Logging to '%s'.", log_file.file_name());
7625
  if (opt_mark_progress)
7626
  {
7627
    progress_file.open(opt_logdir, result_file_name, ".progress");
7628 7629
    verbose_msg("Tracing progress in '%s'.", progress_file.file_name());
  }
7630

7631 7632 7633 7634 7635
  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);

7636 7637
  DBUG_PRINT("info",("result_file: '%s'",
                     result_file_name ? result_file_name : ""));
7638 7639
  verbose_msg("Results saved in '%s'.", 
              result_file_name ? result_file_name : "");
7640 7641 7642
  if (mysql_server_init(embedded_server_arg_count,
			embedded_server_args,
			(char**) embedded_server_groups))
7643
    die("Can't initialize MySQL server");
7644
  server_initialized= 1;
7645
  if (cur_file == file_stack && cur_file->file == 0)
7646
  {
7647 7648
    cur_file->file= stdin;
    cur_file->file_name= my_strdup("<stdin>", MYF(MY_WME));
7649
    cur_file->lineno= 1;
7650
  }
7651 7652 7653 7654 7655 7656 7657
  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)
7658
    ps_protocol_enabled= 1;
7659

7660 7661
  st_connection *con= connections;
  if (!( mysql_init(&con->mysql)))
7662
    die("Failed in mysql_init()");
7663 7664 7665
  if (opt_connect_timeout)
    mysql_options(&con->mysql, MYSQL_OPT_CONNECT_TIMEOUT,
                  (void *) &opt_connect_timeout);
7666
  if (opt_compress)
7667 7668 7669
    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,
7670 7671
                charset_info->csname);
  if (opt_charsets_dir)
7672
    mysql_options(&con->mysql, MYSQL_SET_CHARSET_DIR,
7673
                  opt_charsets_dir);
bar@mysql.com's avatar
bar@mysql.com committed
7674

gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
7675
#ifdef HAVE_OPENSSL
7676

gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
7677
  if (opt_use_ssl)
7678
  {
7679
    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
7680
		  opt_ssl_capath, opt_ssl_cipher);
7681
#if MYSQL_VERSION_ID >= 50000
7682 7683
    /* Turn on ssl_verify_server_cert only if host is "localhost" */
    opt_ssl_verify_server_cert= opt_host && !strcmp(opt_host, "localhost");
7684
    mysql_options(&con->mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
7685 7686 7687
                  &opt_ssl_verify_server_cert);
#endif
  }
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
7688
#endif
7689

7690
  if (!(con->name = my_strdup("default", MYF(MY_WME))))
7691
    die("Out of memory");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
7692

7693
  safe_connect(&con->mysql, con->name, opt_host, opt_user, opt_pass,
7694
               opt_db, opt_port, unix_sock);
7695

7696 7697
  /* 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
7698

7699 7700 7701 7702 7703
  /*
    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
  */
7704 7705
  var_set_errno(-1);

7706
  set_current_connection(con);
7707

7708 7709 7710 7711 7712
  if (opt_include)
  {
    open_file(opt_include);
  }

7713
  verbose_msg("Start processing test commands from '%s' ...", cur_file->file_name);
7714
  while (!read_command(&command) && !abort_flag)
7715 7716
  {
    int current_line_inc = 1, processed = 0;
7717 7718
    if (command->type == Q_UNKNOWN || command->type == Q_COMMENT_WITH_COMMAND)
      get_command_type(command);
7719 7720 7721 7722 7723

    if (parsing_disabled &&
        command->type != Q_ENABLE_PARSING &&
        command->type != Q_DISABLE_PARSING)
    {
7724
      /* Parsing is disabled, silently convert this line to a comment */
7725 7726 7727
      command->type= Q_COMMENT;
    }

7728 7729 7730 7731 7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749 7750 7751 7752
    my_bool ok_to_do= cur_block->ok;
    /*
      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 ||
          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)
7753
    {
7754
      command->last_argument= command->first_argument;
7755
      processed = 1;
7756 7757 7758 7759 7760
      switch (command->type) {
      case Q_CONNECT:
        do_connect(command);
        break;
      case Q_CONNECTION: select_connection(command); break;
7761
      case Q_DISCONNECT:
7762
      case Q_DIRTY_CLOSE:
7763 7764 7765 7766
	do_close_connection(command); break;
      case Q_RPL_PROBE: do_rpl_probe(command); break;
      case Q_ENABLE_RPL_PARSE:	 do_enable_rpl_parse(command); break;
      case Q_DISABLE_RPL_PARSE:  do_disable_rpl_parse(command); break;
7767
      case Q_ENABLE_QUERY_LOG:   disable_query_log=0; break;
7768
      case Q_DISABLE_QUERY_LOG:  disable_query_log=1; break;
7769 7770
      case Q_ENABLE_ABORT_ON_ERROR:  abort_on_error=1; break;
      case Q_DISABLE_ABORT_ON_ERROR: abort_on_error=0; break;
7771 7772
      case Q_ENABLE_RESULT_LOG:  disable_result_log=0; break;
      case Q_DISABLE_RESULT_LOG: disable_result_log=1; break;
7773 7774
      case Q_ENABLE_WARNINGS:    disable_warnings=0; break;
      case Q_DISABLE_WARNINGS:   disable_warnings=1; break;
7775 7776
      case Q_ENABLE_INFO:        disable_info=0; break;
      case Q_DISABLE_INFO:       disable_info=1; break;
7777
      case Q_ENABLE_METADATA:    display_metadata=1; break;
7778
      case Q_DISABLE_METADATA:   display_metadata=0; break;
7779 7780 7781 7782 7783 7784 7785 7786 7787
      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;
7788 7789
      case Q_MKDIR: do_mkdir(command); break;
      case Q_RMDIR: do_rmdir(command); break;
7790 7791 7792 7793 7794 7795 7796
      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;
7797 7798
      case Q_FILE_EXIST: do_file_exist(command); break;
      case Q_WRITE_FILE: do_write_file(command); break;
7799
      case Q_APPEND_FILE: do_append_file(command); break;
7800
      case Q_DIFF_FILES: do_diff_files(command); break;
7801
      case Q_SEND_QUIT: do_send_quit(command); break;
7802
      case Q_CHANGE_USER: do_change_user(command); break;
7803
      case Q_CAT_FILE: do_cat_file(command); break;
7804
      case Q_COPY_FILE: do_copy_file(command); break;
7805
      case Q_MOVE_FILE: do_move_file(command); break;
7806
      case Q_CHMOD_FILE: do_chmod_file(command); break;
7807
      case Q_PERL: do_perl(command); break;
7808
      case Q_DELIMITER:
7809
        do_delimiter(command);
7810
	break;
7811 7812 7813 7814 7815 7816
      case Q_DISPLAY_VERTICAL_RESULTS:
        display_result_vertically= TRUE;
        break;
      case Q_DISPLAY_HORIZONTAL_RESULTS:
	display_result_vertically= FALSE;
        break;
7817
      case Q_SORTED_RESULT:
7818 7819 7820 7821 7822 7823
        /*
          Turn on sorting of result set, will be reset after next
          command
        */
	display_result_sorted= TRUE;
        break;
7824
      case Q_LET: do_let(command); break;
7825
      case Q_EVAL_RESULT:
7826
        die("'eval_result' command  is deprecated");
7827
      case Q_EVAL:
7828 7829
      case Q_QUERY_VERTICAL:
      case Q_QUERY_HORIZONTAL:
7830
	if (command->query == command->query_buf)
monty@mysql.com's avatar
monty@mysql.com committed
7831
        {
7832
          /* Skip the first part of command, i.e query_xxx */
7833 7834
	  command->query= command->first_argument;
          command->first_word_len= 0;
monty@mysql.com's avatar
monty@mysql.com committed
7835
        }
7836
	/* fall through */
7837
      case Q_QUERY:
7838
      case Q_REAP:
7839
      {
7840 7841 7842 7843
	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;

7844 7845 7846 7847 7848 7849 7850 7851 7852 7853
        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;
        }
7854 7855

        /* Check for special property for this query */
7856
        display_result_vertically|= (command->type == Q_QUERY_VERTICAL);
7857

7858
	if (save_file[0])
7859
	{
7860
	  strmake(command->require_file, save_file, sizeof(save_file) - 1);
7861
	  save_file[0]= 0;
7862
	}
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
7863
	run_query(cur_con, command, flags);
7864 7865
	command_executed++;
        command->last_argument= command->end;
7866 7867 7868 7869

        /* Restore settings */
	display_result_vertically= old_display_result_vertically;

7870
	break;
7871
      }
7872
      case Q_SEND:
7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886
        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;

7887
	/*
7888 7889 7890
	  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
7891
	  is given on this connection.
7892
        */
7893
	run_query(cur_con, command, QUERY_SEND_FLAG);
7894 7895
	command_executed++;
        command->last_argument= command->end;
7896
	break;
7897 7898
      case Q_REQUIRE:
	do_get_file_name(command, save_file, sizeof(save_file));
7899
	break;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
7900
      case Q_ERROR:
7901
        do_get_errcodes(command);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
7902
	break;
7903
      case Q_REPLACE:
7904
	do_get_replace(command);
7905
	break;
7906 7907 7908
      case Q_REPLACE_REGEX:
        do_get_replace_regex(command);
        break;
7909
      case Q_REPLACE_COLUMN:
7910
	do_get_replace_column(command);
7911
	break;
7912
      case Q_SAVE_MASTER_POS: do_save_master_pos(); break;
7913
      case Q_SYNC_WITH_MASTER: do_sync_with_master(command); break;
7914 7915 7916
      case Q_SYNC_SLAVE_WITH_MASTER:
      {
	do_save_master_pos();
7917 7918
	if (*command->first_argument)
	  select_connection(command);
7919
	else
7920
	  select_connection_name("slave");
7921
	do_sync_with_master2(command, 0);
7922 7923
	break;
      }
7924
      case Q_COMMENT:				/* Ignore row */
7925
        command->last_argument= command->end;
7926
	break;
7927
      case Q_PING:
7928 7929
        handle_command_error(command, mysql_ping(&cur_con->mysql));
        break;
7930
      case Q_SEND_SHUTDOWN:
7931 7932 7933 7934
        handle_command_error(command,
                             mysql_shutdown(&cur_con->mysql,
                                            SHUTDOWN_DEFAULT));
        break;
7935 7936
      case Q_SHUTDOWN_SERVER:
        do_shutdown_server(command);
7937
        break;
7938
      case Q_EXEC:
7939 7940
	do_exec(command);
	command_executed++;
7941
	break;
kent@mysql.com's avatar
kent@mysql.com committed
7942 7943 7944 7945 7946 7947 7948 7949
      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;
7950
      case Q_CHARACTER_SET:
7951
	do_set_charset(command);
kent@mysql.com's avatar
kent@mysql.com committed
7952
	break;
7953 7954
      case Q_DISABLE_PS_PROTOCOL:
        ps_protocol_enabled= 0;
7955 7956
        /* Close any open statements */
        close_statements();
7957 7958 7959 7960
        break;
      case Q_ENABLE_PS_PROTOCOL:
        ps_protocol_enabled= ps_protocol;
        break;
7961
      case Q_DISABLE_RECONNECT:
7962
        set_reconnect(&cur_con->mysql, 0);
7963 7964
        break;
      case Q_ENABLE_RECONNECT:
7965
        set_reconnect(&cur_con->mysql, 1);
7966 7967
        /* Close any open statements - no reconnect, need new prepare */
        close_statements();
7968 7969 7970 7971 7972 7973
        break;
      case Q_DISABLE_PARSING:
        if (parsing_disabled == 0)
          parsing_disabled= 1;
        else
          die("Parsing is already disabled");
7974
        break;
7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985
      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:
7986
        /* Abort test with error code and error message */
7987 7988
        die("%s", command->first_argument);
        break;
7989 7990 7991 7992
      case Q_EXIT:
        /* Stop processing any more commands */
        abort_flag= 1;
        break;
7993 7994 7995
      case Q_SKIP:
        abort_not_supported_test("%s", command->first_argument);
        break;
7996

7997 7998 7999 8000
      case Q_RESULT:
        die("result, deprecated command");
        break;

8001 8002
      default:
        processed= 0;
8003
        break;
8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019
      }
    }

    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);

8020 8021
    if (command->type != Q_ERROR &&
        command->type != Q_COMMENT)
8022 8023
    {
      /*
8024
        As soon as any non "error" command or comment has been executed,
8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036
        the array with expected errors should be cleared
      */
      memset(&saved_expected_errors, 0, sizeof(saved_expected_errors));
    }

    if (command_executed != last_command_executed)
    {
      /*
        As soon as any command has been executed,
        the replace structures should be cleared
      */
      free_all_replace();
8037

8038
      /* Also reset "sorted_result" */
8039
      display_result_sorted= FALSE;
8040 8041 8042 8043 8044 8045
    }
    last_command_executed= command_executed;

    parser.current_line += current_line_inc;
    if ( opt_mark_progress )
      mark_progress(command, parser.current_line);
8046

Serge Kozlov's avatar
Serge Kozlov committed
8047
    /* Write result from command to log file immediately */
8048
    log_file.write(&ds_res);
Serge Kozlov's avatar
Serge Kozlov committed
8049
    log_file.flush();
8050
    dynstr_set(&ds_res, 0);
8051 8052
  }

8053 8054
  log_file.close();

8055
  start_lineno= 0;
8056
  verbose_msg("... Done processing test commands.");
8057 8058 8059 8060

  if (parsing_disabled)
    die("Test ended with parsing disabled");

8061 8062
  my_bool empty_result= FALSE;
  
8063 8064 8065
  /*
    The whole test has been executed _sucessfully_.
    Time to compare result or save it to record file.
8066
    The entire output from test is in the log file
8067
  */
8068
  if (log_file.bytes_written())
8069
  {
8070
    if (result_file_name)
8071
    {
8072 8073
      /* A result file has been specified */

8074 8075
      if (record)
      {
8076 8077 8078 8079 8080 8081 8082
	/* 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);

8083 8084 8085
      }
      else
      {
8086 8087
	/* Check that the output from test is equal to result file */
	check_result();
8088 8089 8090 8091
      }
    }
    else
    {
8092 8093 8094 8095 8096 8097 8098
      /*
        No result_file_name specified, the result
        has been printed to stdout, exit with error
        unless script has called "exit" to indicate success
      */
      if (abort_flag == 0)
        die("Exit with failure! Call 'exit' in script to return with sucess");
8099 8100 8101 8102
    }
  }
  else
  {
8103 8104 8105 8106 8107 8108 8109 8110 8111 8112
    /* 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 */
    }
8113 8114
  }

8115 8116
  if (!command_executed && result_file_name && !empty_result)
    die("No queries executed but non-empty result file found!");
8117

8118
  verbose_msg("Test has succeeded!");
8119 8120
  timer_output();
  /* Yes, if we got this far the test has suceeded! Sakila smiles */
8121 8122
  cleanup_and_exit(0);
  return 0; /* Keep compiler happy too */
8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162
}


/*
  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)
{
8163
  return my_micro_time() / 1000;
8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181 8182 8183 8184 8185
}


/*
  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 */
8186
  start= buff= (char*)my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
8187 8188 8189 8190 8191 8192 8193 8194 8195 8196 8197 8198 8199 8200 8201 8202
  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);
    my_free(replace_column[column_number-1], MY_ALLOW_ZERO_PTR);
    replace_column[column_number-1]= my_strdup(to, MYF(MY_WME | MY_FAE));
    set_if_bigger(max_replace_column, column_number);
  }
  my_free(start, MYF(0));
  command->last_argument= command->end;
8203 8204

  DBUG_VOID_RETURN;
8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227 8228 8229 8230 8231
}


void free_replace_column()
{
  uint i;
  for (i=0 ; i < max_replace_column ; i++)
  {
    if (replace_column[i])
    {
      my_free(replace_column[i], 0);
      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 */
8232
  uchar	*str;					/* Strings is here */
8233 8234 8235 8236 8237
  int7	*flag;					/* Flag about each var. */
  uint	array_allocs,max_count,length,max_length;
} POINTER_ARRAY;

struct st_replace;
8238 8239 8240
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);
8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269
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);
8270
  start= buff= (char*)my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
8271 8272 8273 8274 8275 8276 8277
  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
8278 8279 8280
#ifdef __WIN__
    fix_win_paths(to, from - to);
#endif
8281 8282 8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300
    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);
  my_free(start, MYF(0));
  command->last_argument= command->end;
  DBUG_VOID_RETURN;
}

8301

8302 8303 8304 8305 8306
void free_replace()
{
  DBUG_ENTER("free_replace");
  if (glob_replace)
  {
8307
    my_free(glob_replace,MYF(0));
8308 8309 8310 8311
    glob_replace=0;
  }
  DBUG_VOID_RETURN;
}
8312

8313 8314

typedef struct st_replace {
8315
  my_bool found;
8316 8317 8318 8319
  struct st_replace *next[256];
} REPLACE;

typedef struct st_replace_found {
8320
  my_bool found;
8321 8322 8323 8324 8325 8326 8327
  char *replace_string;
  uint to_offset;
  int from_offset;
} REPLACE_STRING;


void replace_strings_append(REPLACE *rep, DYNAMIC_STRING* ds,
8328 8329
                            const char *str,
                            int len __attribute__((unused)))
8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345 8346
{
  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)
8347
    {
8348 8349 8350 8351
      /* 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;
8352 8353
    }

8354 8355 8356 8357 8358 8359 8360 8361 8362 8363 8364 8365 8366
    /* 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)
8367
    {
8368 8369 8370
      /* End of from string */
      DBUG_PRINT("exit", ("Found end of from string"));
      DBUG_VOID_RETURN;
8371
    }
8372 8373 8374
    DBUG_ASSERT(from <= str+len);
    start= from;
    rep_pos=rep;
8375
  }
8376
}
8377

8378

8379 8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391 8392 8393 8394 8395 8396 8397 8398 8399 8400 8401 8402 8403 8404 8405 8406 8407 8408 8409 8410 8411 8412 8413 8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474
/*
  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)
8475
  {
8476 8477 8478
    bzero(&reg,sizeof(reg));
    /* find the start of the statement */
    while (p < expr_end)
8479
    {
8480 8481 8482
      if (*p == '/')
        break;
      p++;
8483
    }
8484 8485

    if (p == expr_end || ++p == expr_end)
8486
    {
8487 8488 8489 8490
      if (res->regex_arr.elements)
        break;
      else
        goto err;
8491
    }
8492 8493
    /* we found the start */
    reg.pattern= buf_p;
8494

8495 8496
    /* Find first argument -- pattern string to be removed */
    PARSE_REGEX_ARG
8497

8498 8499 8500 8501 8502 8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517
      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 */
8518
    if (insert_dynamic(&res->regex_arr,(uchar*) &reg))
8519
      die("Out of memory");
8520
  }
8521 8522 8523 8524 8525 8526
  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;
8527

8528
err:
8529
  my_free(res,0);
8530 8531 8532
  die("Error parsing replace_regex \"%s\"", expr);
  return 0;
}
8533

8534
/*
8535 8536 8537 8538 8539 8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550
  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
8551 8552
*/

8553
int multi_reg_replace(struct st_replace_regex* r,char* val)
8554
{
8555 8556 8557
  uint i;
  char* in_buf, *out_buf;
  int* buf_len_p;
8558

8559 8560 8561 8562
  in_buf= val;
  out_buf= r->even_buf;
  buf_len_p= &r->even_buf_len;
  r->buf= 0;
8563

8564 8565
  /* For each substitution, do the replace */
  for (i= 0; i < r->regex_arr.elements; i++)
8566
  {
8567 8568 8569
    struct st_regex re;
    char* save_out_buf= out_buf;

8570
    get_dynamic(&r->regex_arr,(uchar*)&re,i);
8571 8572 8573

    if (!reg_replace(&out_buf, buf_len_p, re.pattern, re.replace,
                     in_buf, re.icase))
8574
    {
8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589 8590 8591
      /* 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;
8592 8593
    }
  }
8594 8595

  return (r->buf == 0);
8596
}
8597

8598 8599 8600 8601 8602 8603 8604 8605 8606 8607
/*
  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
8608
{
8609 8610 8611 8612 8613
  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
8614 8615
}

8616
void free_replace_regex()
kent@mysql.com's avatar
kent@mysql.com committed
8617
{
8618 8619 8620 8621 8622
  if (glob_replace_regex)
  {
    delete_dynamic(&glob_replace_regex->regex_arr);
    my_free(glob_replace_regex->even_buf,MYF(MY_ALLOW_ZERO_PTR));
    my_free(glob_replace_regex->odd_buf,MYF(MY_ALLOW_ZERO_PTR));
8623
    my_free(glob_replace_regex,MYF(0));
8624 8625
    glob_replace_regex=0;
  }
kent@mysql.com's avatar
kent@mysql.com committed
8626 8627
}

8628 8629


8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643
/*
  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
8644

8645
  IN:
8646

8647 8648 8649 8650 8651 8652 8653 8654 8655 8656 8657 8658
  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;
8659
  char *replace_end;
8660 8661 8662 8663 8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675
  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;
8676

8677
  SECURE_REG_BUF
8678

8679 8680
  if (icase)
    cflags|= REG_ICASE;
8681

8682 8683 8684 8685 8686
  if ((err_code= my_regcomp(&r,pattern,cflags,&my_charset_latin1)))
  {
    check_regerr(&r,err_code);
    return 1;
  }
8687

8688 8689
  subs= (my_regmatch_t*)my_malloc(sizeof(my_regmatch_t) * (r.re_nsub+1),
                                  MYF(MY_WME+MY_FAE));
8690

8691 8692 8693
  *res_p= 0;
  str_p= string;
  replace_end= replace + strlen(replace);
8694

8695 8696
  /* for each pattern match instance perform a replacement */
  while (!err_code)
8697
  {
8698 8699 8700 8701 8702 8703 8704 8705 8706 8707 8708 8709 8710 8711 8712 8713 8714 8715 8716 8717 8718 8719
    /* 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
      */
8720
      need_buf_len= (res_p - buf) + (int) subs[0].rm_so;
8721 8722 8723 8724 8725 8726 8727 8728 8729

      /* 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)
        {
8730
          back_ref_num= (int) (expr_p[1] - '0');
8731 8732 8733 8734 8735
        }

        /* found a valid back_ref (eg. \1)*/
        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
        {
8736
          regoff_t start_off, end_off;
8737 8738 8739
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
              (end_off=subs[back_ref_num].rm_eo) > -1)
          {
8740
            need_buf_len += (int) (end_off - start_off);
8741 8742 8743 8744 8745 8746 8747 8748 8749 8750 8751 8752 8753 8754 8755 8756 8757 8758 8759
          }
          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)
        {
8760
          memcpy(res_p, str_p, (size_t) subs[0].rm_so);
8761 8762 8763 8764 8765 8766 8767 8768 8769 8770 8771 8772 8773 8774 8775 8776 8777 8778
          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)
        {
8779
          regoff_t start_off, end_off;
8780 8781 8782
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
              (end_off=subs[back_ref_num].rm_eo) > -1)
          {
8783
            int block_len= (int) (end_off - start_off);
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
            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;
    }
8817
  }
8818
  my_free(subs, MYF(0));
8819 8820 8821 8822 8823 8824
  my_regfree(&r);
  *res_p= 0;
  *buf_p= buf;
  *buf_len_p= buf_len;
  return 0;
}
8825 8826


8827 8828 8829
#ifndef WORD_BIT
#define WORD_BIT (8*sizeof(uint))
#endif
8830 8831

#define SET_MALLOC_HUNC 64
8832
#define LAST_CHAR_CODE 259
8833 8834

typedef struct st_rep_set {
8835 8836
  uint	*bits;				/* Pointer to used sets */
  short next[LAST_CHAR_CODE];		/* Pointer to next sets */
8837 8838
  uint	found_len;			/* Best match to date */
  int	found_offset;
8839 8840
  uint	table_offset;
  uint	size_of_bits;			/* For convinience */
8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 8861 8862 8863
} 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;


8864 8865 8866 8867 8868 8869 8870 8871 8872 8873 8874 8875 8876 8877
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);
8878 8879
uint start_at_word(char * pos);
uint end_of_word(char * pos);
8880 8881 8882 8883

static uint found_sets=0;


8884
uint replace_len(char * str)
8885 8886 8887 8888 8889 8890 8891 8892 8893 8894 8895
{
  uint len=0;
  while (*str)
  {
    str++;
    len++;
  }
  return len;
}

/* Init a replace structure for further calls */
8896

8897 8898
REPLACE *init_replace(char * *from, char * *to,uint count,
		      char * word_end_chars)
8899
{
8900 8901 8902
  static const int SPACE_CHAR= 256;
  static const int END_OF_LINE= 258;

8903 8904 8905
  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];
8906
  char * pos, *to_pos, **to_array;
8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918 8919 8920 8921 8922 8923 8924 8925 8926 8927 8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947 8948 8949
  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);
  }
  VOID(make_new_set(&sets));			/* Set starting set */
  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);
8950
    my_free(found_set,MYF(0));
8951 8952 8953
    DBUG_RETURN(0);
  }

8954
  /* Init follow_ptr[] */
8955 8956 8957 8958
  for (i=0, states=1, follow_ptr=follow+1 ; i < count ; i++)
  {
    if (from[i][0] == '\\' && from[i][1] == '^')
    {
8959
      internal_set_bit(start_states,states+1);
8960 8961 8962 8963 8964 8965 8966 8967
      if (!from[i][2])
      {
	start_states->table_offset=i;
	start_states->found_offset=1;
      }
    }
    else if (from[i][0] == '\\' && from[i][1] == '$')
    {
8968 8969
      internal_set_bit(start_states,states);
      internal_set_bit(word_states,states);
8970 8971 8972 8973 8974 8975 8976 8977
      if (!from[i][2] && start_states->table_offset == (uint) ~0)
      {
	start_states->table_offset=i;
	start_states->found_offset=0;
      }
    }
    else
    {
8978
      internal_set_bit(word_states,states);
8979
      if (from[i][0] == '\\' && (from[i][1] == 'b' && from[i][2]))
8980
	internal_set_bit(start_states,states+1);
8981
      else
8982
	internal_set_bit(start_states,states);
8983 8984 8985
    }
    for (pos=from[i], len=0; *pos ; pos++)
    {
8986
      follow_ptr->chr= (uchar) *pos;
8987 8988 8989 8990 8991 8992 8993 8994 8995 8996 8997 8998 8999 9000 9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021 9022 9023 9024 9025 9026 9027 9028 9029 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
      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)
9060
	      internal_set_bit(new_set,i+1);		/* To next set */
9061
	    else
9062
	      internal_set_bit(new_set,i);
9063 9064 9065 9066 9067 9068 9069 9070 9071 9072 9073 9074 9075 9076 9077 9078
	  }
	}
	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)))
9079
	      internal_clear_bit(new_set,i);
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
	    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);
      }
    }
  }

9109
  /* Alloc replace structure for the replace-state-machine */
9110 9111 9112

  if ((replace=(REPLACE*) my_malloc(sizeof(REPLACE)*(sets.count)+
				    sizeof(REPLACE_STRING)*(found_sets+1)+
9113
				    sizeof(char *)*count+result_len,
9114 9115 9116
				    MYF(MY_WME | MY_ZEROFILL))))
  {
    rep_str=(REPLACE_STRING*) (replace+sets.count);
9117 9118
    to_array= (char **) (rep_str+found_sets+1);
    to_pos=(char *) (to_array+count);
9119 9120 9121 9122 9123 9124 9125 9126 9127 9128
    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];
9129 9130
      rep_str[i].found= !bcmp((const uchar*) pos,
			      (const uchar*) "\\^", 3) ? 2 : 1;
9131 9132 9133 9134 9135 9136 9137 9138 9139 9140 9141 9142 9143 9144
      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));
    }
  }
9145
  my_free(follow,MYF(0));
9146
  free_sets(&sets);
9147
  my_free(found_set,MYF(0));
9148 9149 9150 9151 9152
  DBUG_PRINT("exit",("Replace table has %d states",sets.count));
  DBUG_RETURN(replace);
}


9153
int init_sets(REP_SETS *sets,uint states)
9154 9155 9156 9157 9158 9159 9160 9161 9162
{
  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))))
  {
9163
    my_free(sets->set,MYF(0));
9164 9165 9166 9167 9168
    return 1;
  }
  return 0;
}

9169
/* Make help sets invisible for nicer codeing */
9170

9171
void make_sets_invisible(REP_SETS *sets)
9172 9173 9174 9175 9176 9177
{
  sets->invisible=sets->count;
  sets->set+=sets->count;
  sets->count=0;
}

9178
REP_SET *make_new_set(REP_SETS *sets)
9179 9180 9181 9182 9183 9184 9185 9186 9187 9188 9189 9190 9191 9192 9193 9194
{
  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;
9195
  if (!(set=(REP_SET*) my_realloc((uchar*) sets->set_buffer,
9196
                                  sizeof(REP_SET)*count,
9197 9198 9199 9200
				  MYF(MY_WME))))
    return 0;
  sets->set_buffer=set;
  sets->set=set+sets->invisible;
9201
  if (!(bit_buffer=(uint*) my_realloc((uchar*) sets->bit_buffer,
9202 9203 9204 9205 9206 9207 9208 9209 9210 9211 9212 9213 9214
				      (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);
}

9215
void free_last_set(REP_SETS *sets)
9216 9217 9218 9219 9220 9221
{
  sets->count--;
  sets->extra++;
  return;
}

9222
void free_sets(REP_SETS *sets)
9223
{
9224 9225
  my_free(sets->set_buffer,MYF(0));
  my_free(sets->bit_buffer,MYF(0));
9226 9227 9228
  return;
}

9229
void internal_set_bit(REP_SET *set, uint bit)
9230 9231 9232 9233 9234
{
  set->bits[bit / WORD_BIT] |= 1 << (bit % WORD_BIT);
  return;
}

9235
void internal_clear_bit(REP_SET *set, uint bit)
9236 9237 9238 9239 9240 9241
{
  set->bits[bit / WORD_BIT] &= ~ (1 << (bit % WORD_BIT));
  return;
}


9242
void or_bits(REP_SET *to,REP_SET *from)
9243 9244 9245 9246 9247 9248 9249
{
  reg1 uint i;
  for (i=0 ; i < to->size_of_bits ; i++)
    to->bits[i]|=from->bits[i];
  return;
}

9250
void copy_bits(REP_SET *to,REP_SET *from)
9251
{
9252
  memcpy((uchar*) to->bits,(uchar*) from->bits,
9253 9254 9255
	 (size_t) (sizeof(uint) * to->size_of_bits));
}

9256
int cmp_bits(REP_SET *set1,REP_SET *set2)
9257
{
9258
  return bcmp((uchar*) set1->bits,(uchar*) set2->bits,
9259 9260 9261 9262
	      sizeof(uint) * set1->size_of_bits);
}


9263
/* Get next set bit from set. */
9264

9265
int get_next_bit(REP_SET *set,uint lastpos)
9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280 9281 9282 9283 9284 9285
{
  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;
}

9286 9287 9288
/* 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 */
9289

9290
int find_set(REP_SETS *sets,REP_SET *find)
9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303
{
  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 */
}

9304 9305 9306 9307 9308 9309
/* 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.
*/
9310

9311
int find_found(FOUND_SET *found_set,uint table_offset, int found_offset)
9312 9313 9314 9315 9316 9317 9318 9319 9320 9321 9322 9323
{
  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 */
}

9324
/* Return 1 if regexp starts with \b or ends with \b*/
9325

9326
uint start_at_word(char * pos)
9327
{
9328 9329
  return (((!bcmp((const uchar*) pos, (const uchar*) "\\b",2) && pos[2]) ||
           !bcmp((const uchar*) pos, (const uchar*) "\\^", 2)) ? 1 : 0);
9330 9331
}

9332
uint end_of_word(char * pos)
9333
{
9334
  char * end=strend(pos);
9335 9336 9337 9338
  return ((end > pos+2 && !bcmp((const uchar*) end-2,
                                (const uchar*) "\\b", 2)) ||
	  (end >= pos+2 && !bcmp((const uchar*) end-2,
                                (const uchar*) "\\$",2))) ? 1 : 0;
9339 9340
}

9341 9342 9343
/****************************************************************************
 * Handle replacement of strings
 ****************************************************************************/
9344

9345 9346
#define PC_MALLOC		256	/* Bytes for pointers */
#define PS_MALLOC		512	/* Bytes for data */
9347

9348
int insert_pointer_name(reg1 POINTER_ARRAY *pa,char * name)
9349
{
9350
  uint i,length,old_count;
9351
  uchar *new_pos;
9352 9353
  const char **new_array;
  DBUG_ENTER("insert_pointer_name");
9354

9355
  if (! pa->typelib.count)
9356
  {
9357 9358
    if (!(pa->typelib.type_names=(const char **)
	  my_malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
9359 9360
		     (sizeof(char *)+sizeof(*pa->flag))*
		     (sizeof(char *)+sizeof(*pa->flag))),MYF(MY_WME))))
9361
      DBUG_RETURN(-1);
9362
    if (!(pa->str= (uchar*) my_malloc((uint) (PS_MALLOC-MALLOC_OVERHEAD),
9363
				     MYF(MY_WME))))
9364
    {
9365
      my_free((char*) pa->typelib.type_names,MYF(0));
9366
      DBUG_RETURN (-1);
9367
    }
9368
    pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(uchar*)+
9369 9370 9371 9372 9373
					       sizeof(*pa->flag));
    pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
    pa->length=0;
    pa->max_length=PS_MALLOC-MALLOC_OVERHEAD;
    pa->array_allocs=1;
9374
  }
9375 9376
  length=(uint) strlen(name)+1;
  if (pa->length+length >= pa->max_length)
9377
  {
9378
    if (!(new_pos= (uchar*) my_realloc((uchar*) pa->str,
9379 9380 9381 9382
				      (uint) (pa->max_length+PS_MALLOC),
				      MYF(MY_WME))))
      DBUG_RETURN(1);
    if (new_pos != pa->str)
9383
    {
9384 9385 9386 9387 9388
      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;
9389
    }
9390
    pa->max_length+=PS_MALLOC;
9391
  }
9392
  if (pa->typelib.count >= pa->max_count-1)
9393
  {
9394 9395 9396
    int len;
    pa->array_allocs++;
    len=(PC_MALLOC*pa->array_allocs - MALLOC_OVERHEAD);
9397
    if (!(new_array=(const char **) my_realloc((uchar*) pa->typelib.type_names,
9398
					       (uint) len/
9399 9400
                                               (sizeof(uchar*)+sizeof(*pa->flag))*
                                               (sizeof(uchar*)+sizeof(*pa->flag)),
9401 9402 9403 9404
                                               MYF(MY_WME))))
      DBUG_RETURN(1);
    pa->typelib.type_names=new_array;
    old_count=pa->max_count;
9405
    pa->max_count=len/(sizeof(uchar*) + sizeof(*pa->flag));
9406
    pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
9407
    memcpy((uchar*) pa->flag,(char *) (pa->typelib.type_names+old_count),
9408
	   old_count*sizeof(*pa->flag));
9409
  }
9410
  pa->flag[pa->typelib.count]=0;			/* Reset flag */
9411
  pa->typelib.type_names[pa->typelib.count++]= (char*) pa->str+pa->length;
9412
  pa->typelib.type_names[pa->typelib.count]= NullS;	/* Put end-mark */
9413
  VOID(strmov((char*) pa->str+pa->length,name));
9414 9415 9416
  pa->length+=length;
  DBUG_RETURN(0);
} /* insert_pointer_name */
monty@mysql.com's avatar
monty@mysql.com committed
9417 9418


9419
/* free pointer array */
monty@mysql.com's avatar
monty@mysql.com committed
9420

9421 9422 9423 9424 9425
void free_pointer_array(POINTER_ARRAY *pa)
{
  if (pa->typelib.count)
  {
    pa->typelib.count=0;
9426
    my_free((char*) pa->typelib.type_names,MYF(0));
9427
    pa->typelib.type_names=0;
9428
    my_free(pa->str,MYF(0));
9429 9430
  }
} /* free_pointer_array */
monty@mysql.com's avatar
monty@mysql.com committed
9431 9432


9433
/* Functions that uses replace and replace_regex */
monty@mysql.com's avatar
monty@mysql.com committed
9434

9435 9436 9437
/* 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
9438
{
9439 9440 9441
#ifdef __WIN__
  fix_win_paths(val, len);
#endif
monty@mysql.com's avatar
monty@mysql.com committed
9442

9443
  if (glob_replace_regex)
monty@mysql.com's avatar
monty@mysql.com committed
9444
  {
9445 9446
    /* Regex replace */
    if (!multi_reg_replace(glob_replace_regex, (char*)val))
monty@mysql.com's avatar
monty@mysql.com committed
9447
    {
9448 9449
      val= glob_replace_regex->buf;
      len= strlen(val);
monty@mysql.com's avatar
monty@mysql.com committed
9450 9451 9452
    }
  }

9453 9454 9455 9456 9457 9458 9459 9460
  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
9461 9462


9463 9464
/* 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
9465
{
9466 9467
  replace_dynstr_append_mem(ds, val, strlen(val));
}
9468

9469 9470 9471 9472 9473 9474
/* 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
9475
}
9476 9477 9478 9479 9480 9481 9482 9483 9484 9485 9486 9487 9488 9489 9490 9491 9492 9493 9494 9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517 9518 9519 9520 9521 9522 9523 9524



/*
  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 */
9525
    if (insert_dynamic(&lines, (uchar*) &start))
9526 9527 9528 9529 9530 9531 9532 9533 9534 9535 9536 9537 9538 9539 9540 9541 9542 9543 9544 9545
      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;
}