~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2006 MySQL AB

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* maintaince of mysql databases */

#include "client_priv.h"

#include <signal.h>

#include <my_pthread.h>				/* because of signal()	*/

#include <sys/stat.h>

#include <mysql.h>

#ifdef LATER_HAVE_NDBCLUSTER_DB

#include "../ndb/src/mgmclient/ndb_mgmclient.h"

#endif

#define ADMIN_VERSION "8.42"

#define MAX_MYSQL_VAR 256

#define SHUTDOWN_DEF_TIMEOUT 3600		/* Wait for shutdown */

#define MAX_TRUNC_LENGTH 3

char *host= NULL, *user= 0, *opt_password= 0,

     *default_charset= NULL;

char truncated_var_names[MAX_MYSQL_VAR][MAX_TRUNC_LENGTH];

char ex_var_names[MAX_MYSQL_VAR][FN_REFLEN];

ulonglong last_values[MAX_MYSQL_VAR];

static int interval=0;

static my_bool option_force=0,interrupted=0,new_line=0,

               opt_compress=0, opt_relative=0, opt_verbose=0, opt_vertical=0,

               tty_password= 0, opt_nobeep;

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;

#ifdef LATER_HAVE_NDBCLUSTER_DB

static my_bool opt_ndbcluster=0;

static char *opt_ndb_connectstring=0;

#endif

#ifdef HAVE_SMEM

static char *shared_memory_base_name=0;

#endif

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;

static void print_version(void);

static void usage(void);

extern "C" my_bool get_one_option(int optid, const struct my_option *opt,

                                  char *argument);

static my_bool sql_connect(MYSQL *mysql, uint wait);

static int execute_commands(MYSQL *mysql,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_FLUSH_THREADS,    ADMIN_OLD_PASSWORD

#ifdef LATER_HAVE_NDBCLUSTER_DB

  ,ADMIN_NDB_MGM

#endif

};

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",

  "flush-threads","old-password",

#ifdef LATER_HAVE_NDBCLUSTER_DB

  "ndb-mgm",

#endif

  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.",

   (uchar**) &nr_iterations, (uchar**) &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 .",

   (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},

  {"force", 'f',

   "Don't ask for confirmation on drop database; with multiple commands, continue even if an error occurs.",

   (uchar**) &option_force, (uchar**) &option_force, 0, GET_BOOL, NO_ARG, 0, 0,

   0, 0, 0, 0},

  {"compress", 'C', "Use compression in server/client protocol.",

   (uchar**) &opt_compress, (uchar**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,

   0, 0, 0},

  {"character-sets-dir", OPT_CHARSETS_DIR,

   "Directory where character sets are.", (uchar**) &charsets_dir,

   (uchar**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"default-character-set", OPT_DEFAULT_CHARSET,

   "Set the default character set.", (uchar**) &default_charset,

   (uchar**) &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.", (uchar**) &host, (uchar**) &host, 0, GET_STR,

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"no-beep", 'b', "Turn off beep on error.", (uchar**) &opt_nobeep,

   (uchar**) &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},

  {"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) ").",

   (uchar**) &tcp_port,

   (uchar**) &tcp_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"protocol", OPT_MYSQL_PROTOCOL, "The protocol of connection (tcp,socket,pipe,memory).",

    0, 0, 0, GET_STR,  REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"relative", 'r',

   "Show difference between current and previous values when used with -i. Currently works only with extended-status.",

   (uchar**) &opt_relative, (uchar**) &opt_relative, 0, GET_BOOL, NO_ARG, 0, 0, 0,

  0, 0, 0},

  {"set-variable", 'O',

   "Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value.",

   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

#ifdef HAVE_SMEM

  {"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,

   "Base name of shared memory.", (uchar**) &shared_memory_base_name, (uchar**) &shared_memory_base_name,

   0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

#endif

  {"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', "Socket file to use for connection.",

   (uchar**) &unix_port, (uchar**) &unix_port, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,

   0, 0, 0},

  {"sleep", 'i', "Execute commands again and again with a sleep between.",

   (uchar**) &interval, (uchar**) &interval, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0,

   0, 0},

#ifndef DONT_ALLOW_USER_CHANGE

  {"user", 'u', "User for login if not current user.", (uchar**) &user,

   (uchar**) &user, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

#endif

  {"verbose", 'v', "Write more information.", (uchar**) &opt_verbose,

   (uchar**) &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.",

   (uchar**) &opt_vertical, (uchar**) &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, "", (uchar**) &opt_connect_timeout,

   (uchar**) &opt_connect_timeout, 0, GET_ULONG, REQUIRED_ARG, 3600*12, 0,

   3600*12, 0, 1, 0},

  {"shutdown_timeout", OPT_SHUTDOWN_TIMEOUT, "", (uchar**) &opt_shutdown_timeout,

   (uchar**) &opt_shutdown_timeout, 0, GET_ULONG, REQUIRED_ARG,

   SHUTDOWN_DEF_TIMEOUT, 0, 3600*12, 0, 1, 0},

#ifdef LATER_HAVE_NDBCLUSTER_DB

  {"ndbcluster", OPT_NDBCLUSTER, ""

   "", (uchar**) &opt_ndbcluster,

   (uchar**) &opt_ndbcluster, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"ndb-connectstring", OPT_NDB_CONNECTSTRING, ""

   "", (uchar**) &opt_ndb_connectstring,

   (uchar**) &opt_ndb_connectstring, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

#endif

  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

};

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

my_bool

get_one_option(int optid, const struct my_option *opt __attribute__((unused)),

	       char *argument)

{

  int error = 0;

  switch(optid) {

  case 'c':

    opt_count_iterations= 1;

    break;

  case 'p':

    if (argument)

    {

      char *start=argument;

      my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));

      opt_password=my_strdup(argument,MYF(MY_FAE));

      while (*argument) *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 '#':

    DBUG_PUSH(argument ? argument : "d:t:o,/tmp/mysqladmin.trace");

    break;

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

    error++;

    break;

  case OPT_CHARSETS_DIR:

#if MYSQL_VERSION_ID > 32300

    charsets_dir = argument;

#endif

    break;

  case OPT_MYSQL_PROTOCOL:

    opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,

                                    opt->name);

    break;

  }

  if (error)

  {

    usage();

    exit(1);

  }

  return 0;

}

int main(int argc,char *argv[])

{

  int error= 0, ho_error;

  MYSQL mysql;

  char **commands, **save_argv;

  MY_INIT(argv[0]);

  mysql_init(&mysql);

  load_defaults("my",load_default_groups,&argc,&argv);

  save_argv = argv;				/* Save for free_defaults */

  if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))

  {

    free_defaults(save_argv);

    exit(ho_error);

  }

  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 = argv;

  if (tty_password)

    opt_password = get_tty_password(NullS);

  VOID(signal(SIGINT,endprog));			/* Here if abort */

  VOID(signal(SIGTERM,endprog));		/* Here if abort */

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

  }

  if (opt_protocol)

    mysql_options(&mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);

#ifdef HAVE_SMEM

  if (shared_memory_base_name)

    mysql_options(&mysql,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name);

#endif

  if (default_charset)

    mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, default_charset);

  error_flags= (myf)(opt_nobeep ? 0 : ME_BELL);

  if (sql_connect(&mysql, option_wait))

  {

    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, 2) != ADMIN_PING)

        {

          error= 1;

          break;

        }

      }

    }

  }

  else

  {

    while (!interrupted && (!opt_count_iterations || nr_iterations))

    {

      new_line = 0;

      if ((error=execute_commands(&mysql,argc,commands)))

      {

	if (error > 0)

	  break;				/* Wrong command error */

	if (!option_force)

	{

	  if (option_wait && !interrupted)

	  {

	    mysql_close(&mysql);

	    if (!sql_connect(&mysql, option_wait))

	    {

	      sleep(1);				/* Don't retry too rapidly */

	      continue;				/* Retry */

	    }

	  }

	  error=1;

	  break;

	}

      }

      if (interval)

      {

	sleep(interval);

	if (new_line)

	  puts("");

	if (opt_count_iterations)

	  nr_iterations--;

      }

      else

	break;

    }

    mysql_close(&mysql);

  }

  my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));

  my_free(user,MYF(MY_ALLOW_ZERO_PTR));

#ifdef HAVE_SMEM

  my_free(shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));

#endif

  free_defaults(save_argv);

  my_end(my_end_arg);

  exit(error ? 1 : 0);

}

sig_handler endprog(int signal_number __attribute__((unused)))

{

  interrupted=1;

}

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, 0))

    {

      mysql->reconnect= 1;

      if (info)

      {

	fputs("\n",stderr);

	(void) fflush(stderr);

      }

      return 0;

    }

    if (!wait)

    {

      if (!option_silent)

      {

	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 mysqld 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 mysqld 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--;				/* One less retry */

    if ((mysql_errno(mysql) != CR_CONN_HOST_ERROR) &&

	(mysql_errno(mysql) != CR_CONNECTION_ERROR))

    {

      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 MySQL server to answer",stderr);

	(void) fflush(stderr);

      }

      else

      {

	putc('.',stderr);

	(void) fflush(stderr);

      }

    }

    sleep(5);

  }

}

/*

  Execute a command.

  Return 0 on ok

	 -1 on retryable error

	 1 on fatal error

*/

static int execute_commands(MYSQL *mysql,int argc, char **argv)

{

  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 rand_struct rand_st;

  for (; argc > 0 ; argv++,argc--)

  {

    switch (find_type(argv[0],&command_typelib,2)) {

    case ADMIN_CREATE:

    {

      char buff[FN_REFLEN+20];

      if (argc < 2)

      {

	my_printf_error(0, "Too few arguments to create", error_flags);

	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 (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 (mysql_shutdown(mysql, SHUTDOWN_DEFAULT))

      {

	my_printf_error(0, "shutdown failed; error: '%s'", error_flags,

			mysql_error(mysql));

	return -1;

      }

      mysql_close(mysql);	/* Close connection to avoid error messages */

      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 (mysql_query(mysql,"flush privileges"))

      {

	my_printf_error(0, "reload failed; error: '%s'", error_flags,

			mysql_error(mysql));

	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("Copyright (C) 2000-2006 MySQL AB");

      puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\nand you are welcome to modify and redistribute it under the GPL license\n");

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

	{

	  if (mysql_kill(mysql,(ulong) atol(pos)))

	  {

	    my_printf_error(0, "kill failed on %ld; error: '%s'", error_flags,

			    atol(pos), 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;