Adding upstream version 1:10.11.6.upstream/1%10.11.6

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1712 insertions, 0 deletions

diff --git a/client/mysqladmin.cc b/client/mysqladmin.cc
new file mode 100644
index 00000000..022ba2ae
--- /dev/null
+++ b/client/mysqladmin.cc
@@ -0,0 +1,1712 @@
+/*
+   Copyright (c) 2000, 2014, Oracle and/or its affiliates.
+   Copyright (c) 2010, 2019, MariaDB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1335  USA */
+
+/* maintenance of mysql databases */
+
+#include "client_priv.h"
+#include <signal.h>
+#include <my_pthread.h>				/* because of signal()	*/
+#include <sys/stat.h>
+#include <mysql.h>
+#include <mysql_version.h>
+#include <welcome_copyright_notice.h>
+#include <my_rnd.h>
+#include <password.h>
+#include <my_sys.h>
+
+#define ADMIN_VERSION "9.1"
+#define MAX_MYSQL_VAR 512
+#define SHUTDOWN_DEF_TIMEOUT 3600		/* Wait for shutdown */
+#define MAX_TRUNC_LENGTH 3
+
+char *host= NULL, *user= 0, *opt_password= 0,
+     *default_charset= (char*) MYSQL_AUTODETECT_CHARSET_NAME;
+char truncated_var_names[MAX_MYSQL_VAR+100][MAX_TRUNC_LENGTH];
+char ex_var_names[MAX_MYSQL_VAR+100][FN_REFLEN];
+ulonglong last_values[MAX_MYSQL_VAR+100];
+static int interval=0;
+static my_bool option_force=0,interrupted=0,new_line=0,
+               opt_compress= 0, opt_local= 0, opt_relative= 0, opt_verbose= 0,
+               opt_vertical= 0, tty_password= 0, opt_nobeep,
+               opt_shutdown_wait_for_slaves= 0;
+static my_bool debug_info_flag= 0, debug_check_flag= 0;
+static uint tcp_port = 0, option_wait = 0, option_silent=0, nr_iterations;
+static uint opt_count_iterations= 0, my_end_arg;
+static ulong opt_connect_timeout, opt_shutdown_timeout;
+static char * unix_port=0;
+static char *opt_plugin_dir= 0, *opt_default_auth= 0;
+static bool sql_log_bin_off= false;
+
+static uint opt_protocol=0;
+static myf error_flags; /* flags to pass to my_printf_error, like ME_BELL */
+
+/*
+  When using extended-status relatively, ex_val_max_len is the estimated
+  maximum length for any relative value printed by extended-status. The
+  idea is to try to keep the length of output as short as possible.
+*/
+
+static uint ex_val_max_len[MAX_MYSQL_VAR];
+static my_bool ex_status_printed = 0; /* First output is not relative. */
+static uint ex_var_count, max_var_length, max_val_length;
+
+#include <sslopt-vars.h>
+
+static void print_version(void);
+static void usage(void);
+extern "C" my_bool get_one_option(int optid, const struct my_option *opt,
+                                  const char *argument);
+static my_bool sql_connect(MYSQL *mysql, uint wait);
+static int execute_commands(MYSQL *mysql,int argc, char **argv);
+static char **mask_password(int argc, char ***argv);
+static int drop_db(MYSQL *mysql,const char *db);
+extern "C" sig_handler endprog(int signal_number);
+static void nice_time(ulong sec,char *buff);
+static void print_header(MYSQL_RES *result);
+static void print_top(MYSQL_RES *result);
+static void print_row(MYSQL_RES *result,MYSQL_ROW cur, uint row);
+static void print_relative_row(MYSQL_RES *result, MYSQL_ROW cur, uint row);
+static void print_relative_row_vert(MYSQL_RES *result, MYSQL_ROW cur, uint row);
+static void print_relative_header();
+static void print_relative_line();
+static void truncate_names();
+static my_bool get_pidfile(MYSQL *mysql, char *pidfile);
+static my_bool wait_pidfile(char *pidfile, time_t last_modified,
+			    struct stat *pidfile_status);
+static void store_values(MYSQL_RES *result);
+
+/*
+  The order of commands must be the same as command_names,
+  except ADMIN_ERROR
+*/
+enum commands {
+  ADMIN_ERROR,
+  ADMIN_CREATE,           ADMIN_DROP,            ADMIN_SHUTDOWN,
+  ADMIN_RELOAD,           ADMIN_REFRESH,         ADMIN_VER,
+  ADMIN_PROCESSLIST,      ADMIN_STATUS,          ADMIN_KILL,
+  ADMIN_DEBUG,            ADMIN_VARIABLES,       ADMIN_FLUSH_LOGS,
+  ADMIN_FLUSH_HOSTS,      ADMIN_FLUSH_TABLES,    ADMIN_PASSWORD,
+  ADMIN_PING,             ADMIN_EXTENDED_STATUS, ADMIN_FLUSH_STATUS,
+  ADMIN_FLUSH_PRIVILEGES, ADMIN_START_SLAVE,     ADMIN_STOP_SLAVE,
+  ADMIN_START_ALL_SLAVES, ADMIN_STOP_ALL_SLAVES,
+  ADMIN_FLUSH_THREADS,    ADMIN_OLD_PASSWORD,    ADMIN_FLUSH_BINARY_LOG,
+  ADMIN_FLUSH_ENGINE_LOG, ADMIN_FLUSH_ERROR_LOG, ADMIN_FLUSH_GENERAL_LOG,
+  ADMIN_FLUSH_RELAY_LOG,  ADMIN_FLUSH_SLOW_LOG,
+  ADMIN_FLUSH_TABLE_STATISTICS, ADMIN_FLUSH_INDEX_STATISTICS,
+  ADMIN_FLUSH_USER_STATISTICS, ADMIN_FLUSH_CLIENT_STATISTICS,
+  ADMIN_FLUSH_USER_RESOURCES,
+  ADMIN_FLUSH_ALL_STATUS, ADMIN_FLUSH_ALL_STATISTICS, ADMIN_FLUSH_SSL
+};
+static const char *command_names[]= {
+  "create",               "drop",                "shutdown",
+  "reload",               "refresh",             "version",
+  "processlist",          "status",              "kill",
+  "debug",                "variables",           "flush-logs",
+  "flush-hosts",          "flush-tables",        "password",
+  "ping",                 "extended-status",     "flush-status",
+  "flush-privileges",     "start-slave",         "stop-slave",
+  "start-all-slaves", "stop-all-slaves",
+  "flush-threads", "old-password", "flush-binary-log", "flush-engine-log",
+  "flush-error-log", "flush-general-log", "flush-relay-log", "flush-slow-log",
+  "flush-table-statistics", "flush-index-statistics",
+  "flush-user-statistics", "flush-client-statistics", "flush-user-resources",
+  "flush-all-status", "flush-all-statistics", "flush-ssl",
+  NullS
+};
+
+static TYPELIB command_typelib=
+{ array_elements(command_names)-1,"commands", command_names, NULL};
+
+static struct my_option my_long_options[] =
+{
+  {"count", 'c',
+   "Number of iterations to make. This works with -i (--sleep) only.",
+   &nr_iterations, &nr_iterations, 0, GET_UINT,
+   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+#ifndef DBUG_OFF
+  {"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
+  {"debug-check", OPT_DEBUG_CHECK, "Check memory and open file usage at exit.",
+   &debug_check_flag, &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.",
+   &debug_info_flag, &debug_info_flag,
+   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"force", 'f',
+   "Don't ask for confirmation on drop database; with multiple commands, "
+   "continue even if an error occurs.",
+   &option_force, &option_force, 0, GET_BOOL, NO_ARG, 0, 0,
+   0, 0, 0, 0},
+  {"compress", 'C', "Use compression in server/client protocol.",
+   &opt_compress, &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
+   0, 0, 0},
+  {"character-sets-dir", OPT_CHARSETS_DIR,
+   "Directory for character set files.", &charsets_dir,
+   &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"default-character-set", OPT_DEFAULT_CHARSET,
+   "Set the default character set.", &default_charset,
+   &default_charset, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG,
+   NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"host", 'h', "Connect to host.", &host, &host, 0, GET_STR,
+   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"local", 'l', "Local command, don't write to binlog.",
+   &opt_local, &opt_local, 0, GET_BOOL, NO_ARG, 0, 0, 0,
+   0, 0, 0},
+  {"no-beep", 'b', "Turn off beep on error.", &opt_nobeep,
+   &opt_nobeep, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0}, 
+  {"password", 'p',
+   "Password to use when connecting to server. If password is not given it's asked from the tty.",
+   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
+#ifdef _WIN32
+  {"pipe", 'W', "Use named pipes to connect to server.", 0, 0, 0, GET_NO_ARG,
+   NO_ARG, 0, 0, 0, 0, 0, 0},
+#endif
+  {"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) ").",
+   &tcp_port, &tcp_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"protocol", OPT_MYSQL_PROTOCOL, "The protocol to use for connection (tcp, socket, pipe).",
+    0, 0, 0, GET_STR,  REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"relative", 'r',
+   "Show difference between current and previous values when used with -i. "
+   "Currently only works with extended-status.",
+   &opt_relative, &opt_relative, 0, GET_BOOL, NO_ARG, 0, 0, 0,
+  0, 0, 0},
+  {"silent", 's', "Silently exit if one can't connect to server.",
+   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"socket", 'S', "The socket file to use for connection.",
+   &unix_port, &unix_port, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
+   0, 0, 0},
+  {"sleep", 'i', "Execute commands repeatedly with a sleep between.",
+   &interval, &interval, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0,
+   0, 0},
+#include <sslopt-longopts.h>
+#ifndef DONT_ALLOW_USER_CHANGE
+  {"user", 'u', "User for login if not current user.", &user,
+   &user, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+#endif
+  {"verbose", 'v', "Write more information.", &opt_verbose,
+   &opt_verbose, 0, 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},
+  {"vertical", 'E',
+   "Print output vertically. Is similar to --relative, but prints output vertically.",
+   &opt_vertical, &opt_vertical, 0, GET_BOOL, NO_ARG, 0, 0, 0,
+   0, 0, 0},
+  {"wait", 'w', "Wait and retry if connection is down.", 0, 0, 0, GET_UINT,
+   OPT_ARG, 0, 0, 0, 0, 0, 0},
+  {"connect_timeout", OPT_CONNECT_TIMEOUT, "", &opt_connect_timeout,
+   &opt_connect_timeout, 0, GET_ULONG, REQUIRED_ARG, 3600*12, 0,
+   3600*12, 0, 1, 0},
+  {"shutdown_timeout", OPT_SHUTDOWN_TIMEOUT, "", &opt_shutdown_timeout,
+   &opt_shutdown_timeout, 0, GET_ULONG, REQUIRED_ARG,
+   SHUTDOWN_DEF_TIMEOUT, 0, 3600*12, 0, 1, 0},
+  {"wait_for_all_slaves", OPT_SHUTDOWN_WAIT_FOR_SLAVES,
+   "Defers shutdown until after all binlogged events have been sent to "
+   "all connected slaves", &opt_shutdown_wait_for_slaves,
+   &opt_shutdown_wait_for_slaves, 0, GET_BOOL, NO_ARG, 0, 0, 0,
+   0, 0, 0},
+  {"plugin_dir", OPT_PLUGIN_DIR, "Directory for client-side plugins.",
+    &opt_plugin_dir, &opt_plugin_dir, 0,
+   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"default_auth", OPT_DEFAULT_AUTH,
+   "Default authentication client-side plugin to use.",
+   &opt_default_auth, &opt_default_auth, 0,
+   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
+};
+
+
+static const char *load_default_groups[]=
+{ "mysqladmin", "mariadb-admin", "client", "client-server", "client-mariadb",
+  0 };
+
+my_bool
+get_one_option(const struct my_option *opt, const char *argument,
+               const char *filename)
+{
+  switch(opt->id) {
+  case 'c':
+    opt_count_iterations= 1;
+    break;
+  case 'p':
+    if (argument == disabled_my_option)
+      argument= (char*) "";			// Don't require password
+    if (argument)
+    {
+      /*
+        One should not really change the argument, but we make an
+        exception for passwords
+      */
+      char *start= (char*) argument;
+      my_free(opt_password);
+      opt_password=my_strdup(PSI_NOT_INSTRUMENTED, argument,MYF(MY_FAE));
+      while (*argument)
+        *(char*) argument++= 'x';		/* Destroy argument */
+      if (*start)
+	start[1]=0;				/* Cut length of argument */
+      tty_password= 0;
+    }
+    else
+      tty_password=1;
+    break;
+  case 's':
+    option_silent++;
+    break;
+  case 'W':
+#ifdef _WIN32
+    opt_protocol = MYSQL_PROTOCOL_PIPE;
+#endif
+    break;
+  case '#':
+    DBUG_PUSH(argument ? argument : "d:t:o,/tmp/mysqladmin.trace");
+    break;
+#include <sslopt-case.h>
+  case 'V':
+    print_version();
+    exit(0);
+    break;
+  case 'w':
+    if (argument)
+    {
+      if ((option_wait=atoi(argument)) <= 0)
+	option_wait=1;
+    }
+    else
+      option_wait= ~(uint)0;
+    break;
+  case '?':
+  case 'I':					/* Info */
+    usage();
+    exit(0);
+  case OPT_CHARSETS_DIR:
+#if MYSQL_VERSION_ID > 32300
+    charsets_dir = argument;
+#endif
+    break;
+  case OPT_MYSQL_PROTOCOL:
+    if ((opt_protocol= find_type_with_warning(argument, &sql_protocol_typelib,
+                                              opt->name)) <= 0)
+    {
+      sf_leaking_memory= 1; /* no memory leak reports here */
+      exit(1);
+    }
+    break;
+  case 'P':
+    if (filename[0] == '\0')
+    {
+      /* Port given on command line, switch protocol to use TCP */
+      opt_protocol= MYSQL_PROTOCOL_TCP;
+    }
+    break;
+  case 'S':
+    if (filename[0] == '\0')
+    {
+      /*
+        Socket given on command line, switch protocol to use SOCKETSt
+        Except on Windows if 'protocol= pipe' has been provided in
+        the config file or command line.
+      */
+      if (opt_protocol != MYSQL_PROTOCOL_PIPE)
+      {
+        opt_protocol= MYSQL_PROTOCOL_SOCKET;
+      }
+    }
+    break;
+  }
+  return 0;
+}
+
+
+int main(int argc,char *argv[])
+{
+  int error= 0, temp_argc;
+  MYSQL mysql;
+  char **commands, **save_argv, **temp_argv;
+
+  MY_INIT(argv[0]);
+  sf_leaking_memory=1; /* don't report memory leaks on early exits */
+
+  /* We need to know if protocol-related options originate from CLI args */
+  my_defaults_mark_files = TRUE;
+
+  load_defaults_or_exit("my", load_default_groups, &argc, &argv);
+  save_argv = argv;				/* Save for free_defaults */
+
+  if ((error=handle_options(&argc, &argv, my_long_options, get_one_option)))
+    goto err2;
+  temp_argv= mask_password(argc, &argv);
+  temp_argc= argc;
+
+  if (debug_info_flag)
+    my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
+  if (debug_check_flag)
+    my_end_arg= MY_CHECK_ERROR;
+
+  if (argc == 0)
+  {
+    usage();
+    exit(1);
+  }
+  commands = temp_argv;
+  if (tty_password)
+    opt_password = my_get_tty_password(NullS);
+
+  (void) signal(SIGINT,endprog);			/* Here if abort */
+  (void) signal(SIGTERM,endprog);		/* Here if abort */
+
+  sf_leaking_memory=0; /* from now on we cleanup properly */
+
+  mysql_init(&mysql);
+  if (opt_compress)
+    mysql_options(&mysql,MYSQL_OPT_COMPRESS,NullS);
+  if (opt_connect_timeout)
+  {
+    uint tmp=opt_connect_timeout;
+    mysql_options(&mysql,MYSQL_OPT_CONNECT_TIMEOUT, (char*) &tmp);
+  }
+#ifdef HAVE_OPENSSL
+  if (opt_use_ssl)
+  {
+    mysql_ssl_set(&mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
+		  opt_ssl_capath, opt_ssl_cipher);
+    mysql_options(&mysql, MYSQL_OPT_SSL_CRL, opt_ssl_crl);
+    mysql_options(&mysql, MYSQL_OPT_SSL_CRLPATH, opt_ssl_crlpath);
+    mysql_options(&mysql, MARIADB_OPT_TLS_VERSION, opt_tls_version);
+  }
+  mysql_options(&mysql,MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
+                (char*)&opt_ssl_verify_server_cert);
+#endif
+  if (opt_protocol)
+    mysql_options(&mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
+  if (!strcmp(default_charset,MYSQL_AUTODETECT_CHARSET_NAME))
+    default_charset= (char *)my_default_csname();
+  my_set_console_cp(default_charset);
+  mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, default_charset);
+  error_flags= (myf)(opt_nobeep ? 0 : ME_BELL);
+
+  if (opt_plugin_dir && *opt_plugin_dir)
+    mysql_options(&mysql, MYSQL_PLUGIN_DIR, opt_plugin_dir);
+
+  if (opt_default_auth && *opt_default_auth)
+    mysql_options(&mysql, MYSQL_DEFAULT_AUTH, opt_default_auth);
+
+  mysql_options(&mysql, MYSQL_OPT_CONNECT_ATTR_RESET, 0);
+  mysql_options4(&mysql, MYSQL_OPT_CONNECT_ATTR_ADD,
+                 "program_name", "mysqladmin");
+  if (sql_connect(&mysql, option_wait))
+  {
+    /*
+      We couldn't get an initial connection and will definitely exit.
+      The following just determines the exit-code we'll give.
+    */
+
+    unsigned int err= mysql_errno(&mysql);
+    if (err >= CR_MIN_ERROR && err <= CR_MAX_ERROR)
+      error= 1;
+    else
+    {
+      /* Return 0 if all commands are PING */
+      for (; argc > 0; argv++, argc--)
+      {
+        if (find_type(argv[0], &command_typelib, FIND_TYPE_BASIC) !=
+            ADMIN_PING)
+        {
+          error= 1;
+          break;
+        }
+      }
+    }
+  }
+  else
+  {
+    /*
+      --count=0 aborts right here. Otherwise iff --sleep=t ("interval")
+      is given a t!=0, we get an endless loop, or n iterations if --count=n
+      was given an n!=0. If --sleep wasn't given, we get one iteration.
+
+      To wit, --wait loops the connection-attempts, while --sleep loops
+      the command execution (endlessly if no --count is given).
+    */
+
+    while (!interrupted && (!opt_count_iterations || nr_iterations))
+    {
+      new_line = 0;
+
+      if ((error= execute_commands(&mysql,argc,commands)))
+      {
+        /*
+          Unknown/malformed command always aborts and can't be --forced.
+          If the user got confused about the syntax, proceeding would be
+          dangerous ...
+        */
+	if (error > 0)
+	  break;
+
+        error= -error; /* don't exit with negative error codes */
+        /*
+          Command was well-formed, but failed on the server. Might succeed
+          on retry (if conditions on server change etc.), but needs --force
+          to retry.
+        */
+        if (!option_force)
+          break;
+      }                                         /* if((error= ... */
+
+      if (interval)                             /* --sleep=interval given */
+      {
+        if (opt_count_iterations && --nr_iterations == 0)
+          break;
+
+        /*
+          If connection was dropped (unintentionally, or due to SHUTDOWN),
+          re-establish it if --wait ("retry-connect") was given and user
+          didn't signal for us to die. Otherwise, signal failure.
+        */
+
+	if (mysql.net.pvio == 0)
+	{
+	  if (option_wait && !interrupted)
+	  {
+	    sleep(1);
+	    sql_connect(&mysql, option_wait);
+	    /*
+	      continue normally and decrease counters so that
+	      "mysqladmin --count=1 --wait=1 shutdown"
+	      cannot loop endlessly.
+	    */
+	  }
+	  else
+	  {
+	    /*
+	      connexion broke, and we have no order to re-establish it. fail.
+	    */
+	    if (!option_force)
+	      error= 1;
+	    break;
+	  }
+	}                                       /* lost connection */
+
+	sleep(interval);
+	if (new_line)
+	  puts("");
+      }
+      else
+        break;                                  /* no --sleep, done looping */
+    }                                           /* command-loop */
+  }                                             /* got connection */
+
+  mysql_close(&mysql);
+  temp_argc--;
+  while(temp_argc >= 0)
+  {
+    my_free(temp_argv[temp_argc]);
+    temp_argc--;
+  }
+  my_free(temp_argv);
+err2:
+  mysql_library_end();
+  my_free(opt_password);
+  my_free(user);
+  free_defaults(save_argv);
+  my_end(my_end_arg);
+  return error;
+}
+
+
+sig_handler endprog(int signal_number __attribute__((unused)))
+{
+  interrupted=1;
+}
+
+/**
+   @brief connect to server, optionally waiting for same to come up
+
+   @param  mysql     connection struct
+   @param  wait      wait for server to come up?
+                     (0: no, ~0: forever, n: cycles)
+
+   @return Operation result
+   @retval 0         success
+   @retval 1         failure
+*/
+
+static my_bool sql_connect(MYSQL *mysql, uint wait)
+{
+  my_bool info=0;
+
+  for (;;)
+  {
+    if (mysql_real_connect(mysql,host,user,opt_password,NullS,tcp_port,
+			   unix_port, CLIENT_REMEMBER_OPTIONS))
+    {
+      my_bool reconnect= 1;
+      mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+      if (info)
+      {
+	fputs("\n",stderr);
+	(void) fflush(stderr);
+      }
+      return 0;
+    }
+
+    if (!wait)                                  // was or reached 0, fail
+    {
+      if (!option_silent)                       // print diagnostics
+      {
+	if (!host)
+	  host= (char*) LOCAL_HOST;
+	my_printf_error(0,"connect to server at '%s' failed\nerror: '%s'",
+			error_flags, host, mysql_error(mysql));
+	if (mysql_errno(mysql) == CR_CONNECTION_ERROR)
+	{
+	  fprintf(stderr,
+		  "Check that mariadbd is running and that the socket: '%s' exists!\n",
+		  unix_port ? unix_port : mysql_unix_port);
+	}
+	else if (mysql_errno(mysql) == CR_CONN_HOST_ERROR ||
+		 mysql_errno(mysql) == CR_UNKNOWN_HOST)
+	{
+	  fprintf(stderr,"Check that mariadbd is running on %s",host);
+	  fprintf(stderr," and that the port is %d.\n",
+		  tcp_port ? tcp_port: mysql_port);
+	  fprintf(stderr,"You can check this by doing 'telnet %s %d'\n",
+		  host, tcp_port ? tcp_port: mysql_port);
+	}
+      }
+      return 1;
+    }
+
+    if (wait != (uint) ~0)
+      wait--;				/* count down, one less retry */
+
+    if ((mysql_errno(mysql) != CR_CONN_HOST_ERROR) &&
+	(mysql_errno(mysql) != CR_CONNECTION_ERROR))
+    {
+      /*
+        Error is worse than "server doesn't answer (yet?)";
+        fail even if we still have "wait-coins" unless --force
+        was also given.
+      */
+      fprintf(stderr,"Got error: %s\n", mysql_error(mysql));
+      if (!option_force)
+	return 1;
+    }
+    else if (!option_silent)
+    {
+      if (!info)
+      {
+	info=1;
+	fputs("Waiting for MariaDB server to answer",stderr);
+	(void) fflush(stderr);
+      }
+      else
+      {
+	putc('.',stderr);
+	(void) fflush(stderr);
+      }
+    }
+    sleep(5);
+  }
+}
+
+
+static int maybe_disable_binlog(MYSQL *mysql)
+{
+  if (opt_local && !sql_log_bin_off)
+  {
+    if (mysql_query(mysql,  "set local sql_log_bin=0"))
+    {
+      my_printf_error(0, "SET LOCAL SQL_LOG_BIN=0 failed; error: '%-.200s'",
+                      error_flags, mysql_error(mysql));
+      return -1;
+    }
+  }
+  sql_log_bin_off= true;
+  return 0;
+}
+
+
+int flush(MYSQL *mysql, const char *what)
+{
+  char buf[FN_REFLEN];
+  my_snprintf(buf, sizeof(buf), "flush %s%s",
+              (opt_local && !sql_log_bin_off ? "local " : ""), what);
+
+  if (mysql_query(mysql, buf))
+  {
+    my_printf_error(0, "flush %s failed; error: '%s'", error_flags, what,
+                    mysql_error(mysql));
+    return -1;
+  }
+  return 0;
+}
+
+
+/**
+   @brief Execute all commands
+
+   @details We try to execute all commands we were given, in the order
+            given, but return with non-zero as soon as we encounter trouble.
+            By that token, individual commands can be considered a conjunction
+            with boolean short-cut.
+
+   @return success?
+   @retval 0       Yes!  ALL commands worked!
+   @retval 1       No, one failed and will never work (malformed): fatal error!
+   @retval -1      No, one failed on the server, may work next time!
+*/
+
+static int execute_commands(MYSQL *mysql,int argc, char **argv)
+{
+  int ret = 0;
+  const char *status;
+  /*
+    MySQL documentation relies on the fact that mysqladmin will
+    execute commands in the order specified, e.g.
+    mysqladmin -u root flush-privileges password "newpassword"
+    to reset a lost root password.
+    If this behaviour is ever changed, Docs should be notified.
+  */
+
+  struct my_rnd_struct rand_st;
+  char buff[FN_REFLEN + 20];
+
+  for (; argc > 0 ; argv++,argc--)
+  {
+    int command;
+    switch ((command= find_type(argv[0],&command_typelib,FIND_TYPE_BASIC))) {
+    case ADMIN_CREATE:
+    {
+      if (argc < 2)
+      {
+	my_printf_error(0, "Too few arguments to create", error_flags);
+	return 1;
+      }
+      if (maybe_disable_binlog(mysql))
+        return -1;
+      sprintf(buff,"create database `%.*s`",FN_REFLEN,argv[1]);
+      if (mysql_query(mysql,buff))
+      {
+	my_printf_error(0,"CREATE DATABASE failed; error: '%-.200s'",
+			error_flags, mysql_error(mysql));
+	return -1;
+      }
+      argc--; argv++;
+      break;
+    }
+    case ADMIN_DROP:
+    {
+      if (argc < 2)
+      {
+	my_printf_error(0, "Too few arguments to drop", error_flags);
+	return 1;
+      }
+      if (maybe_disable_binlog(mysql))
+        return -1;
+      if (drop_db(mysql,argv[1]))
+	return -1;
+      argc--; argv++;
+      break;
+    }
+    case ADMIN_SHUTDOWN:
+    {
+      char pidfile[FN_REFLEN];
+      my_bool got_pidfile= 0;
+      time_t last_modified= 0;
+      struct stat pidfile_status;
+
+      /*
+	Only wait for pidfile on local connections
+	If pidfile doesn't exist, continue without pid file checking
+      */
+      if (mysql->unix_socket && (got_pidfile= !get_pidfile(mysql, pidfile)) &&
+	  !stat(pidfile, &pidfile_status))
+	last_modified= pidfile_status.st_mtime;
+
+      if (opt_shutdown_wait_for_slaves)
+      {
+        sprintf(buff, "SHUTDOWN WAIT FOR ALL SLAVES");
+        if (mysql_query(mysql, buff))
+        {
+          my_printf_error(0, "%s failed; error: '%-.200s'",
+                          error_flags, buff, mysql_error(mysql));
+          return -1;
+        }
+      }
+      else if (mysql_shutdown(mysql, SHUTDOWN_DEFAULT))
+      {
+	my_printf_error(0, "shutdown failed; error: '%s'", error_flags,
+			mysql_error(mysql));
+	return -1;
+      }
+      argc=1;                   /* force SHUTDOWN to be the last command    */
+      if (got_pidfile)
+      {
+	if (opt_verbose)
+	  printf("Shutdown signal sent to server;  Waiting for pid file to disappear\n");
+
+	/* Wait until pid file is gone */
+	if (wait_pidfile(pidfile, last_modified, &pidfile_status))
+	  return -1;
+      }
+      break;
+    }
+    case ADMIN_FLUSH_PRIVILEGES:
+    case ADMIN_RELOAD:
+      if (flush(mysql, "privileges"))
+	return -1;
+      break;
+    case ADMIN_REFRESH:
+      if (mysql_refresh(mysql,
+			(uint) ~(REFRESH_GRANT | REFRESH_STATUS |
+				 REFRESH_READ_LOCK | REFRESH_SLAVE |
+				 REFRESH_MASTER)))
+      {
+	my_printf_error(0, "refresh failed; error: '%s'", error_flags,
+			mysql_error(mysql));
+	return -1;
+      }
+      break;
+    case ADMIN_FLUSH_THREADS:
+      if (mysql_refresh(mysql,(uint) REFRESH_THREADS))
+      {
+	my_printf_error(0, "refresh failed; error: '%s'", error_flags,
+			mysql_error(mysql));
+	return -1;
+      }
+      break;
+    case ADMIN_VER:
+      new_line=1;
+      print_version();
+      puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
+      printf("Server version\t\t%s\n", mysql_get_server_info(mysql));
+      printf("Protocol version\t%d\n", mysql_get_proto_info(mysql));
+      printf("Connection\t\t%s\n",mysql_get_host_info(mysql));
+      if (mysql->unix_socket)
+	printf("UNIX socket\t\t%s\n", mysql->unix_socket);
+      else
+	printf("TCP port\t\t%d\n", mysql->port);
+      status=mysql_stat(mysql);
+      {
+	char *pos,buff[40];
+	ulong sec;
+	pos= (char*) strchr(status,' ');
+	*pos++=0;
+	printf("%s\t\t\t",status);			/* print label */
+	if ((status=str2int(pos,10,0,LONG_MAX,(long*) &sec)))
+	{
+	  nice_time(sec,buff);
+	  puts(buff);				/* print nice time */
+	  while (*status == ' ') status++;	/* to next info */
+	}
+      }
+      putc('\n',stdout);
+      if (status)
+	puts(status);
+      break;
+    case ADMIN_PROCESSLIST:
+    {
+      MYSQL_RES *result;
+      MYSQL_ROW row;
+
+      if (mysql_query(mysql, (opt_verbose ? "show full processlist" :
+			      "show processlist")) ||
+	  !(result = mysql_store_result(mysql)))
+      {
+	my_printf_error(0, "process list failed; error: '%s'", error_flags,
+			mysql_error(mysql));
+	return -1;
+      }
+      print_header(result);
+      while ((row=mysql_fetch_row(result)))
+	print_row(result,row,0);
+      print_top(result);
+      mysql_free_result(result);
+      new_line=1;
+      break;
+    }
+    case ADMIN_STATUS:
+      status=mysql_stat(mysql);
+      if (status)
+	puts(status);
+      break;
+    case ADMIN_KILL:
+      {
+	uint error=0;
+	char *pos;
+	if (argc < 2)
+	{
+	  my_printf_error(0, "Too few arguments to 'kill'", error_flags);
+	  return 1;
+	}
+	pos=argv[1];
+	for (;;)
+	{
+          /* We don't use mysql_kill(), since it only handles 32-bit IDs. */
+          char buff[26], *out; /* "KILL " + max 20 digs + NUL */
+          out= strxmov(buff, "KILL ", NullS);
+          ullstr(strtoull(pos, NULL, 0), out);
+
+          if (mysql_query(mysql, buff))
+	  {
+            /* out still points to just the number */
+	    my_printf_error(0, "kill failed on %s; error: '%s'", error_flags,
+			    out, mysql_error(mysql));
+	    error=1;
+	  }
+	  if (!(pos=strchr(pos,',')))
+	    break;
+	  pos++;
+	}
+	argc--; argv++;
+	if (error)
+	  return -1;
+	break;
+      }
+    case ADMIN_DEBUG:
+      if (mysql_dump_debug_info(mysql))
+      {
+	my_printf_error(0, "debug failed; error: '%s'", error_flags,
+			mysql_error(mysql));
+	return -1;
+      }
+      break;
+    case ADMIN_VARIABLES:
+    {
+      MYSQL_RES *res;
+      MYSQL_ROW row;
+
+      new_line=1;
+      if (mysql_query(mysql,"show /*!40003 GLOBAL */ variables") ||
+	  !(res=mysql_store_result(mysql)))
+      {
+	my_printf_error(0, "unable to show variables; error: '%s'", error_flags,
+			mysql_error(mysql));
+	return -1;
+      }
+      print_header(res);
+      while ((row=mysql_fetch_row(res)))
+	print_row(res,row,0);
+      print_top(res);
+      mysql_free_result(res);
+      break;
+    }
+    case ADMIN_EXTENDED_STATUS:
+    {
+      MYSQL_RES *res;
+      MYSQL_ROW row;
+      uint rownr = 0;
+      void (*func) (MYSQL_RES*, MYSQL_ROW, uint);
+
+      new_line = 1;
+      if (mysql_query(mysql, "show /*!50002 GLOBAL */ status") ||
+	  !(res = mysql_store_result(mysql)))
+      {
+	my_printf_error(0, "unable to show status; error: '%s'", error_flags,
+			mysql_error(mysql));
+	return -1;
+      }
+
+      DBUG_ASSERT(mysql_num_rows(res) < MAX_MYSQL_VAR+100);
+
+      if (!opt_vertical)
+	print_header(res);
+      else
+      {
+	if (!ex_status_printed)
+	{
+	  store_values(res);
+	  truncate_names();   /* Does some printing also */
+	}
+	else
+	{
+	  print_relative_line();
+	  print_relative_header();
+	  print_relative_line();
+	}
+      }
+
+      /*      void (*func) (MYSQL_RES*, MYSQL_ROW, uint); */
+      if (opt_relative && !opt_vertical)
+	func = print_relative_row;
+      else if (opt_vertical)
+	func = print_relative_row_vert;
+      else
+	func = print_row;
+
+      while ((row = mysql_fetch_row(res)))
+	(*func)(res, row, rownr++);
+      if (opt_vertical)
+      {
+	if (ex_status_printed)
+	{
+	  putchar('\n');
+	  print_relative_line();
+	}
+      }
+      else
+	print_top(res);
+
+      ex_status_printed = 1; /* From now on the output will be relative */
+      mysql_free_result(res);
+      break;
+    }
+    case ADMIN_FLUSH_LOGS:
+    {
+      if (flush(mysql, "logs"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_BINARY_LOG:
+    {
+      if (flush(mysql, "binary logs"))
+        return -1;
+      break;
+    }
+    case ADMIN_FLUSH_ENGINE_LOG:
+    {
+      if (flush(mysql, "engine logs"))
+        return -1;
+      break;
+    }
+    case ADMIN_FLUSH_ERROR_LOG:
+    {
+      if (flush(mysql, "error logs"))
+        return -1;
+      break;
+    }
+    case ADMIN_FLUSH_GENERAL_LOG:
+    {
+      if (flush(mysql, "general logs"))
+        return -1;
+      break;
+    }
+    case ADMIN_FLUSH_RELAY_LOG:
+    {
+      if (flush(mysql, "relay logs"))
+        return -1;
+      break;
+    }
+    case ADMIN_FLUSH_SLOW_LOG:
+    {
+      if (flush(mysql, "slow logs"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_HOSTS:
+    {
+      if (flush(mysql, "hosts"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_TABLES:
+    {
+      if (flush(mysql, "tables"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_STATUS:
+    {
+      if (flush(mysql, "status"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_TABLE_STATISTICS:
+    {
+      if (flush(mysql, "table_statistics"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_INDEX_STATISTICS:
+    {
+      if (flush(mysql, "index_statistics"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_SSL:
+    {
+      if (flush(mysql, "ssl"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_USER_STATISTICS:
+    {
+      if (flush(mysql, "user_statistics"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_USER_RESOURCES:
+    {
+      if (flush(mysql, "user_resources"))
+        return -1;
+      break;
+    }
+    case ADMIN_FLUSH_CLIENT_STATISTICS:
+    {
+      if (flush(mysql, "client_statistics"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_ALL_STATISTICS:
+    {
+      if (flush(mysql, "table_statistics,index_statistics,"
+                       "user_statistics,client_statistics"))
+	return -1;
+      break;
+    }
+    case ADMIN_FLUSH_ALL_STATUS:
+    {
+      if (flush(mysql, "status,table_statistics,index_statistics,"
+                       "user_statistics,client_statistics"))
+	return -1;
+      break;
+    }
+    case ADMIN_OLD_PASSWORD:
+    case ADMIN_PASSWORD:
+    {
+      char buff[128],crypted_pw[64];
+      time_t start_time;
+      char *typed_password= NULL, *verified= NULL;
+      /* Do initialization the same way as we do in mysqld */
+      start_time=time((time_t*) 0);
+      my_rnd_init(&rand_st,(ulong) start_time,(ulong) start_time/2);
+
+      if (maybe_disable_binlog(mysql))
+        return -1;
+      if (argc < 1)
+      {
+	my_printf_error(0, "Too few arguments to change password", error_flags);
+	return 1;
+      }
+      else if (argc == 1)
+      {
+        /* prompt for password */
+        typed_password= my_get_tty_password("New password: ");
+        verified= my_get_tty_password("Confirm new password: ");
+        if (strcmp(typed_password, verified) != 0)
+        {
+          my_printf_error(0,"Passwords don't match",MYF(ME_BELL));
+          ret = -1;
+          goto password_done;
+        }
+      }
+      else
+        typed_password= argv[1];
+
+      if (typed_password[0])
+      {
+        bool old= (find_type(argv[0], &command_typelib, FIND_TYPE_BASIC) ==
+                   ADMIN_OLD_PASSWORD);
+#ifdef _WIN32
+        size_t pw_len= strlen(typed_password);
+        if (pw_len > 1 && typed_password[0] == '\'' &&
+            typed_password[pw_len-1] == '\'')
+          printf("Warning: single quotes were not trimmed from the password by"
+                 " your command\nline client, as you might have expected.\n");
+#endif
+        /*
+           If we don't already know to use an old-style password, see what
+           the server is using
+        */
+        if (!old)
+        {
+          if (mysql_query(mysql, "SHOW VARIABLES LIKE 'old_passwords'"))
+          {
+            my_printf_error(0, "Could not determine old_passwords setting from server; error: '%s'",
+                	    error_flags, mysql_error(mysql));
+            ret = -1;
+            goto password_done;
+          }
+          else
+          {
+            MYSQL_RES *res= mysql_store_result(mysql);
+            if (!res)
+            {
+              my_printf_error(0,
+                              "Could not get old_passwords setting from "
+                              "server; error: '%s'",
+        		      error_flags, mysql_error(mysql));
+              ret = -1;
+              goto password_done;
+            }
+            if (!mysql_num_rows(res))
+              old= 1;
+            else
+            {
+              MYSQL_ROW row= mysql_fetch_row(res);
+              old= !strncmp(row[1], "ON", 2);
+            }
+            mysql_free_result(res);
+          }
+        }
+        if (old)
+          my_make_scrambled_password_323(crypted_pw, typed_password, strlen(typed_password));
+        else
+          my_make_scrambled_password(crypted_pw, typed_password, strlen(typed_password));
+      }
+      else
+	crypted_pw[0]=0;			/* No password */
+      sprintf(buff,"set password='%s',sql_log_off=0",crypted_pw);
+
+      if (mysql_query(mysql,"set sql_log_off=1"))
+      {
+	my_printf_error(0, "Can't turn off logging; error: '%s'",
+			error_flags, mysql_error(mysql));
+        ret = -1;
+      }
+      else
+      if (mysql_query(mysql,buff))
+      {
+        my_printf_error(0,"unable to change password; error: '%s'",
+                        error_flags, mysql_error(mysql));
+        ret = -1;
+      }
+password_done:
+      /* free up memory from prompted password */
+      if (typed_password != argv[1]) 
+      {
+        my_free(typed_password);
+        my_free(verified);
+      }
+      argc--; argv++;
+      break;
+    }
+
+    case ADMIN_START_SLAVE:
+    case ADMIN_START_ALL_SLAVES:
+    {
+      my_bool many_slaves= 0;
+      const char *query= "START SLAVE";
+      if (command == ADMIN_START_ALL_SLAVES && mariadb_connection(mysql) &&
+          mysql_get_server_version(mysql) >= 100000)
+      {
+        query="START ALL SLAVES";
+        many_slaves= 1;
+      }
+
+      if (mysql_query(mysql, query))
+      {
+	my_printf_error(0, "Error starting slave: %s", error_flags,
+			mysql_error(mysql));
+	return -1;
+      }
+      else if (!many_slaves || mysql_warning_count(mysql) > 0)
+      {
+        if (!option_silent)
+          puts("Slave('s) started");
+      }
+      else
+      {
+        if (!option_silent)
+          puts("No slaves to start");
+      }
+      break;
+    }
+    case ADMIN_STOP_SLAVE:
+    case ADMIN_STOP_ALL_SLAVES:
+    {
+      const char *query= "STOP SLAVE";
+      my_bool many_slaves= 0;
+
+      if (command == ADMIN_STOP_ALL_SLAVES && mariadb_connection(mysql) &&
+          mysql_get_server_version(mysql) >= 100000)
+      {
+        query="STOP ALL SLAVES";
+        many_slaves= 1;
+      }
+
+      if (mysql_query(mysql, query))
+      {
+	  my_printf_error(0, "Error stopping slave: %s", error_flags,
+			  mysql_error(mysql));
+	  return -1;
+      }
+      else if (!many_slaves || mysql_warning_count(mysql) > 0)
+      {
+        /* We can't detect if there was any slaves to stop with STOP SLAVE */
+        if (many_slaves && !option_silent)
+          puts("Slave('s) stopped");
+      }
+      else
+      {
+        if (!option_silent)
+          puts("All slaves was already stopped");
+      }
+      break;
+    }
+    case ADMIN_PING:
+    {
+      my_bool reconnect= 0;
+      mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+      if (!mysql_ping(mysql))
+      {
+	if (option_silent < 2)
+	  puts("mysqld is alive");
+      }
+      else
+      {
+	if (mysql_errno(mysql) == CR_SERVER_GONE_ERROR)
+	{
+          reconnect= 1;
+          mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+	  if (!mysql_ping(mysql))
+	    puts("connection was down, but mysqld is now alive");
+	}
+	else
+	{
+	  my_printf_error(0,"mariadbd doesn't answer to ping, error: '%s'",
+			  error_flags, mysql_error(mysql));
+	  return -1;
+	}
+      }
+      reconnect=1;	/* Automatic reconnect is default */
+      mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
+      break;
+    }
+    default:
+      my_printf_error(0, "Unknown command: '%-.60s'", error_flags, argv[0]);
+      return 1;
+    }
+  }
+  return ret;
+}
+
+/**
+   @brief Masking the password if it is passed as command line argument.
+
+   @details It works in Linux and changes cmdline in ps and /proc/pid/cmdline,
+            but it won't work for history file of shell.
+            The command line arguments are copied to another array and the
+            password in the argv is masked. This function is called just after
+            "handle_options" because in "handle_options", the agrv pointers
+            are altered which makes freeing of dynamically allocated memory
+            difficult. The password masking is done before all other operations
+            in order to minimise the time frame of password visibility via cmdline.
+
+   @param argc            command line options (count)
+   @param argv            command line options (values)
+
+   @return temp_argv      copy of argv
+*/
+
+static char **mask_password(int argc, char ***argv)
+{
+  char **temp_argv;
+  if (!argc)
+    return NULL;
+
+  temp_argv= (char **)(my_malloc(PSI_NOT_INSTRUMENTED, sizeof(char *) * argc, MYF(MY_WME)));
+  argc--;
+  while (argc > 0)
+  {
+    temp_argv[argc]= my_strdup(PSI_NOT_INSTRUMENTED, (*argv)[argc], MYF(MY_FAE));
+    if (find_type((*argv)[argc - 1],&command_typelib, FIND_TYPE_BASIC) == ADMIN_PASSWORD ||
+        find_type((*argv)[argc - 1],&command_typelib, FIND_TYPE_BASIC) == ADMIN_OLD_PASSWORD)
+    {
+      char *start= (*argv)[argc];
+      while (*start)
+        *start++= 'x';
+      start= (*argv)[argc];
+      if (*start)
+        start[1]= 0;                         /* Cut length of argument */
+     }
+    argc--;
+  }
+  temp_argv[argc]= my_strdup(PSI_NOT_INSTRUMENTED, (*argv)[argc], MYF(MY_FAE));
+  return(temp_argv);
+}
+
+static void print_version(void)
+{
+  printf("%s  Ver %s Distrib %s, for %s on %s\n",my_progname,ADMIN_VERSION,
+	 MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
+}
+
+
+static void usage(void)
+{
+  print_version();
+  puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
+  puts("Administration program for the mysqld daemon.");
+  printf("Usage: %s [OPTIONS] command command....\n", my_progname);
+  print_defaults("my",load_default_groups);
+  puts("");
+  my_print_help(my_long_options);
+  my_print_variables(my_long_options);
+  puts("\nWhere command is a one or more of: (Commands may be shortened)\n\
+  create databasename	  Create a new database\n\
+  debug			  Instruct server to write debug information to log\n\
+  drop databasename	  Delete a database and all its tables\n\
+  extended-status         Gives an extended status message from the server\n\
+  flush-all-statistics    Flush all statistics tables\n\
+  flush-all-status        Flush status and statistics\n\
+  flush-client-statistics Flush client statistics\n\
+  flush-hosts             Flush all cached hosts\n\
+  flush-index-statistics  Flush index statistics\n\
+  flush-logs              Flush all logs\n\
+  flush-privileges        Reload grant tables (same as reload)\n\
+  flush-binary-log        Flush binary log\n\
+  flush-engine-log        Flush engine log(s)\n\
+  flush-error-log         Flush error log\n\
+  flush-general-log       Flush general log\n\
+  flush-relay-log         Flush relay log\n\
+  flush-slow-log          Flush slow query log\n\
+  flush-ssl               Flush SSL certificates\n\
+  flush-status            Clear status variables\n\
+  flush-table-statistics  Clear table statistics\n\
+  flush-tables            Flush all tables\n\
+  flush-threads           Flush the thread cache\n\
+  flush-user-statistics   Flush user statistics\n\
+  flush-user-resources    Flush user resources\n\
+  kill id,id,...	Kill mysql threads");
+#if MYSQL_VERSION_ID >= 32200
+  puts("\
+  password [new-password] Change old password to new-password in current format\n\
+  old-password [new-password] Change old password to new-password in old format");
+#endif
+  puts("\
+  ping			Check if mysqld is alive\n\
+  processlist		Show list of active threads in server\n\
+  reload		Reload grant tables\n\
+  refresh		Flush all tables and close and open logfiles\n\
+  shutdown		Take server down\n\
+  status		Gives a short status message from the server\n\
+  start-slave		Start slave\n\
+  stop-slave		Stop slave\n\
+  variables             Prints variables available\n\
+  version		Get version info from server");
+}
+
+
+static int drop_db(MYSQL *mysql, const char *db)
+{
+  char name_buff[FN_REFLEN+20], buf[10];
+  char *input;
+
+  if (!option_force)
+  {
+    puts("Dropping the database is potentially a very bad thing to do.");
+    puts("Any data stored in the database will be destroyed.\n");
+    printf("Do you really want to drop the '%s' database [y/N] ",db);
+    fflush(stdout);
+    input= fgets(buf, sizeof(buf)-1, stdin);
+    if (!input || ((*input != 'y') && (*input != 'Y')))
+    {
+      puts("\nOK, aborting database drop!");
+      return -1;
+    }
+  }
+  sprintf(name_buff,"drop database `%.*s`",FN_REFLEN,db);
+  if (mysql_query(mysql,name_buff))
+  {
+    my_printf_error(0, "DROP DATABASE %s failed;\nerror: '%s'", error_flags,
+		    db,mysql_error(mysql));
+    return 1;
+  }
+  printf("Database \"%s\" dropped\n",db);
+  return 0;
+}
+
+
+static void nice_time(ulong sec,char *buff)
+{
+  ulong tmp;
+
+  if (sec >= 3600L*24)
+  {
+    tmp=sec/(3600L*24);
+    sec-=3600L*24*tmp;
+    buff=int10_to_str(tmp, buff, 10);
+    buff=strmov(buff,tmp > 1 ? " days " : " day ");
+  }
+  if (sec >= 3600L)
+  {
+    tmp=sec/3600L;
+    sec-=3600L*tmp;
+    buff=int10_to_str(tmp, buff, 10);
+    buff=strmov(buff,tmp > 1 ? " hours " : " hour ");
+  }
+  if (sec >= 60)
+  {
+    tmp=sec/60;
+    sec-=60*tmp;
+    buff=int10_to_str(tmp, buff, 10);
+    buff=strmov(buff," min ");
+  }
+  strmov(int10_to_str(sec, buff, 10)," sec");
+}
+
+
+static void print_header(MYSQL_RES *result)
+{
+  MYSQL_FIELD *field;
+
+  print_top(result);
+  mysql_field_seek(result,0);
+  putchar('|');
+  while ((field = mysql_fetch_field(result)))
+  {
+    printf(" %-*s|",(int) field->max_length+1,field->name);
+  }
+  putchar('\n');
+  print_top(result);
+}
+
+
+static void print_top(MYSQL_RES *result)
+{
+  uint i,length;
+  MYSQL_FIELD *field;
+
+  putchar('+');
+  mysql_field_seek(result,0);
+  while((field = mysql_fetch_field(result)))
+  {
+    if ((length=(uint) strlen(field->name)) > field->max_length)
+      field->max_length=length;
+    else
+      length=field->max_length;
+    for (i=length+2 ; i--> 0 ; )
+      putchar('-');
+    putchar('+');
+  }
+  putchar('\n');
+}
+
+
+/* 3.rd argument, uint row, is not in use. Don't remove! */
+static void print_row(MYSQL_RES *result, MYSQL_ROW cur,
+		      uint row __attribute__((unused)))
+{
+  uint i,length;
+  MYSQL_FIELD *field;
+
+  putchar('|');
+  mysql_field_seek(result,0);
+  for (i=0 ; i < mysql_num_fields(result); i++)
+  {
+    field = mysql_fetch_field(result);
+    length=field->max_length;
+    printf(" %-*s|",length+1,cur[i] ? (char*) cur[i] : "");
+  }
+  putchar('\n');
+}
+
+
+static void print_relative_row(MYSQL_RES *result, MYSQL_ROW cur, uint row)
+{
+  ulonglong tmp;
+  char buff[22];
+  MYSQL_FIELD *field;
+
+  mysql_field_seek(result, 0);
+  field = mysql_fetch_field(result);
+  printf("| %-*s|", (int) field->max_length + 1, cur[0]);
+
+  field = mysql_fetch_field(result);
+  tmp = cur[1] ? strtoull(cur[1], NULL, 10) : (ulonglong) 0;
+  printf(" %-*s|\n", (int) field->max_length + 1,
+	 llstr((tmp - last_values[row]), buff));
+  last_values[row] = tmp;
+}
+
+
+static void print_relative_row_vert(MYSQL_RES *result __attribute__((unused)),
+				    MYSQL_ROW cur,
+				    uint row __attribute__((unused)))
+{
+  uint length;
+  ulonglong tmp;
+  char buff[22];
+
+  if (!row)
+    putchar('|');
+
+  tmp = cur[1] ? strtoull(cur[1], NULL, 10) : (ulonglong) 0;
+  printf(" %-*s|", ex_val_max_len[row] + 1,
+	 llstr((tmp - last_values[row]), buff));
+
+  /* Find the minimum row length needed to output the relative value */
+  length=(uint) strlen(buff);
+  if (length > ex_val_max_len[row] && ex_status_printed)
+    ex_val_max_len[row] = length;
+  last_values[row] = tmp;
+}
+
+
+static void store_values(MYSQL_RES *result)
+{
+  uint i;
+  MYSQL_ROW row;
+  MYSQL_FIELD *field;
+
+  field = mysql_fetch_field(result);
+  max_var_length = field->max_length;
+  field = mysql_fetch_field(result);
+  max_val_length = field->max_length;
+
+  for (i = 0; (row = mysql_fetch_row(result)); i++)
+  {
+    strmov(ex_var_names[i], row[0]);
+    last_values[i]=strtoull(row[1],NULL,10);
+    ex_val_max_len[i]=2;		/* Default print width for values */
+  }
+  ex_var_count = i;
+  return;
+}
+
+
+static void print_relative_header()
+{
+  uint i;
+
+  putchar('|');
+  for (i = 0; i < ex_var_count; i++)
+    printf(" %-*s|", ex_val_max_len[i] + 1, truncated_var_names[i]);
+  putchar('\n');
+}
+
+
+static void print_relative_line()
+{
+  uint i;
+
+  putchar('+');
+  for (i = 0; i < ex_var_count; i++)
+  {
+    uint j;
+    for (j = 0; j < ex_val_max_len[i] + 2; j++)
+      putchar('-');
+    putchar('+');
+  }
+  putchar('\n');
+}
+
+
+static void truncate_names()
+{
+  uint i;
+  char *ptr,top_line[MAX_TRUNC_LENGTH+4+NAME_LEN+22+1],buff[22];
+
+  ptr=top_line;
+  *ptr++='+';
+  ptr=strfill(ptr,max_var_length+2,'-');
+  *ptr++='+';
+  ptr=strfill(ptr,MAX_TRUNC_LENGTH+2,'-');
+  *ptr++='+';
+  ptr=strfill(ptr,max_val_length+2,'-');
+  *ptr++='+';
+  *ptr=0;
+  puts(top_line);
+
+  for (i = 0 ; i < ex_var_count; i++)
+  {
+    uint sfx=1,j;
+    printf("| %-*s|", max_var_length + 1, ex_var_names[i]);
+    ptr = ex_var_names[i];
+    /* Make sure no two same truncated names will become */
+    for (j = 0; j < i; j++)
+      if (*truncated_var_names[j] == *ptr)
+	sfx++;
+
+    truncated_var_names[i][0]= *ptr;		/* Copy first var char */
+    int10_to_str(sfx, truncated_var_names[i]+1,10);
+    printf(" %-*s|", MAX_TRUNC_LENGTH + 1, truncated_var_names[i]);
+    printf(" %-*s|\n", max_val_length + 1, llstr(last_values[i],buff));
+  }
+  puts(top_line);
+  return;
+}
+
+
+static my_bool get_pidfile(MYSQL *mysql, char *pidfile)
+{
+  MYSQL_RES* result;
+
+  if (mysql_query(mysql, "SHOW VARIABLES LIKE 'pid_file'"))
+  {
+    my_printf_error(mysql_errno(mysql),
+                    "The query to get the server's pid file failed,"
+                    " error: '%s'. Continuing.", error_flags,
+                    mysql_error(mysql));
+  }
+  result = mysql_store_result(mysql);
+  if (result)
+  {
+    MYSQL_ROW row=mysql_fetch_row(result);
+    if (row)
+      strmov(pidfile, row[1]);
+    mysql_free_result(result);
+    return row == 0;				/* Error if row = 0 */
+  }
+  return 1;					/* Error */
+}
+
+/*
+  Return 1 if pid file didn't disappear or change
+*/
+
+static my_bool wait_pidfile(char *pidfile, time_t last_modified,
+			    struct stat *pidfile_status)
+{
+  char buff[FN_REFLEN];
+  my_bool error= 1;
+  uint count= 0;
+  DBUG_ENTER("wait_pidfile");
+
+  system_filename(buff, pidfile);
+  do
+  {
+    int fd;
+    if ((fd= my_open(buff, O_RDONLY, MYF(0))) < 0)
+    {
+      error= 0;
+      break;
+    }
+    (void) my_close(fd,MYF(0));
+    if (last_modified && !stat(pidfile, pidfile_status))
+    {
+      if (last_modified != pidfile_status->st_mtime)
+      {
+	/* File changed;  Let's assume that mysqld did restart */
+	if (opt_verbose)
+	  printf("pid file '%s' changed while waiting for it to disappear!\nmysqld did probably restart\n",
+		 buff);
+	error= 0;
+	break;
+      }
+    }
+    if (count++ == opt_shutdown_timeout)
+      break;
+    sleep(1);
+  } while (!interrupted);
+
+  if (error)
+  {
+    DBUG_PRINT("warning",("Pid file didn't disappear"));
+    fprintf(stderr,
+	    "Warning;  Aborted waiting on pid file: '%s' after %d seconds\n",
+	    buff, count-1);
+  }
+  DBUG_RETURN(error);
+}