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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mysqlmanager.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：44k
源码类别：

MySQL数据库

开发平台：

Visual C++

mysqlmanager.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  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.
  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.
  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. /*
  18.   MySQL server management daemon
  20.   Written by:
  21.     Sasha Pachev <sasha@mysql.com>
  22. */
  24. #ifndef __NETWARE__
  26. #include <my_global.h>
  27. #include <my_pthread.h>
  28. #include <mysql.h>
  29. #include <mysql_version.h>
  30. #include <mysqld_error.h>
  31. #include <my_sys.h>
  32. #include <my_dir.h>
  33. #include <m_string.h>
  34. #include <m_ctype.h>
  35. #include <hash.h>
  36. #include <my_getopt.h>
  37. #include <stdarg.h>
  38. #include <sys/stat.h>
  39. #include <errno.h>
  40. #include <violite.h>
  41. #include <md5.h>
  42. #include <signal.h>
  43. #ifdef HAVE_SYS_WAIT_H
  44. #include <sys/wait.h>
  45. #endif
  47. #define MANAGER_VERSION "1.2"
  48. #define MANAGER_GREETING "MySQL Server Management Daemon v. 1.2" 
  50. #define LOG_ERR  1
  51. #define LOG_WARN 2
  52. #define LOG_INFO 3
  53. #define LOG_DEBUG 4
  55. #define CHILD_START 1
  56. #define CHILD_STOP  2
  58. #ifndef MANAGER_PORT
  59. #define MANAGER_PORT  23546
  60. #endif
  62. #ifndef MANAGER_CONNECT_RETRIES
  63. #define MANAGER_CONNECT_RETRIES 5
  64. #endif
  66. #ifndef MANAGER_MAX_CMD_LEN
  67. #define MANAGER_MAX_CMD_LEN 16384
  68. #endif
  70. #ifndef MANAGER_LOG_FILE
  71. #define MANAGER_LOG_FILE "/var/log/mysqlmanager.log"
  72. #endif
  74. #ifndef MANAGER_BACK_LOG
  75. #define MANAGER_BACK_LOG 50
  76. #endif
  78. #ifndef MAX_USER_NAME
  79. #define MAX_USER_NAME 16
  80. #endif
  82. #ifndef MANAGER_PW_FILE
  83. #define MANAGER_PW_FILE "/etc/mysqlmanager.passwd"
  84. #endif
  86. #ifndef MAX_HOST
  87. #define MAX_HOST 128
  88. #endif
  90. #ifndef MAX_LAUNCHER_MSG
  91. #define MAX_LAUNCHER_MSG 256
  92. #endif
  94. static CHARSET_INFO *cs= &my_charset_latin1;
  96. #define MAX_RETRY_COUNT 100
  98. /*
  99.   Variable naming convention - if starts with manager_, either is set
  100.   directly by the user, or used closely in ocnjunction with a variable
  101.   set by the user
  102. */
  104. #if defined(__i386__) && defined(TARGET_OS_LINUX)
  105. #define DO_STACKTRACE 1
  106. #endif
  108. uint manager_port;
  109. FILE* errfp;
  110. const char* manager_log_file = MANAGER_LOG_FILE;
  111. pthread_mutex_t lock_log,lock_shutdown,lock_exec_hash,lock_launch_thd;
  112. pthread_cond_t cond_launch_thd;
  113. pthread_t loop_th,launch_msg_th;
  114. int manager_sock = -1;
  115. uchar* stack_bottom=0;
  116. struct sockaddr_in manager_addr;
  117. ulong manager_bind_addr;
  118. int manager_back_log;
  119. int in_shutdown = 0, shutdown_requested=0;
  120. int manager_connect_retries;
  121. const char* manager_greeting = MANAGER_GREETING;
  122. uint manager_max_cmd_len;
  123. const char* manager_pw_file=MANAGER_PW_FILE;
  124. my_bool one_thread; /* for debugging */
  126. typedef enum {PARAM_STDOUT,PARAM_STDERR} PARAM_TYPE;
  128. /* messages */
  130. #define MAX_CLIENT_MSG_LEN  256
  131. #define NET_BLOCK    2048
  132. #define MD5_LEN      16
  133. #define ESCAPE_CHAR '\'
  134. #define EOL_CHAR 'n'
  136. /* access flags */
  138. #define PRIV_SHUTDOWN 1
  140. struct manager_thd
  141. {
  142.   NET net;
  143.   char user[MAX_USER_NAME+1];
  144.   int priv_flags;
  145.   char* cmd_buf;
  146.   int fatal,finished;
  147. };
  149. struct manager_user
  150. {
  151.   char user[MAX_USER_NAME+1];
  152.   char md5_pass[MD5_LEN];
  153.   int user_len;
  154.   const char* error;
  155. };
  157. HASH exec_hash,user_hash;
  158. struct manager_exec* cur_launch_exec=0;
  160. static struct manager_thd* manager_thd_new(Vio* vio);
  162. static struct manager_exec* manager_exec_new(char* arg_start,char* arg_end);
  163. static void manager_exec_print(NET* net,struct manager_exec* e);
  164. static void manager_thd_free(struct manager_thd* thd);
  165. static void manager_exec_free(void* e);
  166. static void manager_exec_connect(struct manager_exec* e);
  167. static int manager_exec_launch(struct manager_exec* e);
  168. static struct manager_exec* manager_exec_by_pid(pid_t pid);
  170. static struct manager_user* manager_user_new(char* buf);
  171. static void manager_user_free(void* u);
  173. static char* arg_strmov(char* dest, const char* src, int n);
  174. static byte* get_exec_key(const byte* e, uint* len,
  175.   my_bool __attribute__((unused)) t);
  176. static byte* get_user_key(const byte* u, uint* len,
  177.   my_bool __attribute__((unused)) t);
  178. static uint tokenize_args(char* arg_start,char** arg_end);
  179. static void init_arg_array(char* arg_str,char** args,uint arg_count);
  180. static int hex_val(char c);
  181. static int open_and_dup(int fd,char* path);
  182. static void update_req_len(struct manager_exec* e);
  184. typedef int (*manager_cmd_handler)(struct manager_thd*,char*,char*);
  186. static void handle_child(int __attribute__((unused)) sig);
  187. static void handle_sigpipe(int __attribute__((unused)) sig);
  189. /*
  190.   exec() in a threaded application is full of problems.
  191.   To solve this, we fork off a launcher at the very start
  192.   and communicate with it through a pipe
  193. */
  195. static void fork_launcher();
  196. static void run_launcher_loop();
  197. int to_launcher_pipe[2],from_launcher_pipe[2];
  198. pid_t launcher_pid;
  199. int in_segfault=0;
  200. const char* pid_file = "/var/run/mysqlmanager.pid";
  201. int created_pid_file = 0;
  203. struct manager_cmd
  204. {
  205.   const char* name;
  206.   const char* help;
  207.   manager_cmd_handler handler_func;
  208.   int len;
  209. };
  211. struct manager_exec
  212. {
  213.   char* ident;
  214.   int ident_len;
  215.   const char* error;
  216.   char* bin_path;
  217.   char** args;
  218.   char con_user[16];
  219.   char con_pass[16];
  220.   int con_port;
  221.   pid_t pid;
  222.   int exit_code;
  223.   pthread_mutex_t lock;
  224.   pthread_cond_t cond;
  225.   pthread_t th;
  226.   char con_sock[FN_REFLEN];
  227.   char con_host[MAX_HOST];
  228.   char stderr_path[FN_REFLEN];
  229.   char stdout_path[FN_REFLEN];
  230.   MYSQL mysql;
  231.   char* data_buf;
  232.   int req_len;
  233.   int start_wait_timeout;
  234.   int stderr_path_size,stdout_path_size,data_buf_size;
  235.   int num_args;
  236. };
  238. static int set_exec_param(struct manager_thd* thd, char* args_start,
  239.   char* args_end, PARAM_TYPE param_type);
  241. #define HANDLE_DECL(com) 
  242. static int com(struct manager_thd* thd, char* args_start,char* args_end)
  243. #define HANDLE_NOARG_DECL(com) 
  244. static int com(struct manager_thd *thd,
  245.                char *args_start __attribute__((unused)),
  246.                char* args_end __attribute__((unused)))
  248. HANDLE_NOARG_DECL(handle_ping);
  249. HANDLE_NOARG_DECL(handle_quit);
  250. HANDLE_NOARG_DECL(handle_help);
  251. HANDLE_NOARG_DECL(handle_shutdown);
  252. HANDLE_DECL(handle_def_exec);
  253. HANDLE_DECL(handle_start_exec);
  254. HANDLE_DECL(handle_stop_exec);
  255. HANDLE_DECL(handle_set_exec_con);
  256. HANDLE_DECL(handle_set_exec_stdout);
  257. HANDLE_DECL(handle_set_exec_stderr);
  258. HANDLE_NOARG_DECL(handle_show_exec);
  259. HANDLE_DECL(handle_query);
  262. struct manager_cmd commands[] =
  263. {
  264.   {"ping", "Check if this server is alive", handle_ping,4},
  265.   {"quit", "Finish session", handle_quit,4},
  266.   {"shutdown", "Shutdown this server", handle_shutdown,8},
  267.   {"def_exec", "Define executable entry", handle_def_exec,8},
  268.   {"start_exec", "Launch process defined by executable entry",
  269.    handle_start_exec,10},
  270.   {"stop_exec", "Stop process defined by executable entry",
  271.    handle_stop_exec,9},
  272.   {"set_exec_con", "Set connection parameters for executable entry",
  273.    handle_set_exec_con,12},
  274.   {"set_exec_stdout", "Set stdout path for executable entry",
  275.    handle_set_exec_stdout,15},
  276.   {"set_exec_stderr", "Set stderr path for executable entry",
  277.    handle_set_exec_stderr,15},
  278.   {"query","Run query against MySQL server",handle_query,5},
  279.   {"show_exec","Show defined executable entries",handle_show_exec,9},
  280.   {"help", "Print this message", handle_help,4},
  281.   {0,0,0,0}
  282. };
  285. static struct my_option my_long_options[] =
  286. {
  287. #ifndef DBUG_OFF
  288.   {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
  289.    0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  290. #endif
  291.   {"help", '?', "Display this help and exit.",
  292.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  293.   {"port", 'P', "Port number to listen on.", (gptr*) &manager_port,
  294.    (gptr*) &manager_port, 0, GET_UINT, REQUIRED_ARG, MANAGER_PORT, 0, 0, 0,
  295.    0, 0},
  296.   {"log", 'l', "Path to log file.", (gptr*) &manager_log_file,
  297.    (gptr*) &manager_log_file, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  298.   {"bind-address", 'b', "Address to listen on.", (gptr*) &manager_bind_addr,
  299.    (gptr*) &manager_bind_addr, 0, GET_ULONG, REQUIRED_ARG, INADDR_ANY, 0,
  300.    0, 0, 0, 0},
  301.   {"tcp-backlog", 'B', "Size of TCP/IP listen queue.",
  302.    (gptr*) &manager_back_log, (gptr*) &manager_back_log, 0, GET_INT,
  303.    REQUIRED_ARG, MANAGER_BACK_LOG, 0, 0, 0, 0, 0},
  304.   {"greeting", 'g', "Set greeting on connect.", (gptr*) &manager_greeting,
  305.    (gptr*) &manager_greeting, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  306.   {"max-command-len", 'm', "Maximum command length.",
  307.    (gptr*) &manager_max_cmd_len, (gptr*) &manager_max_cmd_len, 0, GET_UINT,
  308.    REQUIRED_ARG, MANAGER_MAX_CMD_LEN, 0, 0, 0, 0, 0},
  309.   {"one-thread", 'd', "Use one thread ( for debugging).", (gptr*) &one_thread,
  310.    (gptr*) &one_thread, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  311.   {"connect-retries", 'C', "Number of attempts to establish MySQL connection.",
  312.    (gptr*) &manager_connect_retries, (gptr*) &manager_connect_retries, 0,
  313.    GET_INT, REQUIRED_ARG, MANAGER_CONNECT_RETRIES, 0, 0, 0, 0, 0},
  314.   {"password-file", 'p', "Password file for manager.",
  315.    (gptr*) &manager_pw_file, (gptr*) &manager_pw_file, 0, GET_STR,
  316.    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  317.   {"pid-file", 'f', "Pid file to use.", (gptr*) &pid_file, (gptr*) &pid_file,
  318.    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  319.   {"version", 'V', "Output version information and exit.", 0, 0, 0,
  320.    GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  321.   { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
  322. };
  324. static void die(const char* fmt,...);
  325. static void print_time(FILE* fp);
  326. static void clean_up();
  327. static struct manager_cmd* lookup_cmd(char* s,int len);
  328. static int client_msg(NET* net,int err_code,const char* fmt,...);
  329. static int client_msg_pre(NET* net,int err_code,const char* fmt,...);
  330. static int client_msg_raw(NET* net,int err_code,int pre,const char* fmt,
  331.     va_list args);
  332. static int authenticate(struct manager_thd* thd);
  333. /* returns pointer to end of line */
  334. static char* read_line(struct manager_thd* thd);
  335. static pthread_handler_decl(process_connection, arg);
  336. static pthread_handler_decl(process_launcher_messages, arg);
  337. static int exec_line(struct manager_thd* thd,char* buf,char* buf_end);
  339. #ifdef DO_STACKTRACE
  340. void print_stacktrace();
  341. #endif
  343. static void log_msg(const char* fmt, int msg_type, va_list args);
  345. /* No 'inline' here becasue functions with ... can't do that portable */
  346. #define LOG_MSG_FUNC(type,TYPE) static void type  
  347.  (const char* fmt,...) { 
  348.   va_list args; 
  349.   va_start(args,fmt); 
  350.   log_msg(fmt,TYPE,args);
  351.  }
  353. LOG_MSG_FUNC(log_err,LOG_ERR)
  354. LOG_MSG_FUNC(log_warn,LOG_WARN)
  355. LOG_MSG_FUNC(log_info,LOG_INFO)
  357. #ifndef DBUG_OFF
  358. LOG_MSG_FUNC(log_debug,LOG_DEBUG)
  359. #else
  360. void log_debug(const char* fmt __attribute__((unused)),...) {}
  361. #endif
  363. static void handle_sigterm(int sig __attribute__((unused)))
  364. {
  365.   log_info("Got SIGTERM"); 
  366.   if (!one_thread)
  367.   {
  368.     kill(launcher_pid,SIGTERM);
  369.     pthread_kill(loop_th,SIGTERM);
  370.   }
  371.   clean_up();
  372.   exit(0);
  373. }
  375. #ifdef DO_STACKTRACE
  376. static void handle_segfault(int sig)
  377. {
  378.   if (in_segfault)
  379.     exit(1);
  380.   in_segfault=1;
  381.   fprintf(errfp,"Got fatal signal %dn",sig);
  382.   print_stacktrace();
  383.   exit(1);
  384. }
  385. #endif
  387. static void handle_sigpipe(int __attribute__((unused)) sig)
  388. {
  389.   signal(SIGPIPE,handle_sigpipe);
  390. }
  392. #ifdef DO_STACKTRACE
  394. #define MAX_DEPTH 25
  395. #define SIGRETURN_FRAME_COUNT 1
  397. void print_stacktrace()
  398. {
  399.   uchar** fp;
  400.   int i;
  401.   LINT_INIT(fp);
  402.   fprintf(errfp,"Fatal errror, stacktrace follows:n");
  403. #ifdef __i386__  
  404.   __asm__ __volatile__("movl %%ebp,%0" :"=r"(fp) :"r"(fp));
  405. #endif
  406.   if (!fp)
  407.   {
  408.     fprintf(errfp,"frame points is NULL, cannot trace stackn");
  409.     return;
  410.   }
  411.   for (i=0;i<MAX_DEPTH && fp<(uchar**)stack_bottom;i++)
  412.   {
  413. #ifdef __i386__    
  414.     uchar** new_fp = (uchar**)*fp;
  415.     fprintf(errfp, "%pn", i == SIGRETURN_FRAME_COUNT ?
  416.     *(fp+17) : *(fp+1));
  417. #endif /* __386__ */
  418.     if (new_fp <= fp )
  419.     {
  420.       fprintf(errfp, "New value of fp=%p failed sanity check,
  421.  terminating stack trace!n", new_fp);
  422.       return;
  423.     }
  424.     fp = new_fp;
  425.   }
  426.   fprintf(errfp,"Stack trace successfuln");
  427.   fflush(errfp);
  428. }
  429. #endif
  431. static int exec_line(struct manager_thd* thd,char* buf,char* buf_end)
  432. {
  433.   char* p=buf;
  434.   struct manager_cmd* cmd;
  435.   for (;p<buf_end && !my_isspace(cs,*p);p++)
  436.     *p=my_tolower(cs,*p);
  437.   log_info("Command '%s'", buf);
  438.   if (!(cmd=lookup_cmd(buf,(int)(p-buf))))
  439.   {
  440.     if (client_msg(&thd->net,MANAGER_CLIENT_ERR,
  441.    "Unrecognized command '%s', type help to see list of supported
  442.  commands", buf))
  443.       thd->fatal=1;
  444.     return 1;
  445.   }
  446.   for (;p<buf_end && my_isspace(cs,*p);p++);
  447.   return cmd->handler_func(thd,p,buf_end);
  448. }
  450. static struct manager_cmd* lookup_cmd(char* s,int len)
  451. {
  452.   struct manager_cmd* cmd = commands;
  453.   for (;cmd->name;cmd++)
  454.   {
  455.     if (cmd->len == len && !memcmp(cmd->name,s,len))
  456.       return cmd;
  457.   }
  458.   return 0;
  459. }
  461. HANDLE_NOARG_DECL(handle_ping)
  462. {
  463.   client_msg(&thd->net,MANAGER_OK,"Server management daemon is alive");
  464.   return 0;
  465. }
  467. HANDLE_NOARG_DECL(handle_quit)
  468. {
  469.   client_msg(&thd->net,MANAGER_OK,"Goodbye");
  470.   thd->finished=1;
  471.   return 0;
  472. }
  474. HANDLE_NOARG_DECL(handle_help)
  475. {
  476.   struct manager_cmd* cmd = commands;
  477.   NET* net = &thd->net;
  478.   client_msg_pre(net,MANAGER_INFO,"Available commands:");
  479.   for (;cmd->name;cmd++)
  480.   {
  481.     client_msg_pre(net,MANAGER_INFO,"%s - %s", cmd->name, cmd->help);
  482.   }
  483.   client_msg_pre(net,MANAGER_INFO,"End of help");
  484.   return 0;
  485. }
  487. HANDLE_NOARG_DECL(handle_shutdown)
  488. {
  489.   client_msg(&thd->net,MANAGER_OK,"Shutdown started, goodbye");
  490.   thd->finished=1;
  491.   shutdown_requested = 1;
  492.   if (!one_thread)
  493.   {
  494.     kill(launcher_pid,SIGTERM);
  495.     pthread_kill(loop_th,SIGTERM);
  496.   }
  497.   return 0;
  498. }
  500. HANDLE_DECL(handle_set_exec_con)
  501. {
  502.   int num_args;
  503.   const char* error=0;
  504.   struct manager_exec* e;
  505.   char* arg_p;
  506.   if ((num_args=tokenize_args(args_start,&args_end))<2)
  507.   {
  508.     error="Too few arguments";
  509.     goto err;
  510.   }
  511.   arg_p=args_start;
  512.   pthread_mutex_lock(&lock_exec_hash);
  513.   if (!(e=(struct manager_exec*)hash_search(&exec_hash,arg_p,
  514.     strlen(arg_p))))
  515.   {
  516.     pthread_mutex_unlock(&lock_exec_hash);
  517.     error="Exec definition entry does not exist";
  518.     goto err;
  519.   }
  520.   arg_p+=strlen(arg_p)+1;
  521.   arg_p+=(strnmov(e->con_user,arg_p,sizeof(e->con_user))-e->con_user)+1;
  522.   if (num_args >= 3)
  523.   {
  524.     arg_p+=(strnmov(e->con_host,arg_p,sizeof(e->con_host))-e->con_host)+1;
  525.     if (num_args == 4)
  526.     {
  527.       if (!(e->con_port=atoi(arg_p)))
  528. strnmov(e->con_sock,arg_p,sizeof(e->con_sock));
  529.       else
  530. e->con_sock[0]=0;
  531.     }
  532.     else if (num_args > 4)
  533.     {
  534.       pthread_mutex_unlock(&lock_exec_hash);
  535.       error="Too many arguments";
  536.       goto err;
  537.     }
  538.   }
  539.   pthread_mutex_unlock(&lock_exec_hash);
  540.   client_msg(&thd->net,MANAGER_OK,"Entry updated");
  541.   return 0;
  542. err:
  543.   client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
  544.   return 1;
  545. }
  547. HANDLE_DECL(handle_set_exec_stdout)
  548. {
  549.   return set_exec_param(thd,args_start,args_end,PARAM_STDOUT);
  550. }
  552. HANDLE_DECL(handle_set_exec_stderr)
  553. {
  554.   return set_exec_param(thd,args_start,args_end,PARAM_STDERR);
  555. }
  557. static int set_exec_param(struct manager_thd* thd, char* args_start,
  558.   char* args_end, PARAM_TYPE param_type)
  559. {
  560.   int num_args;
  561.   const char* error=0;
  562.   struct manager_exec* e;
  563.   char* arg_p;
  564.   char* param;
  565.   int param_size;
  567.   if ((num_args=tokenize_args(args_start,&args_end))<2)
  568.   {
  569.     error="Too few arguments";
  570.     goto err;
  571.   }
  572.   arg_p=args_start;
  573.   pthread_mutex_lock(&lock_exec_hash);
  574.   if (!(e=(struct manager_exec*)hash_search(&exec_hash,arg_p,
  575.     strlen(arg_p))))
  576.   {
  577.     pthread_mutex_unlock(&lock_exec_hash);
  578.     error="Exec definition entry does not exist";
  579.     goto err;
  580.   }
  581.   arg_p+=strlen(arg_p)+1;
  582.   param_size=strlen(arg_p)+1;
  583.   switch (param_type) {
  584.   case PARAM_STDOUT:
  585.     param=e->stdout_path;
  586.     e->req_len+=(param_size-e->stdout_path_size);
  587.     e->stdout_path_size=param_size;
  588.     break;
  589.   case PARAM_STDERR:
  590.     param=e->stderr_path;
  591.     e->req_len+=(param_size-e->stderr_path_size);
  592.     e->stderr_path_size=param_size;
  593.     break;
  594.   default:
  595.     error="Internal error";
  596.     goto err;
  597.   }
  598.   strnmov(param,arg_p,FN_REFLEN);
  599.   pthread_mutex_unlock(&lock_exec_hash);
  600.   client_msg(&thd->net,MANAGER_OK,"Entry updated");
  601.   return 0;
  602. err:
  603.   client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
  604.   return 1;
  605. }
  608. HANDLE_DECL(handle_start_exec)
  609. {
  610.   int num_args;
  611.   struct manager_exec* e;
  612.   int ident_len;
  613.   const char* error=0;
  614.   struct timespec t;
  615.   if ((num_args=tokenize_args(args_start,&args_end))<1)
  616.   {
  617.     error="Too few arguments";
  618.     goto err;
  619.   }
  620.   ident_len=strlen(args_start);
  621.   pthread_mutex_lock(&lock_exec_hash);
  622.   if (!(e=(struct manager_exec*)hash_search(&exec_hash,args_start,
  623.     ident_len)))
  624.   {
  625.     pthread_mutex_unlock(&lock_exec_hash);
  626.     error="Exec definition entry does not exist";
  627.     goto err;
  628.   }
  629.   pthread_mutex_unlock(&lock_exec_hash);
  630.   manager_exec_launch(e);
  631.   if ((error=e->error))
  632.     goto err;
  633.   pthread_mutex_lock(&e->lock);
  634.   t.tv_sec=time(0)+(e->start_wait_timeout=atoi(args_start+ident_len+1));
  635.   t.tv_nsec=0;
  636.   if (!e->pid)
  637.     pthread_cond_timedwait(&e->cond,&e->lock,&t);
  638.   if (!e->pid)
  639.   {
  640.     pthread_mutex_unlock(&e->lock);
  641.     error="Process failed to start withing alotted time";
  642.     goto err;
  643.   }
  644.   mysql_close(&e->mysql);
  645.   manager_exec_connect(e);
  646.   error=e->error;
  647.   pthread_mutex_unlock(&e->lock);
  648.   if (error)
  649.     goto err;
  650.   client_msg(&thd->net,MANAGER_OK,"'%s' started",e->ident);
  651.   return 0;
  652. err:
  653.   client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
  654.   return 1;
  655. }
  657. HANDLE_DECL(handle_stop_exec)
  658. {
  659.   int num_args;
  660.   struct timespec abstime;
  661.   struct manager_exec* e;
  662.   int ident_len;
  663.   const char* error=0;
  664.   if ((num_args=tokenize_args(args_start,&args_end))<2)
  665.   {
  666.     error="Too few arguments";
  667.     goto err;
  668.   }
  669.   ident_len=strlen(args_start);
  670.   abstime.tv_sec=time(0)+atoi(args_start+1+ident_len);
  671.   abstime.tv_nsec=0;
  672.   pthread_mutex_lock(&lock_exec_hash);
  673.   if (!(e=(struct manager_exec*)hash_search(&exec_hash,args_start,
  674.     ident_len)))
  675.   {
  676.     pthread_mutex_unlock(&lock_exec_hash);
  677.     error="Exec definition entry does not exist";
  678.     goto err;
  679.   }
  680.   pthread_mutex_unlock(&lock_exec_hash);
  681.   pthread_mutex_lock(&e->lock);
  682.   e->th=pthread_self();
  683.   if (!e->pid)
  684.   {
  685.     /* e->th=0; */ /* th may be a struct */
  686.     pthread_mutex_unlock(&e->lock);
  687.     error="Process not running";
  688.     goto err;
  689.   }
  690.   if (mysql_shutdown(&e->mysql, SHUTDOWN_DEFAULT))
  691.   {
  692.     /* e->th=0; */ /* th may be a struct */
  693.     pthread_mutex_unlock(&e->lock);
  694.     error="Could not send shutdown command";
  695.     goto err;
  696.   }
  697.   if (e->pid)
  698.     pthread_cond_timedwait(&e->cond,&e->lock,&abstime);
  699.   if (e->pid)
  700.     error="Process failed to terminate within alotted time";
  701.   /* e->th=0; */ /* th may be a struct */
  702.   pthread_mutex_unlock(&e->lock);
  703.   if (!error)
  704.   {
  705.     client_msg(&thd->net,MANAGER_OK,"'%s' terminated",e->ident);
  706.     return 0;
  707.   }
  708. err:
  709.   client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
  710.   return 1;
  711. }
  713. HANDLE_DECL(handle_query)
  714. {
  715.   const char* error=0;
  716.   struct manager_exec* e;
  717.   MYSQL_RES* res=0;
  718.   MYSQL_ROW row;
  719.   MYSQL_FIELD* fields;
  720.   int num_fields,i,ident_len;
  721.   char* ident,*query;
  722.   query=ident=args_start;
  723.   while (!my_isspace(cs,*query))
  724.     query++;
  725.   if (query == ident)
  726.   {
  727.     error="Missing server identifier";
  728.     goto err;
  729.   }
  730.   ident_len=(int)(query-ident);
  731.   while (query<args_end && my_isspace(cs,*query))
  732.     query++;
  733.   if (query == args_end)
  734.   {
  735.     error="Missing query";
  736.     goto err;
  737.   }
  738.   pthread_mutex_lock(&lock_exec_hash);
  739.   if (!(e=(struct manager_exec*)hash_search(&exec_hash,ident,
  740.     ident_len)))
  741.   {
  742.     pthread_mutex_unlock(&lock_exec_hash);
  743.     error="Exec definition entry does not exist";
  744.     goto err;
  745.   }
  746.   pthread_mutex_unlock(&lock_exec_hash);
  747.   pthread_mutex_lock(&e->lock);
  748.   if (!e->pid)
  749.   {
  750.     error="Process is not running";
  751.     pthread_mutex_unlock(&e->lock);
  752.     goto err;
  753.   }
  755.   if (mysql_query(&e->mysql,query))
  756.   {
  757.     error=mysql_error(&e->mysql);
  758.     pthread_mutex_unlock(&e->lock);
  759.     goto err;
  760.   }
  761.   if ((res=mysql_store_result(&e->mysql)))
  762.   {
  763.     char buf[MAX_CLIENT_MSG_LEN],*p,*buf_end;
  764.     fields=mysql_fetch_fields(res);
  765.     num_fields=mysql_num_fields(res);
  766.     p=buf;
  767.     buf_end=buf+sizeof(buf);
  768.     for (i=0;i<num_fields && p<buf_end-2;i++)
  769.     {
  770.       p=arg_strmov(p,fields[i].name,buf_end-p-2);
  771.       *p++='t';
  772.     }
  773.     *p=0;
  774.     client_msg_pre(&thd->net,MANAGER_OK,buf);
  776.     while ((row=mysql_fetch_row(res)))
  777.     {
  778.       p=buf;
  779.       for (i=0;i<num_fields && p<buf_end-2;i++)
  780.       {
  781. p=arg_strmov(p,row[i],buf_end-p-2);
  782. *p++='t';
  783.       }
  784.       *p=0;
  785.       client_msg_pre(&thd->net,MANAGER_OK,buf);
  786.     }
  787.   }
  788.   pthread_mutex_unlock(&e->lock);
  789.   client_msg(&thd->net,MANAGER_OK,"End");
  790.   return 0;
  791. err:
  792.   client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
  793.   return 1;
  794. }
  796. HANDLE_DECL(handle_def_exec)
  797. {
  798.   struct manager_exec* e=0,*old_e;
  799.   const char* error=0;
  800.   if (!(e=manager_exec_new(args_start,args_end)))
  801.   {
  802.     error="Out of memory";
  803.     goto err;
  804.   }
  805.   if (e->error)
  806.   {
  807.     error=e->error;
  808.     goto err;
  809.   }
  810.   pthread_mutex_lock(&lock_exec_hash);
  811.   if ((old_e=(struct manager_exec*)hash_search(&exec_hash,(byte*)e->ident,
  812.        e->ident_len)))
  813.   {
  814.     strnmov(e->stdout_path,old_e->stdout_path,sizeof(e->stdout_path));
  815.     strnmov(e->stderr_path,old_e->stderr_path,sizeof(e->stderr_path));
  816.     strnmov(e->con_user,old_e->con_user,sizeof(e->con_user));
  817.     strnmov(e->con_host,old_e->con_host,sizeof(e->con_host));
  818.     strnmov(e->con_sock,old_e->con_sock,sizeof(e->con_sock));
  819.     e->con_port=old_e->con_port;
  820.     update_req_len(e);
  821.     hash_delete(&exec_hash,(byte*)old_e);
  822.   }
  823.   my_hash_insert(&exec_hash,(byte*)e);
  824.   pthread_mutex_unlock(&lock_exec_hash);
  825.   client_msg(&thd->net,MANAGER_OK,"Exec definition created");
  826.   return 0;
  827. err:
  828.   client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
  829.   if (e)
  830.     manager_exec_free(e);
  831.   return 1;
  832. }
  834. HANDLE_NOARG_DECL(handle_show_exec)
  835. {
  836.   uint i;
  837.   client_msg_pre(&thd->net,MANAGER_INFO,"Exec_deftPidtExit_statustCon_info
  838. tStdouttStderrtArguments");
  839.   pthread_mutex_lock(&lock_exec_hash);
  840.   for (i=0;i<exec_hash.records;i++)
  841.   {
  842.     struct manager_exec* e=(struct manager_exec*)hash_element(&exec_hash,i);
  843.     manager_exec_print(&thd->net,e);
  844.   }
  845.   pthread_mutex_unlock(&lock_exec_hash);
  846.   client_msg(&thd->net,MANAGER_INFO,"End");
  847.   return 0;
  848. }
  850. static struct manager_exec* manager_exec_by_pid(pid_t pid)
  851. {
  852.   struct manager_exec* e;
  853.   uint i;
  854.   pthread_mutex_lock(&lock_exec_hash);
  855.   for (i=0;i<exec_hash.records;i++)
  856.   {
  857.     e=(struct manager_exec*)hash_element(&exec_hash,i);
  858.     if (e->pid==pid)
  859.     {
  860.       pthread_mutex_unlock(&lock_exec_hash);
  861.       return e;
  862.     }
  863.   }
  864.  pthread_mutex_unlock(&lock_exec_hash);
  865.  return 0;  
  866. }
  868. static void manager_exec_connect(struct manager_exec* e)
  869. {
  870.   int i;
  871.   int connect_retries;
  873.   if (!(connect_retries=e->start_wait_timeout))
  874.     connect_retries=manager_connect_retries;
  876.   for (i=0;i<connect_retries;i++)
  877.   {
  878.     if (mysql_real_connect(&e->mysql,e->con_host,e->con_user,e->con_pass,0,
  879.    e->con_port,e->con_sock,0))
  880.       return;
  881.     sleep(1);
  882.   }
  883.   e->error="Could not connect to MySQL server withing the number of tries";
  884. }
  886. static int manager_exec_launch(struct manager_exec* e)
  887. {
  888.   if (one_thread)
  889.   {
  890.     pid_t tmp_pid;
  891.     switch ((tmp_pid=fork())) {
  892.     case -1:
  893.       e->error="Cannot fork";
  894.       return 1;
  895.     case 0:
  896.     {
  897.       int err_code;
  898.       close(manager_sock);
  899.       err_code=execv(e->bin_path,e->args);
  900.       exit(err_code);
  901.     }
  902.     default:
  903.       e->pid=tmp_pid;
  904.       manager_exec_connect(e);
  905.       return 0;
  906.     }
  907.   }
  908.   else
  909.   {
  910.     if (my_write(to_launcher_pipe[1],(byte*)&e->req_len,
  911.  sizeof(int),MYF(MY_NABP))||
  912. my_write(to_launcher_pipe[1],(byte*)&e->num_args,
  913.  sizeof(int),MYF(MY_NABP)) ||
  914. my_write(to_launcher_pipe[1],e->stdout_path,e->stdout_path_size,
  915.  MYF(MY_NABP)) ||
  916. my_write(to_launcher_pipe[1],e->stderr_path,e->stderr_path_size,
  917.  MYF(MY_NABP)) ||
  918. my_write(to_launcher_pipe[1],e->data_buf,e->data_buf_size,
  919.  MYF(MY_NABP)))
  920.     {
  921.       e->error="Failed write request to launcher";
  922.       return 1;
  923.     }
  924.   }
  925.   return 0;
  926. }
  928. static char* arg_strmov(char* dest, const char* src, int n)
  929. {
  930.   char* dest_end = dest+n-1;
  931.   char c;
  932.   for (;dest<dest_end && (c=*src++);)
  933.   {
  934.     if (c=='%')
  935.       *dest++='%';
  936.     *dest++=c;
  937.   }
  938.   return dest;
  939. }
  941. static void manager_exec_print(NET* net,struct manager_exec* e)
  942. {
  943.   char buf[MAX_MYSQL_MANAGER_MSG];
  944.   char* p=buf,*buf_end=buf+sizeof(buf)-1;
  945.   char** args=e->args;
  947.   p=arg_strmov(p,e->ident,(int)(buf_end-p)-1);
  948.   *p++='t';
  949.   if (p>buf_end-15)
  950.     goto end;
  951.   p=int10_to_str(e->pid,p,10);
  952.   *p++='t';
  953.   p=int10_to_str(e->exit_code,p,10);
  954.   *p++='t';
  956.   p=arg_strmov(p,e->con_user,(int)(buf_end-p)-1);
  957.   *p++='@';
  958.   if (p==buf_end)
  959.     goto end;
  960.   p=arg_strmov(p,e->con_host,(int)(buf_end-p)-11);
  961.   *p++=':';
  962.   if (p==buf_end-10)
  963.     goto end;
  964.   if (e->con_sock[0])
  965.   {
  966.     p=arg_strmov(p,e->con_sock,(int)(buf_end-p)-1);
  967.   }
  968.   else
  969.   {
  970.     p=int10_to_str(e->con_port,p,10);
  971.   }
  972.   *p++='t';
  973.   p=arg_strmov(p,e->stdout_path,(int)(buf_end-p)-1);
  974.   if (p==buf_end-1)
  975.     goto end;
  976.   *p++='t';
  977.   p=arg_strmov(p,e->stderr_path,(int)(buf_end-p)-1);
  978.   if (p==buf_end-1)
  979.     goto end;
  980.   *p++='t';
  982.   for (;p<buf_end && *args;args++)
  983.   {
  984.     p=arg_strmov(p,*args,(int)(buf_end-p)-1);
  985.     *p++='t';
  986.   }
  987. end:  
  988.   *p=0;
  989.   client_msg_pre(net,MANAGER_INFO,buf);
  990.   return;
  991. }
  993. static int authenticate(struct manager_thd* thd)
  994. {
  995.   char* buf_end,*buf,*p,*p_end;
  996.   my_MD5_CTX context;
  997.   uchar digest[MD5_LEN];
  998.   struct manager_user* u;
  999.   char c;
  1001.   client_msg(&thd->net,MANAGER_INFO, manager_greeting);
  1002.   if (!(buf_end=read_line(thd)))
  1003.     return -1;
  1004.   for (buf=thd->cmd_buf,p=thd->user,p_end=p+MAX_USER_NAME;
  1005.        buf<buf_end && (c=*buf) && p<p_end; buf++,p++)
  1006.   {
  1007.     if (my_isspace(cs,c))
  1008.     {
  1009.       *p=0;
  1010.       break;
  1011.     }
  1012.     else
  1013.       *p=c;
  1014.   }
  1015.   if (p==p_end || buf==buf_end)
  1016.     return 1;
  1017.   if (!(u=(struct manager_user*)hash_search(&user_hash,thd->user,
  1018.     (uint)(p-thd->user))))
  1019.     return 1;
  1020.   for (;my_isspace(cs,*buf) && buf<buf_end;buf++) /* empty */;
  1022.   my_MD5Init(&context);
  1023.   my_MD5Update(&context,(uchar*) buf,(uint)(buf_end-buf));
  1024.   my_MD5Final(digest,&context);
  1025.   if (memcmp(u->md5_pass,digest,MD5_LEN))
  1026.     return 1;
  1027.   client_msg(&thd->net,MANAGER_OK,"OK");
  1028.   return 0;
  1029. }
  1031. static void print_time(FILE* fp)
  1032. {
  1033.   struct tm now;
  1034.   time_t t;
  1035.   time(&t);
  1036.   localtime_r(&t,&now);
  1037.   fprintf(fp,"[%d-%02d-%02d %02d:%02d:%02d] ", now.tm_year+1900,
  1038.   now.tm_mon+1,now.tm_mday,now.tm_hour,now.tm_min,
  1039.   now.tm_sec);
  1040. }
  1042. static void die(const char* fmt, ...)
  1043. {
  1044.   va_list args;
  1045.   va_start(args,fmt);
  1046.   if (fmt)
  1047.   {
  1048.     if (errfp==stderr)
  1049.       fprintf(errfp, "%s: ", my_progname);
  1050.     else
  1051.       {
  1052. print_time(errfp);
  1053. fprintf(errfp,"Fatal error: ");
  1054.       }
  1055.     vfprintf(errfp, fmt, args);
  1056.     if (errno)
  1057.       fprintf(errfp, " errno=%d", errno);
  1058.     fprintf(errfp, "n");
  1059.     fflush(errfp);
  1060.   }
  1061.   va_end(args);
  1062.   clean_up();
  1063.   exit(1);
  1064. }
  1066. void print_msg_type(int msg_type)
  1067. {
  1068.   const char* msg;
  1069.   switch (msg_type) {
  1070.   case LOG_ERR: msg = "ERROR"; break;
  1071.   case LOG_WARN: msg = "WARNING"; break;
  1072.   case LOG_INFO: msg = "INFO"; break;
  1073. #ifndef DBUG_OFF    
  1074.   case LOG_DEBUG: msg = "DEBUG"; break;
  1075. #endif    
  1076.   default: msg = "UNKNOWN TYPE"; break;
  1077.   }
  1078.   fprintf(errfp," %s: ", msg); 
  1079. }
  1081. static void log_msg(const char* fmt, int msg_type, va_list args)
  1082. {
  1083.   pthread_mutex_lock(&lock_log);
  1084.   print_time(errfp);
  1085.   print_msg_type(msg_type);
  1086.   vfprintf(errfp,fmt,args);
  1087.   fputc('n',errfp);
  1088.   fflush(errfp);
  1089.   pthread_mutex_unlock(&lock_log);
  1090. }
  1092. static pthread_handler_decl(process_launcher_messages,
  1093.     args __attribute__((unused)))
  1094. {
  1095.   my_thread_init();
  1096.   for (;!in_shutdown;)
  1097.   {
  1098.     pid_t pid;
  1099.     struct manager_exec* e;
  1100.     char buf[MAX_LAUNCHER_MSG];
  1101.     if (read(from_launcher_pipe[0],buf,MAX_LAUNCHER_MSG)<0)
  1102.     {
  1103.       log_err("error reading launcher message");
  1104.       sleep(1);
  1105.       continue;
  1106.     }
  1107.     switch (buf[0]) {
  1108.     case CHILD_START:
  1109.     {
  1110.       char* ident=buf+1;
  1111.       int ident_len=strlen(ident);
  1112.       memcpy(&pid,ident+ident_len+1,sizeof(pid));
  1113.       log_debug("process message - ident=%s  ident_len=%d  pid=%d",ident,
  1114. ident_len,pid);
  1115.       pthread_mutex_lock(&lock_exec_hash);
  1116.       log_debug("hash has %d records",exec_hash.records);
  1117.       e=(struct manager_exec*)hash_search(&exec_hash,ident,ident_len);
  1118.       if (e)
  1119.       {
  1120. pthread_mutex_lock(&e->lock);
  1121. e->pid=pid;
  1122. pthread_cond_broadcast(&e->cond);
  1123. pthread_mutex_unlock(&e->lock);
  1124.       }
  1125.       pthread_mutex_unlock(&lock_exec_hash);
  1126.       log_debug("unlocked mutex");
  1127.       break;
  1128.     }
  1129.     case CHILD_STOP:
  1130.       memcpy(&pid,buf+1,sizeof(pid));
  1131.       e=manager_exec_by_pid(pid);
  1132.       if (e)
  1133.       {
  1134. pthread_mutex_lock(&e->lock);
  1135. e->pid=0;
  1136. memcpy(&e->exit_code,buf+1+sizeof(pid),sizeof(int));
  1137. pthread_cond_broadcast(&e->cond);
  1138. pthread_mutex_unlock(&e->lock);
  1139.       }
  1140.       break;
  1141.     default:
  1142.       log_err("Got invalid launcher message");
  1143.       break;
  1144.     }
  1145.   }
  1146.   return 0;
  1147. }
  1149. static pthread_handler_decl(process_connection,arg)
  1150. {
  1151.   struct manager_thd* thd = (struct manager_thd*)arg;
  1152.   my_thread_init();
  1153.   pthread_detach_this_thread();
  1154.   for (;!thd->finished;)
  1155.   {
  1156.     char* buf_end;
  1157.     if ((!(buf_end=read_line(thd)) || exec_line(thd,thd->cmd_buf,buf_end))
  1158. && thd->fatal)
  1159.     {
  1160.       log_err("Thread aborted");
  1161.       break;
  1162.     }
  1163.   }
  1164.   manager_thd_free(thd);
  1165.   pthread_exit(0);
  1166.   return 0; /* Don't get cc warning */
  1167. }
  1169. static int client_msg_raw(NET* net, int err_code, int pre, const char* fmt,
  1170.    va_list args)
  1171. {
  1172.   char buf[MAX_CLIENT_MSG_LEN],*p,*buf_end;
  1173.   p=buf;
  1174.   buf_end=buf+sizeof(buf);
  1175.   p=int10_to_str(err_code,p,10);
  1176.   if (pre)
  1177.     *p++='-';
  1178.   *p++=' ';
  1179.   p+=my_vsnprintf(p,buf_end-p,fmt,args);
  1180.   if (p>buf_end-2)
  1181.     p=buf_end - 2;
  1182.   *p++='r';
  1183.   *p++='n';
  1184.   log_debug("message to client: %-.*s",p-buf-2,buf);
  1185.   if (my_net_write(net,buf,(uint)(p-buf)) || net_flush(net))
  1186.   {
  1187.     p[-2]=0;
  1188.     log_err("Failed writing '%s' to client: errno=%d",buf,errno);
  1189.     net_end(net);
  1190.     return 1;
  1191.   }
  1192.   return 0;
  1193. }
  1195. static int client_msg(NET* net, int err_code, const char* fmt, ...)
  1196. {
  1197.   va_list args;
  1198.   va_start(args,fmt);
  1199.   return client_msg_raw(net,err_code,0,fmt,args);
  1200. }
  1202. static int client_msg_pre(NET* net, int err_code, const char* fmt, ...)
  1203. {
  1204.   va_list args;
  1205.   va_start(args,fmt);
  1206.   return client_msg_raw(net,err_code,1,fmt,args);
  1207. }
  1209. static char* read_line(struct manager_thd* thd)
  1210. {
  1211.   int len;
  1212.   char* p, *buf_end;
  1213.   if ((len=my_net_read(&thd->net)) == (int)packet_error || !len)
  1214.     {
  1215.       log_err("Error reading command from client (Error: %d)",
  1216.       errno);
  1217.       thd->fatal=1;
  1218.       return 0;
  1219.     }
  1220.   buf_end=thd->cmd_buf+len;
  1221.   for (p=thd->cmd_buf;p<buf_end;p++)
  1222.     if (*p == 'r' || *p == 'n')
  1223.     {
  1224.       *p=0;
  1225.       break;
  1226.     }
  1228.   return p;
  1229. }
  1231. static void handle_child(int __attribute__((unused)) sig)
  1232. {
  1233.   pid_t child;
  1234.   int child_status;
  1236.   for (;(child=waitpid(-1,&child_status,WNOHANG))>0;)
  1237.   {
  1238.     char msg_buf[1+sizeof(int)+sizeof(int)];
  1239.     msg_buf[0]=CHILD_STOP;
  1240.     memcpy(msg_buf+1,&child,sizeof(int));
  1241.     memcpy(msg_buf+1+sizeof(int),&child_status,sizeof(int));
  1242.     if (write(from_launcher_pipe[1],msg_buf,sizeof(msg_buf))!=sizeof(msg_buf))
  1243.       log_err("launcher: error writing message on child exit"); 
  1244.   }
  1245.   signal(SIGCHLD,handle_child);
  1246. }
  1248. static struct manager_thd* manager_thd_new(Vio* vio)
  1249. {
  1250.   struct manager_thd* tmp;
  1251.   if (!(tmp=(struct manager_thd*)my_malloc(sizeof(*tmp),
  1252. MYF(0))))
  1253.   {
  1254.     log_err("Out of memory in manager_thd_new");
  1255.     return 0;
  1256.   }
  1257.   my_net_init(&tmp->net,vio);
  1258.   tmp->user[0]=0;
  1259.   tmp->priv_flags=0;
  1260.   tmp->fatal=tmp->finished=0;
  1261.   tmp->cmd_buf= (char*) tmp->net.read_pos;
  1262.   return tmp;
  1263. }
  1265. static void manager_thd_free(struct manager_thd* thd)
  1266. {
  1267.   NET* net=&thd->net;
  1268.   if (net->vio)
  1269.   {
  1270.     vio_delete(net->vio);
  1271.     net->vio=0;
  1272.   }
  1273.   net_end(&thd->net);
  1274. }
  1276. static void clean_up()
  1277. {
  1278.   pthread_mutex_lock(&lock_shutdown);
  1279.   if (in_shutdown)
  1280.   {
  1281.     pthread_mutex_unlock(&lock_shutdown);
  1282.     return;
  1283.   }
  1284.   in_shutdown = 1;
  1285.   pthread_mutex_unlock(&lock_shutdown);
  1286.   log_info("Shutdown started");
  1287.   if (manager_sock)
  1288.     close(manager_sock);
  1289.   log_info("Ended");
  1290.   if (errfp != stderr)
  1291.     my_fclose(errfp, MYF(0));
  1292.   hash_free(&exec_hash);
  1293.   if (created_pid_file)
  1294.     my_delete(pid_file, MYF(0));
  1295. }
  1297. static void print_version(void)
  1298. {
  1299.   printf("%s  Ver %s Distrib %s, for %s (%s)n",my_progname,MANAGER_VERSION,
  1300.  MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
  1301. }
  1303. static void usage()
  1304. {
  1305.   print_version();
  1306.   printf("MySQL AB, by Sashan");
  1307.   printf("This software comes with ABSOLUTELY NO WARRANTYnn");
  1308.   printf("Manages instances of MySQL server.nn");
  1309.   printf("Usage: %s [OPTIONS]nn", my_progname);
  1310.   my_print_help(my_long_options);
  1311.   my_print_variables(my_long_options);
  1312. }
  1315. static my_bool
  1316. get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
  1317.        char *argument)
  1318. {
  1319.   switch (optid) {
  1320.   case '#':
  1321.     DBUG_PUSH(argument ? argument : "d:t:O,/tmp/mysqlmgrd.trace");
  1322.     break;
  1323.   case 'V':
  1324.     print_version();
  1325.     exit(0);
  1326.   case '?':
  1327.     usage();
  1328.     exit(0);
  1329.   }
  1330.   return 0;
  1331. }
  1334. static int parse_args(int argc, char **argv)
  1335. {
  1336.   int ho_error;
  1337.   
  1338.   if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))
  1339.     exit(ho_error);
  1341.   return 0;
  1342. }
  1344. static int init_server()
  1345. {
  1346.   int arg=1;
  1347.   log_info("Started");
  1348.   if ((manager_sock=socket(PF_INET,SOCK_STREAM,0)) < 0)
  1349.     die("Could not create socket");
  1350.   bzero((char*) &manager_addr, sizeof(manager_addr));
  1351.   manager_addr.sin_family = AF_INET;
  1352.   manager_addr.sin_addr.s_addr = manager_bind_addr;
  1353.   manager_addr.sin_port = htons(manager_port);
  1354.   setsockopt(manager_sock,SOL_SOCKET, SO_REUSEADDR,(char*)&arg,sizeof(arg));
  1355.   if (bind(manager_sock,(struct sockaddr*)&manager_addr, sizeof(manager_addr))
  1356.       < 0)
  1357.     die("Could not bind");
  1358.   if (listen(manager_sock,manager_back_log) < 0)
  1359.     die("Could not listen");
  1361.   return 0;
  1362. }
  1364. static int run_server_loop()
  1365. {
  1366.   pthread_t th;
  1367.   struct manager_thd *thd;
  1368.   int client_sock;
  1369.   Vio* vio;
  1370.   pthread_attr_t thr_attr;
  1371.   (void) pthread_attr_init(&thr_attr);
  1372. #if !defined(HAVE_DEC_3_2_THREADS)
  1373.   pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_SYSTEM);
  1374.   (void) pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
  1375. #endif
  1377.   for (;!shutdown_requested;)
  1378.   {
  1379.     size_socket len=sizeof(struct sockaddr_in);
  1380.     if ((client_sock=accept(manager_sock,(struct sockaddr*)&manager_addr,
  1381.     &len)) <0)
  1382.     {
  1383.       if (shutdown_requested)
  1384. break;
  1385.       if (errno != EAGAIN)
  1386.       {
  1387. log_warn("Error in accept, errno=%d", errno);
  1388. sleep(1); /* avoid tying up CPU if accept is broken */
  1389.       }
  1390.       continue;
  1391.     }
  1392.     if (shutdown_requested)
  1393.       break;
  1394.     if (!(vio=vio_new(client_sock,VIO_TYPE_TCPIP,FALSE)))
  1395.     {
  1396.       log_err("Could not create I/O object");
  1397.       close(client_sock);
  1398.       continue;
  1399.     }
  1400.     if (!(thd=manager_thd_new(vio)))
  1401.     {
  1402.       log_err("Could not create thread object");
  1403.       vio_close(vio);
  1404.       continue;
  1405.     }
  1406.     if (authenticate(thd))
  1407.     {
  1408.       client_msg(&thd->net,MANAGER_ACCESS, "Access denied");
  1409.       manager_thd_free(thd);
  1410.       log_info("Client failed to authenticate");
  1411.       continue;
  1412.     }
  1413.     if (shutdown_requested)
  1414.     {
  1415.       manager_thd_free(thd);
  1416.       break;
  1417.     }
  1418.     if (one_thread)
  1419.     {
  1420.       process_connection((void*)thd);
  1421.       manager_thd_free(thd);
  1422.       continue;
  1423.     }
  1424.     else if (pthread_create(&th,&thr_attr,process_connection,(void*)thd))
  1425.     {
  1426.       client_msg(&thd->net,MANAGER_INTERNAL_ERR,
  1427.  "Could not create thread, errno=%d",
  1428.  errno);
  1429.       manager_thd_free(thd);
  1430.       continue;
  1431.     }
  1432.   }
  1433.   (void) pthread_attr_destroy(&thr_attr);
  1434.   return 0;
  1435. }
  1437. static FILE* open_log_stream()
  1438. {
  1439.   FILE* fp;
  1440.   if (!(fp=my_fopen(manager_log_file, O_APPEND | FILE_BINARY, MYF(MY_WME))))
  1441.   {
  1442.     clean_up();
  1443.     exit(1);
  1444.   }
  1445.   return fp;
  1446. }
  1448. static byte* get_user_key(const byte* u, uint* len,
  1449.   my_bool __attribute__((unused)) t)
  1450. {
  1451.   register const char* key;
  1452.   key = ((struct manager_user*)u)->user;
  1453.   *len = ((struct manager_user*)u)->user_len;
  1454.   return (byte*)key;
  1455. }
  1457. static byte* get_exec_key(const byte* e, uint* len,
  1458.  my_bool __attribute__((unused)) t)
  1459. {
  1460.   register const char* key;
  1461.   key = ((struct manager_exec*)e)->ident;
  1462.   *len = ((struct manager_exec*)e)->ident_len;
  1463.   return (byte*)key;
  1464. }
  1466. static void init_arg_array(char* arg_str,char** args,uint arg_count)
  1467. {
  1468.   char* p = arg_str;
  1469.   for (;arg_count>0;arg_count--)
  1470.   {
  1471.     *args++=p;
  1472.     p += strlen(p)+1;
  1473.   }
  1474.   *args=0;
  1475. }
  1477. static uint tokenize_args(char* arg_start,char** arg_end)
  1478. {
  1479.   char* p, *p_write,*p_end;
  1480.   uint arg_count=0;
  1481.   int quoted=0,escaped=0,last_space=0;
  1482.   p_end=*arg_end;
  1483.   p_write=p=arg_start;
  1484.   for (; p < p_end ; p++)
  1485.   {
  1486.     char c = *p;
  1487.     switch (c) {
  1488.     case ' ':
  1489.     case 'r':
  1490.     case 'n':  
  1491.       if (!quoted)
  1492.       {
  1493. if (!last_space)
  1494. {
  1495.   *p_write++=0;
  1496.   arg_count++;
  1497.   last_space=1;
  1498. }
  1499.       }
  1500.       else
  1501. *p_write++=c;
  1502.       escaped=0;
  1503.       break;
  1504.     case '"':
  1505.       if (!escaped)
  1506. quoted=!quoted;
  1507.       else
  1508. *p_write++=c;
  1509.       last_space=0;
  1510.       escaped=0;
  1511.       break;
  1512.     case '\':
  1513.       if (!escaped)
  1514. escaped=1;
  1515.       else
  1516.       {
  1517. *p_write++=c;
  1518. escaped=0;
  1519.       }
  1520.       last_space=0;
  1521.       break;
  1522.     default:
  1523.       escaped=last_space=0;
  1524.       *p_write++=c;
  1525.       break;
  1526.     }
  1527.   }
  1528.   if (!last_space && p_write>arg_start)
  1529.     arg_count++;
  1530.   *p_write=0;
  1531.   *arg_end=p_write;
  1532.   log_debug("arg_count: %d  arg_start: '%s'",arg_count,arg_start);
  1533.   return arg_count;
  1534. }
  1536. static void update_req_len(struct manager_exec* e)
  1537. {
  1538.   e->req_len=(e->data_buf_size+
  1539.       (e->stdout_path_size=strlen(e->stdout_path)+1)+
  1540.       (e->stderr_path_size=strlen(e->stderr_path)+1));
  1541. }
  1543. static struct manager_exec* manager_exec_new(char* arg_start,char* arg_end)
  1544. {
  1545.   struct manager_exec* tmp;
  1546.   char* first_arg;
  1547.   uint arg_len,num_args;
  1548.   num_args=tokenize_args(arg_start,&arg_end);
  1549.   arg_len=(uint)(arg_end-arg_start)+1; /* include  terminator*/
  1550.   if (!(tmp=(struct manager_exec*)my_malloc(sizeof(*tmp)+arg_len+
  1551.     sizeof(char*)*num_args,
  1552.     MYF(MY_ZEROFILL))))
  1553.     return 0;
  1554.   if (num_args<2)
  1555.   {
  1556.     tmp->error="Too few arguments";
  1557.     return tmp;
  1558.   }
  1559.   /* We have to allocate 'args' first as this must be alligned */
  1560.   tmp->args=(char**)(tmp +1);
  1561.   tmp->data_buf= (char*) (tmp->args + num_args);
  1562.   memcpy(tmp->data_buf,arg_start,arg_len);
  1563.   tmp->data_buf_size=arg_len;
  1564.   tmp->num_args=num_args; 
  1565.   tmp->ident=tmp->data_buf;
  1566.   tmp->ident_len=strlen(tmp->ident);
  1567.   first_arg=tmp->ident+tmp->ident_len+1;
  1568.   init_arg_array(first_arg,tmp->args,num_args-1);
  1569.   strmov(tmp->con_user,"root");
  1570.   tmp->con_port=MYSQL_PORT;
  1571.   memcpy(tmp->con_host,"localhost",10);
  1572.   tmp->bin_path=tmp->args[0];
  1573.   tmp->stdout_path_size=tmp->stderr_path_size=1;
  1574.   tmp->req_len=tmp->data_buf_size+2;
  1575.   pthread_mutex_init(&tmp->lock,0);
  1576.   pthread_cond_init(&tmp->cond,0);
  1577.   mysql_init(&tmp->mysql);
  1578.   return tmp;
  1579. }
  1581. static void manager_exec_free(void* e)
  1582. {
  1583.   mysql_close(&((struct manager_exec*)e)->mysql);
  1584.   my_free(e,MYF(0));
  1585. }
  1587. static int hex_val(char c)
  1588. {
  1589.   if (my_isdigit(cs,c))
  1590.     return c-'0';
  1591.   c=my_tolower(cs,c);
  1592.   return c-'a'+10;
  1593. }
  1595. static struct manager_user* manager_user_new(char* buf)
  1596. {
  1597.   struct manager_user* tmp;
  1598.   char* p,*user_end,*p_end;
  1599.   char c;
  1600.   if (!(tmp=(struct manager_user*)my_malloc(sizeof(*tmp),MYF(0))))
  1601.     return 0;
  1602.   p=tmp->user;
  1603.   tmp->error=0;
  1604.   user_end=p+MAX_USER_NAME;
  1605.   for (;(c=*buf) && p<user_end;buf++)
  1606.   {
  1607.     if (c == ':')
  1608.     {
  1609.       *p=0;
  1610.       tmp->user_len=p-tmp->user;
  1611.       buf++;
  1612.       break;
  1613.     }
  1614.     else
  1615.       *p++=c;
  1616.   }
  1617.   if (!c)
  1618.     tmp->error="Missing ':'";
  1619.   if (p == user_end)
  1620.     tmp->error="Username too long";
  1621.   if (tmp->error)
  1622.     return tmp;
  1623.   if (strlen(buf) < 2*MD5_LEN)
  1624.   {
  1625.     tmp->error="Invalid MD5 sum, too short";
  1626.     return tmp;
  1627.   }
  1628.   p=tmp->md5_pass;
  1629.   p_end=p+MD5_LEN;
  1630.   for (; p<p_end;p++,buf+=2)
  1631.   {
  1632.     *p=hex_val(*buf)*16+hex_val(buf[1]);
  1633.   }
  1635.   return tmp;
  1636. }
  1638. static void manager_user_free(void* u)
  1639. {
  1640.   my_free((gptr)u,MYF(0));
  1641. }
  1643. static void init_user_hash()
  1644. {
  1645.   FILE* f;
  1646.   char buf[80];
  1647.   int line_num=1;
  1648.   if (hash_init(&user_hash,cs,1024,0,0,
  1649.                 get_user_key,manager_user_free,MYF(0)))
  1650.     die("Could not initialize user hash");
  1651.   if (!(f=my_fopen(manager_pw_file, O_RDONLY | O_BINARY, MYF(MY_WME))))
  1652.   {
  1653.     clean_up();
  1654.     exit(1);
  1655.   }
  1656.   for (;;line_num++)
  1657.   {
  1658.     struct manager_user* u;
  1659.     if (!fgets(buf,sizeof(buf),f) || feof(f))
  1660.       break;
  1661.     if (buf[0] == '#')
  1662.       continue;
  1663.     if (!(u=manager_user_new(buf)))
  1664.       die("Out of memory while reading user line");
  1665.     if (u->error)
  1666.     {
  1667.       die("Error on line %d of '%s': %s",line_num,manager_pw_file, u->error);
  1668.     }
  1669.     else
  1670.     {
  1671.       my_hash_insert(&user_hash,(gptr)u);
  1672.     }
  1673.   }
  1674.   my_fclose(f, MYF(0));
  1675. }
  1678. static void init_pid_file()
  1679. {
  1680.   FILE* fp = my_fopen(pid_file, O_WRONLY | O_BINARY, MYF(MY_WME));
  1681.   if (!fp)
  1682.   {
  1683.     clean_up();
  1684.     exit(1);
  1685.   }
  1686.   created_pid_file=1;
  1687.   fprintf(fp, "%dn", (int) getpid());
  1688.   my_fclose(fp, MYF(0));
  1689. }
  1692. static void init_globals()
  1693. {
  1694.   pthread_attr_t thr_attr;
  1695.   if (hash_init(&exec_hash,cs,1024,0,0,
  1696.                 get_exec_key,manager_exec_free,MYF(0)))
  1697.     die("Exec hash initialization failed");
  1698.   if (!one_thread)
  1699.   {
  1700.     (void) pthread_attr_init(&thr_attr);
  1701. #if !defined(HAVE_DEC_3_2_THREADS)
  1702.     pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_SYSTEM);
  1703.     (void) pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
  1704. #endif
  1705.     fork_launcher();
  1706.     if (pthread_create(&launch_msg_th,&thr_attr,process_launcher_messages,0))
  1707.       die("Could not start launcher message handler thread");
  1708.     /* (void) pthread_attr_destroy(&thr_attr); */
  1709.   }
  1710.   init_user_hash();
  1711.   init_pid_file();
  1712.   loop_th=pthread_self();
  1713.   signal(SIGPIPE,handle_sigpipe);
  1714.   signal(SIGTERM,handle_sigterm);
  1715. }
  1717. static int open_and_dup(int fd,char* path)
  1718. {
  1719.   int old_fd;
  1720.   if ((old_fd=my_open(path,O_WRONLY|O_APPEND|O_CREAT,MYF(0)))<0)
  1721.   {
  1722.     log_err("Could not open '%s' for append, errno=%d",path,errno);
  1723.     return 1;
  1724.   }
  1725.   if (dup2(old_fd,fd)<0)
  1726.   {
  1727.     log_err("Failed in dup2(), errno=%d",errno);
  1728.     return 1;
  1729.   }
  1730.   my_close(old_fd,MYF(0));
  1731.   return 0;
  1732. }
  1734. static void run_launcher_loop()
  1735. {
  1736.   for (;;)
  1737.   {
  1738.     int req_len,ident_len,num_args;
  1739.     char* request_buf=0;
  1740.     pid_t pid;
  1741.     char* exec_path,*ident,*stdout_path,*stderr_path;
  1742.     char** args=0;
  1744.     if (my_read(to_launcher_pipe[0],(byte*)&req_len,
  1745. sizeof(int),MYF(MY_NABP|MY_FULL_IO)) ||
  1746. my_read(to_launcher_pipe[0],(byte*)&num_args,
  1747. sizeof(int),MYF(MY_NABP|MY_FULL_IO)) ||
  1748. !(request_buf=(char*)my_malloc(req_len+sizeof(pid)+2,MYF(0))) ||
  1749. !(args=(char**)my_malloc(num_args*sizeof(char*),MYF(0))) ||
  1750. my_read(to_launcher_pipe[0],request_buf,req_len,
  1751. MYF(MY_NABP|MY_FULL_IO)))
  1752.     {
  1753.       log_err("launcher: Error reading request");
  1754.       my_free((gptr)request_buf,MYF(MY_ALLOW_ZERO_PTR));
  1755.       my_free((gptr)args,MYF(MY_ALLOW_ZERO_PTR));
  1756.       sleep(1);
  1757.       continue;
  1758.     }
  1759.     stdout_path=request_buf;
  1760.     stderr_path=stdout_path+strlen(stdout_path)+1;
  1761.     request_buf=stderr_path+strlen(stderr_path); /* black magic */
  1762.     ident=request_buf+1;
  1763.     ident_len=strlen(ident);
  1764.     exec_path=ident+ident_len+1;
  1765.     log_debug("num_args=%d,req_len=%d,ident=%s,ident_len=%d,exec_path=%s,
  1766. stdout_path=%s,stderr_path=%s",
  1767.       num_args,
  1768.       req_len,ident,ident_len,exec_path,stdout_path,stderr_path);
  1769.     init_arg_array(exec_path,args,num_args-1);    
  1771.     switch ((pid=fork())) {
  1772.     case -1:
  1773.       log_err("launcher: cannot fork");
  1774.       sleep(1);
  1775.       break;
  1776.     case 0:
  1777.       if (open_and_dup(1,stdout_path) || open_and_dup(2,stderr_path))
  1778. exit(1);
  1779.       if (execv(exec_path,args))
  1780. log_err("launcher: cannot exec %s",exec_path);
  1781.       exit(1);
  1782.     default:
  1783.       request_buf[0]=CHILD_START;
  1784.       memcpy(request_buf+ident_len+2,&pid,sizeof(pid));
  1785.       if (write(from_launcher_pipe[1],request_buf,ident_len+2+sizeof(pid))<0)
  1786. log_err("launcher: error sending launch status report");
  1787.       break;
  1788.     }
  1789.     my_free((gptr)(stdout_path),MYF(0));
  1790.     my_free((gptr)args,MYF(0));
  1791.   }
  1792. }
  1794. static void fork_launcher()
  1795. {
  1796.   if (pipe(to_launcher_pipe) || pipe(from_launcher_pipe))
  1797.     die("Could not create launcher pipes");
  1798.   switch ((launcher_pid=fork())) {
  1799.   case 0:
  1800.     signal(SIGCHLD,handle_child);
  1801.     run_launcher_loop();
  1802.     exit(0);
  1803.   case -1: die("Could not fork the launcher");
  1804.   default: return;
  1805.   }
  1806. }
  1808. static int daemonize()
  1809. {
  1810.   switch (fork()) {
  1811.   case -1:
  1812.     die("Cannot fork");
  1813.   case 0:
  1814.     errfp = open_log_stream();
  1815.     init_globals();
  1816.     close(0);
  1817.     close(1);
  1818.     close(2);
  1819.     init_server();
  1820.     run_server_loop();
  1821.     clean_up();
  1822.     break;
  1823.   default:
  1824.     break;
  1825.   }
  1826.   return 0;
  1827. }
  1829. int main(int argc, char** argv)
  1830. {
  1831.   char c;
  1832.   stack_bottom= (uchar *) &c;
  1833.   MY_INIT(argv[0]);
  1834.   errfp = stderr;
  1835.   parse_args(argc,argv);
  1836.   pthread_mutex_init(&lock_log,0);
  1837.   pthread_mutex_init(&lock_shutdown,0);
  1838.   pthread_mutex_init(&lock_exec_hash,0);
  1839.   pthread_mutex_init(&lock_launch_thd,0);
  1840.   pthread_cond_init(&cond_launch_thd,0);
  1841. #ifdef DO_STACKTRACE
  1842.   signal(SIGSEGV,handle_segfault);
  1843. #endif
  1844.   if (one_thread)
  1845.   {
  1846.     init_globals();
  1847.     init_server();
  1848.     run_server_loop();
  1849.     clean_up();
  1850.     return 0;
  1851.   }
  1852.   else
  1853.     return daemonize();
  1854. }
  1856. #else
  1858. #include <stdio.h>
  1860. int main(void)
  1861. {
  1862.   fprintf(stderr,"This tool has not been ported to NetWaren");
  1863.   return 0;
  1864. }
  1866. #endif /* __NETWARE__ */