开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mysqladmin.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：30k
源码类别：

MySQL数据库

开发平台：

Visual C++

mysqladmin.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* maintaince of mysql databases */
  20. #include <global.h>
  21. #include <my_sys.h>
  22. #include <m_string.h>
  23. #include <signal.h>
  24. #include "mysql.h"
  25. #include "errmsg.h"
  26. #include <getopt.h>
  27. #ifdef THREAD
  28. #include <my_pthread.h> /* because of signal() */
  29. #endif
  31. #define ADMIN_VERSION "8.18"
  32. #define MAX_MYSQL_VAR 64
  33. #define SHUTDOWN_DEF_TIMEOUT 3600 /* Wait for shutdown */
  34. #define MAX_TRUNC_LENGTH 3
  36. char truncated_var_names[MAX_MYSQL_VAR][MAX_TRUNC_LENGTH];
  37. char ex_var_names[MAX_MYSQL_VAR][FN_REFLEN];
  38. ulonglong last_values[MAX_MYSQL_VAR];
  39. static int interval=0;
  40. static my_bool option_force=0,interrupted=0,new_line=0,
  41.                opt_compress=0, opt_relative=0, opt_verbose=0, opt_vertical=0;
  42. static uint tcp_port = 0, option_wait = 0, option_silent=0;
  43. static ulong opt_connect_timeout, opt_shutdown_timeout;
  44. static my_string unix_port=0;
  46. /* When using extended-status relatively, ex_val_max_len is the estimated
  47.    maximum length for any relative value printed by extended-status. The
  48.    idea is to try to keep the length of output as short as possible. */
  49. static uint ex_val_max_len[MAX_MYSQL_VAR];
  50. static my_bool ex_status_printed = 0; /* First output is not relative. */
  51. static uint ex_var_count, max_var_length, max_val_length;
  53. #include "sslopt-vars.h"
  55. static void print_version(void);
  56. static void usage(void);
  57. static my_bool sql_connect(MYSQL *mysql,const char *host, const char *user,
  58.    const char *password,uint wait);
  59. static my_bool execute_commands(MYSQL *mysql,int argc, char **argv);
  60. static int drop_db(MYSQL *mysql,const char *db);
  61. static sig_handler endprog(int signal_number);
  62. static void nice_time(ulong sec,char *buff);
  63. static void print_header(MYSQL_RES *result);
  64. static void print_top(MYSQL_RES *result);
  65. static void print_row(MYSQL_RES *result,MYSQL_ROW cur, uint row);
  66. static void print_relative_row(MYSQL_RES *result, MYSQL_ROW cur, uint row);
  67. static void print_relative_row_vert(MYSQL_RES *result, MYSQL_ROW cur, uint row);
  68. static void print_relative_header();
  69. static void print_relative_line();
  70. static void truncate_names();
  71. static my_bool get_pidfile(MYSQL *mysql, char *pidfile);
  72. static void wait_pidfile(char *pidfile);
  73. static void store_values(MYSQL_RES *result);
  75. /*
  76.   The order of commands must be the same as command_names,
  77.   except ADMIN_ERROR
  78. */
  79. enum commands { 
  80.   ADMIN_ERROR, 
  81.   ADMIN_CREATE,           ADMIN_DROP,            ADMIN_SHUTDOWN,
  82.   ADMIN_RELOAD,           ADMIN_REFRESH,         ADMIN_VER, 
  83.   ADMIN_PROCESSLIST,      ADMIN_STATUS,          ADMIN_KILL, 
  84.   ADMIN_DEBUG,            ADMIN_VARIABLES,       ADMIN_FLUSH_LOGS, 
  85.   ADMIN_FLUSH_HOSTS,      ADMIN_FLUSH_TABLES,    ADMIN_PASSWORD, 
  86.   ADMIN_PING,             ADMIN_EXTENDED_STATUS, ADMIN_FLUSH_STATUS, 
  87.   ADMIN_FLUSH_PRIVILEGES, ADMIN_START_SLAVE,     ADMIN_STOP_SLAVE, 
  88.   ADMIN_FLUSH_THREADS
  89. };
  90. static const char *command_names[]= {
  91.   "create",               "drop",                "shutdown",
  92.   "reload",               "refresh",             "version",
  93.   "processlist",          "status",              "kill",
  94.   "debug",                "variables",           "flush-logs",
  95.   "flush-hosts",          "flush-tables",        "password",
  96.   "ping",                 "extended-status",     "flush-status",
  97.   "flush-privileges",     "start-slave",         "stop-slave",  
  98.   "flush-threads", 
  99.   NullS
  100. };
  102. static TYPELIB command_typelib=
  103. { array_elements(command_names)-1,"commands", command_names};
  105. enum options { OPT_CHARSETS_DIR=256 };
  107. static struct option long_options[] = {
  108.   {"compress",           no_argument,       0, 'C'},
  109.   {"character-sets-dir", required_argument, 0, OPT_CHARSETS_DIR},
  110.   {"debug",              optional_argument, 0, '#'},
  111.   {"force",              no_argument,       0, 'f'},
  112.   {"help",               no_argument,       0, '?'},
  113.   {"host",               required_argument, 0, 'h'},
  114.   {"password",           optional_argument, 0, 'p'},
  115. #ifdef __WIN__
  116.   {"pipe",               no_argument,       0, 'W'},
  117. #endif
  118.   {"port",               required_argument, 0, 'P'},
  119.   {"relative",           no_argument,       0, 'r'},
  120.   {"set-variable",  required_argument, 0, 'O'},
  121.   {"silent",             no_argument,       0, 's'},
  122.   {"socket",             required_argument, 0, 'S'},
  123.   {"sleep",              required_argument, 0, 'i'},
  124. #include "sslopt-longopts.h"
  125. #ifndef DONT_ALLOW_USER_CHANGE
  126.   {"user",               required_argument, 0, 'u'},
  127. #endif
  128.   {"verbose",            no_argument,       0, 'v'},
  129.   {"version",            no_argument,       0, 'V'},
  130.   {"vertical",           no_argument,       0, 'E'},
  131.   {"wait",               optional_argument, 0, 'w'},
  132.   {0, 0, 0, 0}
  133. };
  135. CHANGEABLE_VAR changeable_vars[] = {
  136.   { "connect_timeout", (long*) &opt_connect_timeout, 0, 0, 3600*12, 0, 1},
  137.   { "shutdown_timeout", (long*) &opt_shutdown_timeout, SHUTDOWN_DEF_TIMEOUT, 0,
  138.     3600*12, 0, 1},
  139.   { 0, 0, 0, 0, 0, 0, 0}  
  140. };
  142. static const char *load_default_groups[]= { "mysqladmin","client",0 };
  144. int main(int argc,char *argv[])
  145. {
  146.   int c, error = 0,option_index=0;
  147.   MYSQL mysql;
  148.   char *host = NULL,*opt_password=0,*user=0,**commands;
  149.   my_bool tty_password=0;
  150.   MY_INIT(argv[0]);
  151.   mysql_init(&mysql);
  152.   load_defaults("my",load_default_groups,&argc,&argv);
  153.   set_all_changeable_vars( changeable_vars );
  155.   while ((c=getopt_long(argc,argv,"h:i:p::u:#::P:sS:Ct:fq?vVw::WrEO:",
  156. long_options, &option_index)) != EOF)
  157.   {
  158.     switch(c) {
  159.     case 'C':
  160.       opt_compress=1;
  161.       break;
  162.     case 'h':
  163.       host = optarg;
  164.       break;
  165.     case 'q': /* Allow old 'q' option */
  166.     case 'f':
  167.       option_force++;
  168.       break;
  169.     case 'p':
  170.       if (optarg)
  171.       {
  172. char *start=optarg;
  173. my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
  174. opt_password=my_strdup(optarg,MYF(MY_FAE));
  175. while (*optarg) *optarg++= 'x'; /* Destroy argument */
  176. if (*start)
  177.   start[1]=0; /* Cut length of argument */
  178.       }
  179.       else
  180. tty_password=1;
  181.       break;
  182. #ifndef DONT_ALLOW_USER_CHANGE
  183.     case 'u':
  184.       user= my_strdup(optarg,MYF(0));
  185.       break;
  186. #endif
  187.     case 'i':
  188.       interval=atoi(optarg);
  189.       break;
  190.     case 'P':
  191.       tcp_port= (unsigned int) atoi(optarg);
  192.       break;
  193.     case 'r':
  194.       opt_relative = 1;
  195.       break;
  196.     case 'E':
  197.       opt_vertical = 1;
  198.       break;
  199.     case 'O':
  200.       if (set_changeable_var(optarg, changeable_vars))
  201.       {
  202. usage();
  203. return(1);
  204.       }
  205.       break;
  206.     case 's':
  207.       option_silent++;
  208.       break;
  209.     case 'S':
  210.       unix_port= optarg;
  211.       break;
  212.     case 'W':
  213. #ifdef __WIN__
  214.       unix_port=MYSQL_NAMEDPIPE;
  215. #endif
  216.       break;
  217.     case '#':
  218.       DBUG_PUSH(optarg ? optarg : "d:t:o,/tmp/mysqladmin.trace");
  219.       break;
  220.     case 'V':
  221.       print_version();
  222.       exit(0);
  223.       break;
  224.     case 'v':
  225.       opt_verbose=1;
  226.       break;
  227.     case 'w':
  228.       if (optarg)
  229.       {
  230. if ((option_wait=atoi(optarg)) <= 0)
  231.   option_wait=1;
  232.       }
  233.       else
  234. option_wait= ~0;
  235.       break;
  236. #include "sslopt-case.h"
  237.     default:
  238.       fprintf(stderr,"Illegal option character '%c'n",opterr);
  239.       /* Fall throught */
  240.     case '?':
  241.     case 'I': /* Info */
  242.       error++;
  243.       break;
  244.     case OPT_CHARSETS_DIR:
  245. #if MYSQL_VERSION_ID > 32300
  246.       charsets_dir = optarg;
  247. #endif
  248.       break;
  249.     }
  250.   }
  251.   argc -= optind;
  252.   commands = argv + optind;
  253.   if (error || argc == 0)
  254.   {
  255.     usage();
  256.     exit(1);
  257.   }
  258.   if (tty_password)
  259.     opt_password = get_tty_password(NullS);
  261.   VOID(signal(SIGINT,endprog)); /* Here if abort */
  262.   VOID(signal(SIGTERM,endprog)); /* Here if abort */
  264.   if (opt_compress)
  265.     mysql_options(&mysql,MYSQL_OPT_COMPRESS,NullS);
  266.   if (opt_connect_timeout)
  267.   {
  268.     uint tmp=opt_connect_timeout;
  269.     mysql_options(&mysql,MYSQL_OPT_CONNECT_TIMEOUT, (char*) &tmp);
  270.   }
  271. #ifdef HAVE_OPENSSL
  272.   if (opt_use_ssl)
  273.     mysql_ssl_set(&mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
  274.   opt_ssl_capath);
  275. #endif /* HAVE_OPENSSL */
  276.   if (sql_connect(&mysql,host,user,opt_password,option_wait))
  277.     error = 1;
  278.   else
  279.   {
  280.     error = 0;
  281.     while (!interrupted)
  282.     {
  283.       new_line = 0;
  284.       if (execute_commands(&mysql,argc,commands) && !option_force)
  285.       {
  286. if (option_wait && !interrupted)
  287. {
  288.   mysql_close(&mysql);
  289.   if (!sql_connect(&mysql,host,user,opt_password,option_wait))
  290.     continue; /* Retry */
  291. }
  292. error=1;
  293. break;
  294.       }
  295.       if (interval)
  296.       {
  297. sleep(interval);
  298. if (new_line)
  299.   puts("");
  300.       }
  301.       else
  302. break;
  303.     }
  304.     mysql_close(&mysql);
  305.   }
  306.   my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
  307.   my_free(user,MYF(MY_ALLOW_ZERO_PTR));
  308.   free_defaults(argv);
  309.   my_end(0);
  310.   exit(error);
  311.   return 0;
  312. }
  315. static sig_handler endprog(int signal_number __attribute__((unused)))
  316. {
  317.   interrupted=1;
  318. }
  321. static my_bool sql_connect(MYSQL *mysql,const char *host, const char *user,
  322. const char *password,uint wait)
  323. {
  324.   my_bool info=0;
  326.   for (;;)
  327.   {
  328.     if (mysql_real_connect(mysql,host,user,password,NullS,tcp_port,unix_port,
  329.    0))
  330.     {
  331.       if (info)
  332.       {
  333. fputs("n",stderr);
  334. (void) fflush(stderr);
  335.       }
  336.       return 0;
  337.     }
  338.   
  339.     if (!wait)
  340.     {
  341.       if (!option_silent)
  342.       {
  343. if (!host)
  344.   host=LOCAL_HOST;
  345. my_printf_error(0,"connect to server at '%s' failednerror: '%s'",
  346. MYF(ME_BELL), host, mysql_error(mysql));
  347. if (mysql_errno(mysql) == CR_CONNECTION_ERROR)
  348. {
  349.   fprintf(stderr,
  350.   "Check that mysqld is running and that the socket: '%s' exists!n",
  351.   unix_port ? unix_port : mysql_unix_port);
  352. }
  353. else if (mysql_errno(mysql) == CR_CONN_HOST_ERROR ||
  354.  mysql_errno(mysql) == CR_UNKNOWN_HOST)
  355. {
  356.   fprintf(stderr,"Check that mysqld is running on %s",host);
  357.   fprintf(stderr," and that the port is %d.n",
  358.   tcp_port ? tcp_port: mysql_port);
  359.   fprintf(stderr,"You can check this by doing 'telnet %s %d'n",
  360.   host, tcp_port ? tcp_port: mysql_port);
  361. }
  362.       }
  363.       return 1;
  364.     }
  365.     if (wait != (uint) ~0)
  366.       wait--; /* One less retry */
  367.     if ((mysql_errno(mysql) != CR_CONN_HOST_ERROR) &&
  368. (mysql_errno(mysql) != CR_CONNECTION_ERROR))
  369.     {  
  370.       fprintf(stderr,"Got error: %sn", mysql_error(mysql));
  371.       if (!option_force)
  372. return 1;
  373.     }
  374.     else if (!option_silent)
  375.     {
  376.       if (!info)
  377.       {
  378. info=1;
  379. fputs("Waiting for MySQL server to answer",stderr);
  380. (void) fflush(stderr);
  381.       }
  382.       else
  383.       {
  384. putc('.',stderr); 
  385. (void) fflush(stderr);
  386.       }
  387.     }
  388.     sleep(5);
  389.   }
  390. }
  393. static my_bool execute_commands(MYSQL *mysql,int argc, char **argv)
  394. {
  395.   char *status;
  397.   for (; argc > 0 ; argv++,argc--)
  398.   {
  399.     switch (find_type(argv[0],&command_typelib,2)) {
  400.     case ADMIN_CREATE:
  401.     {
  402.       char buff[FN_REFLEN+20];
  403.       if (argc < 2)
  404.       {
  405. my_printf_error(0,"Too few arguments to create",MYF(ME_BELL));
  406. return 1;
  407.       }
  408.       sprintf(buff,"create database `%.*s`",FN_REFLEN,argv[1]);
  409.       if (mysql_query(mysql,buff))
  410.       {
  411. my_printf_error(0,"CREATE DATABASE failed; error: '%-.200s'",
  412. MYF(ME_BELL), mysql_error(mysql));
  413. return 1;
  414.       }
  415.       argc--; argv++;
  416.       break;
  417.     }
  418.     case ADMIN_DROP:
  419.     {
  420.       char buff[FN_REFLEN+20];
  421.       if (argc < 2)
  422.       {
  423. my_printf_error(0,"Too few arguments to drop",MYF(ME_BELL));
  424. return 1;
  425.       }
  426.       sprintf(buff,"drop database `%.*s`",FN_REFLEN,argv[1]);
  427.       if (mysql_query(mysql,buff))
  428.       {
  429. my_printf_error(0,"DROP DATABASE failed; error: '%-.200s'",
  430. MYF(ME_BELL), mysql_error(mysql));
  431. return 1;
  432.       }
  433.       argc--; argv++;
  434.       break;
  435.     }
  436.     case ADMIN_SHUTDOWN:
  437.     {
  438.       char pidfile[FN_REFLEN];
  439.       my_bool got_pidfile=0;
  440.       /* Only wait for pidfile on local connections */
  441.       /* If pidfile doesn't exist, continue without pid file checking */
  442.       if (mysql->unix_socket)
  443. got_pidfile= !get_pidfile(mysql, pidfile);
  444.       if (mysql_shutdown(mysql))
  445.       {
  446. my_printf_error(0,"shutdown failed; error: '%s'",MYF(ME_BELL),
  447. mysql_error(mysql));
  448. return 1;
  449.       }
  450.       mysql_close(mysql); /* Close connection to avoid error messages */
  451.       if (got_pidfile)
  452.       {
  453. if (opt_verbose)
  454.   printf("Shutdown signal sent to server;  Waiting for pid file to disappearn");
  455. wait_pidfile(pidfile); /* Wait until pid file is gone */
  456.       }
  457.       break;
  458.     }
  459.     case ADMIN_FLUSH_PRIVILEGES:
  460.     case ADMIN_RELOAD:
  461.       if (mysql_refresh(mysql,REFRESH_GRANT) < 0)
  462.       {
  463. my_printf_error(0,"reload failed; error: '%s'",MYF(ME_BELL),
  464. mysql_error(mysql));
  465. return 1;
  466.       }
  467.       break;
  468.     case ADMIN_REFRESH:
  469.       if (mysql_refresh(mysql,
  470. (uint) ~(REFRESH_GRANT | REFRESH_STATUS |
  471.  REFRESH_READ_LOCK | REFRESH_SLAVE |
  472.  REFRESH_MASTER)) < 0)
  473.       {
  474. my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL),
  475. mysql_error(mysql));
  476. return 1;
  477.       }
  478.       break;
  479.     case ADMIN_FLUSH_THREADS:
  480.       if (mysql_refresh(mysql,(uint) REFRESH_THREADS) < 0)
  481.       {
  482. my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL),
  483. mysql_error(mysql));
  484. return 1;
  485.       }
  486.       break;
  487.     case ADMIN_VER:
  488.       new_line=1;
  489.       print_version();
  490.       puts("Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB");
  491.       puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,nand you are welcome to modify and redistribute it under the GPL licensen");
  492.       printf("Server versiontt%sn", mysql_get_server_info(mysql));
  493.       printf("Protocol versiont%dn", mysql_get_proto_info(mysql));
  494.       printf("Connectiontt%sn",mysql_get_host_info(mysql));
  495.       if (mysql->unix_socket)
  496. printf("UNIX sockettt%sn", mysql->unix_socket);
  497.       else
  498. printf("TCP porttt%dn", mysql->port);
  499.       status=mysql_stat(mysql);
  500.       {
  501. char *pos,buff[40];
  502. ulong sec;
  503. pos=strchr(status,' ');
  504. *pos++=0;
  505. printf("%sttt",status); /* print label */
  506. if ((status=str2int(pos,10,0,LONG_MAX,(long*) &sec)))
  507. {
  508.   nice_time(sec,buff);
  509.   puts(buff); /* print nice time */
  510.   while (*status == ' ') status++; /* to next info */
  511. }
  512.       }
  513.       putc('n',stdout);
  514.       if (status)
  515. puts(status);
  516.       break;
  517.     case ADMIN_PROCESSLIST:
  518.     {
  519.       MYSQL_RES *result;
  520.       MYSQL_ROW row;
  522.       if (mysql_query(mysql, (opt_verbose ? "show full processlist" :
  523.       "show processlist")) ||
  524.   !(result = mysql_store_result(mysql)))
  525.       {
  526. my_printf_error(0,"process list failed; error: '%s'",MYF(ME_BELL),
  527. mysql_error(mysql));
  528. return 1;
  529.       }
  530.       print_header(result);
  531.       while ((row=mysql_fetch_row(result)))
  532. print_row(result,row,0);
  533.       print_top(result);
  534.       mysql_free_result(result);
  535.       new_line=1;
  536.       break;
  537.     }
  538.     case ADMIN_STATUS:
  539.       status=mysql_stat(mysql);
  540.       if (status)
  541. puts(status);
  542.       break;
  543.     case ADMIN_KILL:
  544.       {
  545. uint error=0;
  546. char *pos;
  547. if (argc < 2)
  548. {
  549.   my_printf_error(0,"Too few arguments to 'kill'",MYF(ME_BELL));
  550.   return 1;
  551. }
  552. pos=argv[1];
  553. for (;;)
  554. {
  555.   if (mysql_kill(mysql,(ulong) atol(pos)))
  556.   {
  557.     my_printf_error(0,"kill failed on %ld; error: '%s'",MYF(ME_BELL),
  558.     atol(pos), mysql_error(mysql));
  559.     error=1;
  560.   }
  561.   if (!(pos=strchr(pos,',')))
  562.     break;
  563.   pos++;
  564. }
  565. argc--; argv++;
  566. if (error)
  567.   return error;
  568. break;
  569.       }
  570.     case ADMIN_DEBUG:
  571.       if (mysql_dump_debug_info(mysql))
  572.       {
  573. my_printf_error(0,"debug failed; error: '%s'",MYF(ME_BELL),
  574. mysql_error(mysql));
  575. return 1;
  576.       }
  577.       break;
  578.     case ADMIN_VARIABLES:
  579.     {
  580.       MYSQL_RES *res;
  581.       MYSQL_ROW row;
  583.       new_line=1;
  584.       if (mysql_query(mysql,"show variables") ||
  585.   !(res=mysql_store_result(mysql)))
  586.       {
  587. my_printf_error(0,"unable to show variables; error: '%s'",MYF(ME_BELL),
  588. mysql_error(mysql));
  589. return 1;
  590.       }
  591.       print_header(res);
  592.       while ((row=mysql_fetch_row(res)))
  593. print_row(res,row,0);
  594.       print_top(res);
  595.       mysql_free_result(res);
  596.       break;
  597.     }
  598.     case ADMIN_EXTENDED_STATUS:
  599.     {
  600.       MYSQL_RES *res;
  601.       MYSQL_ROW row;
  602.       uint rownr = 0;
  603.       void (*func) (MYSQL_RES*, MYSQL_ROW, uint); 
  605.       new_line = 1;
  606.       if (mysql_query(mysql, "show status") ||
  607.   !(res = mysql_store_result(mysql)))
  608.       {
  609. my_printf_error(0, "unable to show status; error: '%s'", MYF(ME_BELL),
  610. mysql_error(mysql));
  611. return 1;
  612.       }
  613.       if (!opt_vertical)
  614. print_header(res);
  615.       else
  616.       {
  617. if (!ex_status_printed)
  618. {
  619.   store_values(res);
  620.   truncate_names();   /* Does some printing also */
  621. }
  622. else
  623. {
  624.   print_relative_line();
  625.   print_relative_header();
  626.   print_relative_line();
  627. }
  628.       }
  630.       /*      void (*func) (MYSQL_RES*, MYSQL_ROW, uint); */
  631.       if (opt_relative && !opt_vertical)
  632. func = print_relative_row;
  633.       else if (opt_vertical)
  634. func = print_relative_row_vert;
  635.       else
  636. func = print_row;
  638.       while ((row = mysql_fetch_row(res)))
  639. (*func)(res, row, rownr++);
  640.       if (opt_vertical)
  641.       {
  642. if (ex_status_printed)
  643. {
  644.   putchar('n');
  645.   print_relative_line();
  646. }
  647.       }
  648.       else
  649. print_top(res);
  651.       ex_status_printed = 1; /* From now on the output will be relative */
  652.       mysql_free_result(res);
  653.       break;
  654.     }
  655.     case ADMIN_FLUSH_LOGS:
  656.     {
  657.       if (mysql_refresh(mysql,REFRESH_LOG))
  658.       {
  659. my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL),
  660. mysql_error(mysql));
  661. return 1;
  662.       }
  663.       break;
  664.     }
  665.     case ADMIN_FLUSH_HOSTS:
  666.     {
  667.       if (mysql_refresh(mysql,REFRESH_HOSTS))
  668.       {
  669. my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL),
  670. mysql_error(mysql));
  671. return 1;
  672.       }
  673.       break;
  674.     }
  675.     case ADMIN_FLUSH_TABLES:
  676.     {
  677.       if (mysql_refresh(mysql,REFRESH_TABLES))
  678.       {
  679. my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL),
  680. mysql_error(mysql));
  681. return 1;
  682.       }
  683.       break;
  684.     }
  685.     case ADMIN_FLUSH_STATUS:
  686.     {
  687.       if (mysql_refresh(mysql,REFRESH_STATUS))
  688.       {
  689. my_printf_error(0,"refresh failed; error: '%s'",MYF(ME_BELL),
  690. mysql_error(mysql));
  691. return 1;
  692.       }
  693.       break;
  694.     }
  695.     case ADMIN_PASSWORD:
  696.     {
  697.       char buff[128],crypted_pw[33];
  699.       if(argc < 2)
  700.       {
  701. my_printf_error(0,"Too few arguments to change password",MYF(ME_BELL));
  702. return 1;
  703.       }
  704.       if (argv[1][0])
  705. make_scrambled_password(crypted_pw,argv[1]);
  706.       else
  707. crypted_pw[0]=0; /* No password */
  708.       sprintf(buff,"set password='%s',sql_log_off=0",crypted_pw);
  710.       if (mysql_query(mysql,"set sql_log_off=1"))
  711.       {
  712. my_printf_error(0, "Can't turn off logging; error: '%s'",
  713. MYF(ME_BELL),mysql_error(mysql));
  714. return 1;
  715.       }
  716.       if (mysql_query(mysql,buff))
  717.       {
  718. my_printf_error(0,"unable to change password; error: '%s'",
  719. MYF(ME_BELL),mysql_error(mysql));
  720. return 1;
  721.       }
  722.       argc--; argv++;
  723.       break;
  724.     }
  726.     case ADMIN_START_SLAVE:
  727.       if (mysql_query(mysql, "SLAVE START"))
  728.       {
  729. my_printf_error(0, "Error starting slave: %s", MYF(ME_BELL),
  730. mysql_error(mysql));
  731. return 1;
  732.       }
  733.       else
  734. puts("Slave started");
  735.       break;
  736.     case ADMIN_STOP_SLAVE:
  737.       if (mysql_query(mysql, "SLAVE STOP"))
  738.       {
  739.   my_printf_error(0, "Error stopping slave: %s", MYF(ME_BELL),
  740.   mysql_error(mysql));
  741.   return 1;
  742.       }
  743.       else
  744. puts("Slave stopped");
  745.       break;
  746.       
  747.     case ADMIN_PING:
  748.       mysql->reconnect=0; /* We want to know of reconnects */
  749.       if (!mysql_ping(mysql))
  750.       {
  751. if (option_silent < 2)
  752.   puts("mysqld is alive");
  753.       }
  754.       else
  755.       {
  756. if (mysql_errno(mysql) == CR_SERVER_GONE_ERROR)
  757. {
  758.   mysql->reconnect=1;
  759.   if (!mysql_ping(mysql))
  760.     puts("connection was down, but mysqld is now alive");
  761. }
  762. else
  763. {
  764.   my_printf_error(0,"mysqld doesn't answer to ping, error: '%s'",
  765.   MYF(ME_BELL),mysql_error(mysql));
  766.   return 1;
  767. }
  768.       }
  769.       mysql->reconnect=1; /* Automatic reconnect is default */
  770.       break;
  771.     default:
  772.       my_printf_error(0,"Unknown command: '%-.60s'",MYF(ME_BELL),argv[0]);
  773.       return 1;
  774.     }
  775.   }
  776.   return 0;
  777. }
  780. static void print_version(void)
  781. {
  782.   printf("%s  Ver %s Distrib %s, for %s on %sn",my_progname,ADMIN_VERSION,
  783.  MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
  784. }
  787. static void usage(void)
  788. {
  789.   uint i;
  790.   print_version();
  791.   puts("Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB");
  792.   puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,nand you are welcome to modify and redistribute it under the GPL licensen");
  793.   puts("Administration program for the mysqld daemon.");
  794.   printf("Usage: %s [OPTIONS] command command....n", my_progname);
  795.   printf("n
  796.   -#, --debug=...       Output debug log. Often this is 'd:t:o,filename`n
  797.   -f, --force Don't ask for confirmation on drop database; withn
  798. multiple commands, continue even if an error occursn
  799.   -?, --help Display this help and exitn
  800.   --character-sets-dir=...n
  801.                         Set the character set directoryn
  802.   -C, --compress        Use compression in server/client protocoln
  803.   -h, --host=# Connect to hostn
  804.   -p, --password[=...] Password to use when connecting to servern
  805. If password is not given it's asked from the ttyn");
  806. #ifdef __WIN__
  807.   puts("-W, --pipe Use named pipes to connect to server");
  808. #endif
  809.   printf("
  810.   -P  --port=... Port number to use for connectionn
  811.   -i, --sleep=sec Execute commands again and again with a sleep betweenn
  812.   -r, --relative        Show difference between current and previous valuesn
  813.                         when used with -i. Currently works only withn
  814.                         extended-statusn
  815.   -E, --vertical        Print output vertically. Is similar to --relative,n
  816.                         but prints output vertically.n
  817.   -s, --silent Silently exit if one can't connect to servern
  818.   -S, --socket=... Socket file to use for connectionn");
  819. #include "sslopt-usage.h"
  820.   printf("
  821.   -t, --timeout=... Timeout for connection to the mysqld servern");
  822. #ifndef DONT_ALLOW_USER_CHANGE
  823.   printf("
  824.   -u, --user=# User for login if not current usern");
  825. #endif
  826.   printf("
  827.   -v, --verbose         Write more informationn
  828.   -V, --version Output version information and exitn
  829.   -w, --wait[=retries]  Wait and retry if connection is downn");
  830.   print_defaults("my",load_default_groups);
  831.   printf("nPossible variables for option --set-variable (-O) are:n");
  832.   for (i=0 ; changeable_vars[i].name ; i++)
  833.     printf("%-20s  current value: %lun",
  834.    changeable_vars[i].name,
  835.    (ulong) *changeable_vars[i].varptr);
  837.   puts("nWhere command is a one or more of: (Commands may be shortened)n
  838.   create databasename Create a new databasen
  839.   drop databasename Delete a database and all its tablesn
  840.   extended-status       Gives an extended status message from the servern
  841.   flush-hosts           Flush all cached hostsn
  842.   flush-logs            Flush all logsn
  843.   flush-status Clear status variablesn
  844.   flush-tables          Flush all tablesn
  845.   flush-threads         Flush the thread cachen
  846.   flush-privileges      Reload grant tables (same as reload)n
  847.   kill id,id,... Kill mysql threads");
  848. #if MYSQL_VERSION_ID >= 32200
  849.   puts("
  850.   password new-password Change old password to new-password");
  851. #endif
  852.   puts("
  853.   ping Check if mysqld is aliven
  854.   processlist Show list of active threads in servern
  855.   reload Reload grant tablesn
  856.   refresh Flush all tables and close and open logfilesn
  857.   shutdown Take server downn
  858.   status Gives a short status message from the servern
  859.   start-slave Start slaven
  860.   stop-slave Stop slaven
  861.   variables             Prints variables availablen
  862.   version Get version info from server");
  863. }
  865. static int drop_db(MYSQL *mysql, const char *db)
  866. {
  867.   char name_buff[FN_REFLEN+20], buf[10];
  868.   if (!option_force)
  869.   {
  870.     puts("Dropping the database is potentially a very bad thing to do.");
  871.     puts("Any data stored in the database will be destroyed.n");
  872.     printf("Do you really want to drop the '%s' database [y/N]n",db);
  873.     VOID(fgets(buf,sizeof(buf)-1,stdin));
  874.     if ((*buf != 'y') && (*buf != 'Y'))
  875.     {
  876.       puts("nOK, aborting database drop!");
  877.       return -1;
  878.     }
  879.   }
  880.   sprintf(name_buff,"drop database %.*s",FN_REFLEN,db);
  881.   if (mysql_query(mysql,name_buff))
  882.   {
  883.     my_printf_error(0,"drop of '%s' failed;nerror: '%s'",MYF(ME_BELL),
  884.     db,mysql_error(mysql));
  885.     return 1;
  886.   }
  887.   printf("Database "%s" droppedn",db);
  888.   return 0;
  889. }
  892. static void nice_time(ulong sec,char *buff)
  893. {
  894.   ulong tmp;
  896.   if (sec >= 3600L*24)
  897.   {
  898.     tmp=sec/(3600L*24);
  899.     sec-=3600L*24*tmp;
  900.     buff=int2str(tmp,buff,10);
  901.     buff=strmov(buff,tmp > 1 ? " days " : " day ");
  902.   }
  903.   if (sec >= 3600L)
  904.   {
  905.     tmp=sec/3600L;
  906.     sec-=3600L*tmp;
  907.     buff=int2str(tmp,buff,10);
  908.     buff=strmov(buff,tmp > 1 ? " hours " : " hour ");
  909.   }
  910.   if (sec >= 60)
  911.   {
  912.     tmp=sec/60;
  913.     sec-=60*tmp;
  914.     buff=int2str(tmp,buff,10);
  915.     buff=strmov(buff," min ");
  916.   }
  917.   strmov(int2str(sec,buff,10)," sec");
  918. }
  921. static void print_header(MYSQL_RES *result)
  922. {
  923.   MYSQL_FIELD *field;
  925.   print_top(result);
  926.   mysql_field_seek(result,0);
  927.   putchar('|');
  928.   while ((field = mysql_fetch_field(result)))
  929.   {
  930.     printf(" %-*s|",field->max_length+1,field->name);
  931.   }
  932.   putchar('n');
  933.   print_top(result);
  934. }
  937. static void print_top(MYSQL_RES *result)
  938. {
  939.   uint i,length;
  940.   MYSQL_FIELD *field;
  942.   putchar('+');
  943.   mysql_field_seek(result,0);
  944.   while((field = mysql_fetch_field(result)))
  945.   {
  946.     if ((length=(uint) strlen(field->name)) > field->max_length)
  947.       field->max_length=length;
  948.     else
  949.       length=field->max_length;
  950.     for (i=length+2 ; i--> 0 ; )
  951.       putchar('-');
  952.     putchar('+');
  953.   }
  954.   putchar('n');
  955. }
  958. /* 3.rd argument, uint row, is not in use. Don't remove! */
  959. static void print_row(MYSQL_RES *result, MYSQL_ROW cur,
  960.       uint row __attribute__((unused)))
  961. {
  962.   uint i,length;
  963.   MYSQL_FIELD *field;
  965.   putchar('|');
  966.   mysql_field_seek(result,0);
  967.   for (i=0 ; i < mysql_num_fields(result); i++)
  968.   {
  969.     field = mysql_fetch_field(result);
  970.     length=field->max_length;
  971.     printf(" %-*s|",length+1,cur[i] ? (char*) cur[i] : "");
  972.   }
  973.   putchar('n');
  974. }
  977. static void print_relative_row(MYSQL_RES *result, MYSQL_ROW cur, uint row)
  978. {
  979.   ulonglong tmp;
  980.   char buff[22];
  981.   MYSQL_FIELD *field;
  983.   mysql_field_seek(result, 0);
  984.   field = mysql_fetch_field(result);
  985.   printf("| %-*s|", field->max_length + 1, cur[0]);
  987.   field = mysql_fetch_field(result);
  988.   tmp = cur[1] ? strtoull(cur[1], NULL, 0) : (ulonglong) 0;
  989.   printf(" %-*s|n", field->max_length + 1,
  990.  llstr((tmp - last_values[row]), buff));
  991.   last_values[row] = tmp;
  992. }
  995. static void print_relative_row_vert(MYSQL_RES *result __attribute__((unused)),
  996.     MYSQL_ROW cur,
  997.     uint row __attribute__((unused)))
  998. {
  999.   uint length;
  1000.   ulonglong tmp;
  1001.   char buff[22];
  1002.   
  1003.   if (!row)
  1004.     putchar('|');
  1006.   tmp = cur[1] ? strtoull(cur[1], NULL, 0) : (ulonglong) 0;
  1007.   printf(" %-*s|", ex_val_max_len[row] + 1, 
  1008.  llstr((tmp - last_values[row]), buff));
  1010.   /* Find the minimum row length needed to output the relative value */
  1011.   if ((length=(uint) strlen(buff) > ex_val_max_len[row]) && ex_status_printed)
  1012.     ex_val_max_len[row] = length;
  1013.   last_values[row] = tmp;
  1014. }
  1017. static void store_values(MYSQL_RES *result)
  1018. {
  1019.   uint i;
  1020.   MYSQL_ROW row;
  1021.   MYSQL_FIELD *field;
  1023.   field = mysql_fetch_field(result);
  1024.   max_var_length = field->max_length;
  1025.   field = mysql_fetch_field(result);
  1026.   max_val_length = field->max_length;
  1028.   for (i = 0; (row = mysql_fetch_row(result)); i++)
  1029.   {
  1030.     strmov(ex_var_names[i], row[0]);
  1031.     last_values[i]=strtoull(row[1],NULL,10);
  1032.     ex_val_max_len[i]=2; /* Default print width for values */
  1033.   }
  1034.   ex_var_count = i;
  1035.   return;
  1036. }
  1039. static void print_relative_header()
  1040. {
  1041.   uint i;
  1043.   putchar('|');
  1044.   for (i = 0; i < ex_var_count; i++)
  1045.     printf(" %-*s|", ex_val_max_len[i] + 1, truncated_var_names[i]);
  1046.   putchar('n');
  1047. }
  1050. static void print_relative_line()
  1051. {
  1052.   uint i;
  1054.   putchar('+');
  1055.   for (i = 0; i < ex_var_count; i++)
  1056.   {
  1057.     uint j;
  1058.     for (j = 0; j < ex_val_max_len[i] + 2; j++)
  1059.       putchar('-');
  1060.     putchar('+');
  1061.   }
  1062.   putchar('n');
  1063. }
  1066. static void truncate_names()
  1067. {
  1068.   uint i;
  1069.   char *ptr,top_line[MAX_TRUNC_LENGTH+4+NAME_LEN+22+1],buff[22];
  1071.   ptr=top_line;
  1072.   *ptr++='+';
  1073.   ptr=strfill(ptr,max_var_length+2,'-');
  1074.   *ptr++='+';
  1075.   ptr=strfill(ptr,MAX_TRUNC_LENGTH+2,'-');
  1076.   *ptr++='+';
  1077.   ptr=strfill(ptr,max_val_length+2,'-');
  1078.   *ptr++='+';
  1079.   *ptr=0;
  1080.   puts(top_line);
  1081.   
  1082.   for (i = 0 ; i < ex_var_count; i++)
  1083.   {
  1084.     uint sfx=1,j;
  1085.     printf("| %-*s|", max_var_length + 1, ex_var_names[i]);
  1086.     ptr = ex_var_names[i];
  1087.     /* Make sure no two same truncated names will become */
  1088.     for (j = 0; j < i; j++)
  1089.       if (*truncated_var_names[j] == *ptr)
  1090. sfx++;
  1092.     truncated_var_names[i][0]= *ptr; /* Copy first var char */
  1093.     int10_to_str(sfx, truncated_var_names[i]+1,10);
  1094.     printf(" %-*s|", MAX_TRUNC_LENGTH + 1, truncated_var_names[i]);
  1095.     printf(" %-*s|n", max_val_length + 1, llstr(last_values[i],buff));
  1096.   }
  1097.   puts(top_line);
  1098.   return;
  1099. }
  1102. static my_bool get_pidfile(MYSQL *mysql, char *pidfile)
  1103. {
  1104.   MYSQL_RES* result;
  1106.   if (mysql_query(mysql, "SHOW VARIABLES LIKE 'pid_file'"))
  1107.   {
  1108.     my_printf_error(0,"query failed; error: '%s'",MYF(ME_BELL),
  1109.     mysql_error(mysql));
  1110.   }
  1111.   result = mysql_store_result(mysql);
  1112.   if (result)
  1113.   {
  1114.     MYSQL_ROW row=mysql_fetch_row(result);
  1115.     if (row)
  1116.       strmov(pidfile, row[1]);
  1117.     mysql_free_result(result);
  1118.     return row == 0; /* Error if row = 0 */
  1119.   }
  1120.   return 1; /* Error */
  1121. }
  1124. static void wait_pidfile(char *pidfile)
  1125. {
  1126.   char buff[FN_REFLEN];
  1127.   int fd;
  1128.   uint count=0;
  1130.   system_filename(buff,pidfile);
  1131.   while ((fd = open(buff, O_RDONLY)) >= 0 && count++ < opt_shutdown_timeout)
  1132.   {
  1133.     close(fd);
  1134.     sleep(1);
  1135.   }
  1136.   if (fd >= 0)
  1137.   {
  1138.     close(fd);
  1139.     fprintf(stderr,
  1140.     "Warning;  Aborted waiting on pid file: '%s' after %d secondsn",
  1141.     buff, count-1);
  1142.   }
  1143. }