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

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

MySQL数据库

开发平台：

Visual C++

sql_parse.cc：源码内容
  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 */
  18. #include "mysql_priv.h"
  19. #include "sql_acl.h"
  20. #include "sql_repl.h"
  21. #include <m_ctype.h>
  22. #include <thr_alarm.h>
  23. #include <myisam.h>
  24. #include <my_dir.h>
  25. #include <assert.h>
  27. #define SCRAMBLE_LENGTH 8
  30. extern int yyparse(void);
  31. extern "C" pthread_mutex_t THR_LOCK_keycache;
  32. #ifdef SOLARIS
  33. extern "C" int gethostname(char *name, int namelen);
  34. #endif
  36. static int check_for_max_user_connections(const char *user, int u_length,
  37.   const char *host);
  38. static void decrease_user_connections(const char *user, const char *host);
  39. static bool check_table_access(THD *thd,uint want_access, TABLE_LIST *tables);
  40. static bool check_db_used(THD *thd,TABLE_LIST *tables);
  41. static bool check_merge_table_access(THD *thd, char *db, TABLE_LIST *tables);
  42. static bool check_dup(THD *thd,const char *db,const char *name,
  43.       TABLE_LIST *tables);
  44. static void mysql_init_query(THD *thd);
  45. static void remove_escape(char *name);
  46. static void refresh_status(void);
  48. const char *any_db="*any*"; // Special symbol for check_access
  50. const char *command_name[]={
  51.   "Sleep", "Quit", "Init DB", "Query", "Field List", "Create DB",
  52.   "Drop DB", "Refresh", "Shutdown", "Statistics", "Processlist",
  53.   "Connect","Kill","Debug","Ping","Time","Delayed_insert","Change user",
  54.   "Binlog Dump","Table Dump",  "Connect Out"
  55. };
  57. bool volatile abort_slave = 0;
  59. #ifdef HAVE_OPENSSL
  60. extern VioSSLAcceptorFd* ssl_acceptor_fd;
  61. #endif /* HAVE_OPENSSL */
  63. #ifdef __WIN__
  64. static void  test_signal(int sig_ptr)
  65. {
  66. #ifndef DBUG_OFF
  67.   MessageBox(NULL,"Test signal","DBUG",MB_OK);
  68. #endif
  69. }
  70. static void init_signals(void)
  71. {
  72.   int signals[7] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGBREAK,SIGABRT } ;
  73.   for(int i=0 ; i < 7 ; i++)
  74.     signal( signals[i], test_signal) ;
  75. }
  76. #endif
  78. inline bool end_active_trans(THD *thd)
  79. {
  80.   int error=0;
  81.   if (thd->options & (OPTION_NOT_AUTO_COMMIT | OPTION_BEGIN))
  82.   {
  83.     thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
  84.     thd->server_status&= ~SERVER_STATUS_IN_TRANS;
  85.     if (ha_commit(thd))
  86.       error=1;
  87.   }
  88.   return error;
  89. }
  92. /*
  93. ** Check if user is ok
  94. ** Updates:
  95. ** thd->user, thd->master_access, thd->priv_user, thd->db, thd->db_access
  96. */
  98. static bool check_user(THD *thd,enum_server_command command, const char *user,
  99.        const char *passwd, const char *db, bool check_count)
  100. {
  101.   NET *net= &thd->net;
  102.   thd->db=0;
  104.   if (!(thd->user = my_strdup(user, MYF(0))))
  105.   {
  106.     send_error(net,ER_OUT_OF_RESOURCES);
  107.     return 1;
  108.   }
  109.   thd->master_access=acl_getroot(thd->host, thd->ip, thd->user,
  110.  passwd, thd->scramble, &thd->priv_user,
  111.  protocol_version == 9 ||
  112.  !(thd->client_capabilities &
  113.    CLIENT_LONG_PASSWORD));
  114.   DBUG_PRINT("general",
  115.      ("Capabilities: %d  packet_length: %d  Host: '%s'  User: '%s'  Using password: %s  Access: %u  db: '%s'",
  116.       thd->client_capabilities, thd->max_packet_length,
  117.       thd->host ? thd->host : thd->ip, thd->priv_user,
  118.       passwd[0] ? "yes": "no",
  119.       thd->master_access, thd->db ? thd->db : "*none*"));
  120.   if (thd->master_access & NO_ACCESS)
  121.   {
  122.     net_printf(net, ER_ACCESS_DENIED_ERROR,
  123.        thd->user,
  124.        thd->host ? thd->host : thd->ip,
  125.        passwd[0] ? ER(ER_YES) : ER(ER_NO));
  126.     mysql_log.write(thd,COM_CONNECT,ER(ER_ACCESS_DENIED_ERROR),
  127.     thd->user,
  128.     thd->host ? thd->host : thd->ip ? thd->ip : "unknown ip",
  129.     passwd[0] ? ER(ER_YES) : ER(ER_NO));
  130.     return(1); // Error already given
  131.   }
  132.   if (check_count)
  133.   {
  134.     VOID(pthread_mutex_lock(&LOCK_thread_count));
  135.     bool tmp=(thread_count - delayed_insert_threads >= max_connections &&
  136.       !(thd->master_access & PROCESS_ACL));
  137.     VOID(pthread_mutex_unlock(&LOCK_thread_count));
  138.     if (tmp)
  139.     { // Too many connections
  140.       send_error(net, ER_CON_COUNT_ERROR);
  141.       return(1);
  142.     }
  143.   }
  144.   mysql_log.write(thd,command,
  145.   (thd->priv_user == thd->user ?
  146.    (char*) "%s@%s on %s" :
  147.    (char*) "%s@%s as anonymous on %s"),
  148.   user,
  149.   thd->host ? thd->host : thd->ip ? thd->ip : "unknown ip",
  150.   db ? db : (char*) "");
  151.   thd->db_access=0;
  152.   if (max_user_connections &&
  153.       check_for_max_user_connections(user, strlen(user), thd->host))
  154.     return -1;
  155.   if (db && db[0])
  156.   {
  157.     bool error=test(mysql_change_db(thd,db));
  158.     if (error)
  159.       decrease_user_connections(thd->user,thd->host);
  160.     return error;
  161.   }
  162.   else
  163.     send_ok(net); // Ready to handle questions
  164.   return 0; // ok
  165. }
  167. /*
  168. ** check for maximum allowable user connections
  169. ** if mysql server is started with corresponding
  170. ** variable that is greater then 0
  171. */
  173. static HASH hash_user_connections;
  174. static DYNAMIC_ARRAY  user_conn_array;
  175. extern  pthread_mutex_t LOCK_user_conn;
  177. struct  user_conn {
  178.   char *user;
  179.   uint len, connections;
  180. };
  182. static byte* get_key_conn(user_conn *buff, uint *length,
  183.   my_bool not_used __attribute__((unused)))
  184. {
  185.   *length=buff->len;
  186.   return (byte*) buff->user;
  187. }
  189. #define DEF_USER_COUNT 50
  191. static void free_user(struct user_conn *uc)
  192. {
  193.   my_free((char*) uc,MYF(0));
  194. }
  196. void init_max_user_conn(void) 
  197. {
  198.   (void) hash_init(&hash_user_connections,DEF_USER_COUNT,0,0,
  199.    (hash_get_key) get_key_conn, (void (*)(void*)) free_user,
  200.    0);
  201. }
  204. static int check_for_max_user_connections(const char *user, int u_length,
  205.   const char *host) 
  206. {
  207.   int error=1;
  208.   uint temp_len;
  209.   char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];
  210.   struct  user_conn *uc;
  211.   if (!user)
  212.     user="";
  213.   if (!host)
  214.     host="";
  215.   DBUG_ENTER("check_for_max_user_connections");
  216.   DBUG_PRINT("enter",("user: '%s'  host: '%s'", user, host));
  218.   temp_len= (uint) (strxnmov(temp_user, sizeof(temp_user), user, "@", host,
  219.      NullS) - temp_user);
  220.   (void) pthread_mutex_lock(&LOCK_user_conn);
  221.   uc = (struct  user_conn *) hash_search(&hash_user_connections,
  222.  (byte*) temp_user, temp_len);
  223.   if (uc) /* user found ; check for no. of connections */
  224.   {
  225.     if (max_user_connections ==  (uint) uc->connections) 
  226.     {
  227.       net_printf(&(current_thd->net),ER_TOO_MANY_USER_CONNECTIONS, temp_user);
  228.       goto end;
  229.     }
  230.     uc->connections++; 
  231.   }
  232.   else
  233.   {
  234.     /* the user is not found in the cache; Insert it */
  235.     struct user_conn *uc= ((struct user_conn*)
  236.    my_malloc(sizeof(struct user_conn) + temp_len+1,
  237.      MYF(MY_WME)));
  238.     if (!uc)
  239.     {
  240.       send_error(&current_thd->net, 0, NullS); // Out of memory
  241.       goto end;
  242.     }      
  243.     uc->user=(char*) (uc+1);
  244.     memcpy(uc->user,temp_user,temp_len+1);
  245.     uc->len = temp_len;
  246.     uc->connections = 1;
  247.     if (hash_insert(&hash_user_connections, (byte*) uc))
  248.     {
  249.       my_free((char*) uc,0);
  250.       send_error(&current_thd->net, 0, NullS); // Out of memory
  251.       goto end;
  252.     }
  253.   }
  254.   error=0;
  256. end:
  257.   (void) pthread_mutex_unlock(&LOCK_user_conn);
  258.   DBUG_RETURN(error);
  259. }
  262. static void decrease_user_connections(const char *user, const char *host)
  263. {
  264.   char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];
  265.   int temp_len;
  266.   struct user_conn *uc;
  267.   if (!max_user_connections)
  268.     return;
  269.   if (!user)
  270.     user="";
  271.   if (!host)
  272.     host="";
  273.   DBUG_ENTER("decrease_user_connections");
  274.   DBUG_PRINT("enter",("user: '%s'  host: '%s'", user, host));
  276.   temp_len= (uint) (strxnmov(temp_user, sizeof(temp_user), user, "@", host,
  277.      NullS) - temp_user);
  278.   (void) pthread_mutex_lock(&LOCK_user_conn);
  280.   uc = (struct  user_conn *) hash_search(&hash_user_connections,
  281.  (byte*) temp_user, temp_len);
  282.   dbug_assert(uc != 0); // We should always find the user
  283.   if (!uc)
  284.     goto end; // Safety; Something went wrong
  285.   if (! --uc->connections)
  286.   {
  287.     /* Last connection for user; Delete it */
  288.     (void) hash_delete(&hash_user_connections,(byte*) uc);
  289.   }
  290. end:
  291.   (void) pthread_mutex_unlock(&LOCK_user_conn);
  292.   DBUG_VOID_RETURN;
  293. }
  296. void free_max_user_conn(void)
  297. {
  298.   hash_free(&hash_user_connections);
  299. }
  302. /*
  303. ** check connnetion and get priviliges
  304. ** returns 0 on ok, -1 < if error is given > 0 on error.
  305. */
  308. static int
  309. check_connections(THD *thd)
  310. {
  311.   uint connect_errors=0;
  312.   NET *net= &thd->net;
  313.   /*
  314.   ** store the connection details
  315.   */
  316.   DBUG_PRINT("info", (("check_connections called by thread %d"),
  317.      thd->thread_id));
  318.   DBUG_PRINT("general",("New connection received on %s",
  319. vio_description(net->vio)));
  320.   if (!thd->host)                           // If TCP/IP connection
  321.   {
  322.     char ip[30];
  324.     if (vio_peer_addr(net->vio,ip))
  325.       return (ER_BAD_HOST_ERROR);
  326.     if (!(thd->ip = my_strdup(ip,MYF(0))))
  327.       return (ER_OUT_OF_RESOURCES);
  328. #if !defined(HAVE_SYS_UN_H) || defined(HAVE_mit_thread)
  329.     /* Fast local hostname resolve for Win32 */
  330.     if (!strcmp(thd->ip,"127.0.0.1"))
  331.       thd->host=(char*) localhost;
  332.     else
  333. #endif
  334.     if (!(specialflag & SPECIAL_NO_RESOLVE))
  335.     {
  336.       vio_in_addr(net->vio,&thd->remote.sin_addr);
  337.       thd->host=ip_to_hostname(&thd->remote.sin_addr,&connect_errors);
  338.       if (connect_errors > max_connect_errors)
  339. return(ER_HOST_IS_BLOCKED);
  340.     }
  341.     DBUG_PRINT("general",("Host: %s  ip: %s",
  342.   thd->host ? thd->host : "unknown host",
  343.   thd->ip ? thd->ip : "unknown ip"));
  344.     if (acl_check_host(thd->host,thd->ip))
  345.       return(ER_HOST_NOT_PRIVILEGED);
  346.   }
  347.   else /* Hostname given means that the connection was on a socket */
  348.   {
  349.     DBUG_PRINT("general",("Host: %s",thd->host));
  350.     thd->ip=0;
  351.     bzero((char*) &thd->remote,sizeof(struct sockaddr));
  352.   }
  353.   vio_keepalive(net->vio, TRUE);
  355.   /* nasty, but any other way? */
  356.   uint pkt_len = 0;
  357.   {
  358.     /* buff[] needs to big enough to hold the server_version variable */
  359.     char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH+32],*end;
  360.     int client_flags = CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB;
  361.     if (opt_using_transactions)
  362.       client_flags|=CLIENT_TRANSACTIONS;
  363. #ifdef HAVE_COMPRESS
  364.     client_flags |= CLIENT_COMPRESS;
  365. #endif /* HAVE_COMPRESS */
  367.     end=strmov(buff,server_version)+1;
  368.     int4store((uchar*) end,thd->thread_id);
  369.     end+=4;
  370.     memcpy(end,thd->scramble,SCRAMBLE_LENGTH+1);
  371.     end+=SCRAMBLE_LENGTH +1;
  372. #ifdef HAVE_OPENSSL
  373.     if (ssl_acceptor_fd)
  374.       client_flags |= CLIENT_SSL;       /* Wow, SSL is avalaible! */
  375.     /*
  376.      * Without SSL the handshake consists of one packet. This packet
  377.      * has both client capabilites and scrambled password.
  378.      * With SSL the handshake might consist of two packets. If the first
  379.      * packet (client capabilities) has CLIENT_SSL flag set, we have to
  380.      * switch to SSL and read the second packet. The scrambled password
  381.      * is in the second packet and client_capabilites field will be ignored.
  382.      * Maybe it is better to accept flags other than CLIENT_SSL from the
  383.      * second packet?
  384.   */
  385. #define  SSL_HANDSHAKE_SIZE      2
  386. #define  NORMAL_HANDSHAKE_SIZE   6
  387. #define  MIN_HANDSHAKE_SIZE      2
  389. #else
  390. #define  MIN_HANDSHAKE_SIZE      6
  391. #endif /* HAVE_OPENSSL */
  392.     int2store(end,client_flags);
  393.     end[2]=MY_CHARSET_CURRENT;
  394.     int2store(end+3,thd->server_status);
  395.     bzero(end+5,13);
  396.     end+=18;
  397.     if (net_write_command(net,protocol_version, buff,
  398.   (uint) (end-buff)) ||
  399.        (pkt_len=my_net_read(net)) == packet_error ||
  400. pkt_len < MIN_HANDSHAKE_SIZE)
  401.     {
  402.       inc_host_errors(&thd->remote.sin_addr);
  403.       return(ER_HANDSHAKE_ERROR);
  404.     }
  405.   }
  406. #ifdef _CUSTOMCONFIG_
  407. #include "_cust_sql_parse.h"
  408. #endif
  409.   if (connect_errors)
  410.     reset_host_errors(&thd->remote.sin_addr);
  411.   if (thd->packet.alloc(net_buffer_length))
  412.     return(ER_OUT_OF_RESOURCES);
  414.   thd->client_capabilities=uint2korr(net->read_pos);
  415. #ifdef HAVE_OPENSSL
  416.   DBUG_PRINT("info",
  417.      ("pkt_len:%d, client capabilities: %d",
  418.       pkt_len, thd->client_capabilities) );
  419.   if (thd->client_capabilities & CLIENT_SSL)
  420.   {
  421.     DBUG_PRINT("info", ("Agreed to change IO layer to SSL") );
  422.     /* Do the SSL layering. */
  423.     DBUG_PRINT("info", ("IO layer change in progress..."));
  424.     VioSocket* vio_socket = my_reinterpret_cast(VioSocket*)(net->vio);
  425.     VioSSL* vio_ssl =    ssl_acceptor_fd->accept(vio_socket);
  426.     net->vio =               my_reinterpret_cast(NetVio*) (vio_ssl);
  427.     DBUG_PRINT("info", ("Reading user information over SSL layer"));
  428.     if ((pkt_len=my_net_read(net)) == packet_error ||
  429. pkt_len < NORMAL_HANDSHAKE_SIZE)
  430.     {
  431.       DBUG_PRINT("info", ("pkt_len:%d", pkt_len));
  432.       DBUG_PRINT("error", ("Failed to read user information"));
  433.       inc_host_errors(&thd->remote.sin_addr);
  434.       return(ER_HANDSHAKE_ERROR);
  435.     }
  436.   }
  437.   else
  438.   {
  439.     DBUG_PRINT("info", ("Leaving IO layer intact"));
  440.     if (pkt_len < NORMAL_HANDSHAKE_SIZE)
  441.     {
  442.       inc_host_errors(&thd->remote.sin_addr);
  443.       return ER_HANDSHAKE_ERROR;
  444.     }
  445.   }
  446. #endif
  448.   thd->max_packet_length=uint3korr(net->read_pos+2);
  449.   char *user=   (char*) net->read_pos+5;
  450.   char *passwd= strend(user)+1;
  451.   char *db=0;
  452.   if (passwd[0] && strlen(passwd) != SCRAMBLE_LENGTH)
  453.     return ER_HANDSHAKE_ERROR;
  454.   if (thd->client_capabilities & CLIENT_CONNECT_WITH_DB)
  455.     db=strend(passwd)+1;
  456.   if (thd->client_capabilities & CLIENT_INTERACTIVE)
  457.     thd->inactive_timeout=net_interactive_timeout;
  458.   if (thd->client_capabilities & CLIENT_TRANSACTIONS)
  459.     thd->net.return_status= &thd->server_status;
  460.   net->timeout=net_read_timeout;
  461.   if (check_user(thd,COM_CONNECT, user, passwd, db, 1))
  462.     return (-1);
  463.   thd->password=test(passwd[0]);
  464.   return 0;
  465. }
  468. pthread_handler_decl(handle_one_connection,arg)
  469. {
  470.   THD *thd=(THD*) arg;
  471.   uint launch_time  =
  472.     (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
  473.   if (launch_time >= slow_launch_time)
  474.     statistic_increment(slow_launch_threads,&LOCK_status );
  476.   pthread_detach_this_thread();
  478. #ifndef __WIN__ /* Win32 calls this in pthread_create */
  479.   if (my_thread_init()) // needed to be called first before we call
  480.     // DBUG_ macros
  481.   {
  482.     close_connection(&thd->net,ER_OUT_OF_RESOURCES);
  483.     statistic_increment(aborted_connects,&LOCK_thread_count);
  484.     end_thread(thd,0);
  485.     return 0;
  486.   }
  487. #endif
  489.   // handle_one_connection() is the only way a thread would start
  490.   // and would always be on top of the stack
  491.   // therefore, the thread stack always starts at the address of the first
  492.   // local variable of handle_one_connection, which is thd
  493.   // we need to know the start of the stack so that we could check for
  494.   // stack overruns
  496.   DBUG_PRINT("info", ("handle_one_connection called by thread %dn",
  497.       thd->thread_id));
  498.   // now that we've called my_thread_init(), it is safe to call DBUG_*
  500. #ifdef __WIN__
  501.   init_signals(); // IRENA; testing ?
  502. #else
  503.   sigset_t set;
  504.   VOID(sigemptyset(&set)); // Get mask in use
  505.   VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
  506. #endif
  507.   if (thd->store_globals())
  508.   {
  509.     close_connection(&thd->net,ER_OUT_OF_RESOURCES);
  510.     statistic_increment(aborted_connects,&LOCK_thread_count);
  511.     end_thread(thd,0);
  512.     return 0;
  513.   }
  515.   do
  516.   {
  517.     int error;
  518.     NET *net= &thd->net;
  520.     thd->mysys_var=my_thread_var;
  521.     thd->dbug_thread_id=my_thread_id();
  522.     thd->thread_stack= (char*) &thd;
  524.     if ((error=check_connections(thd)))
  525.     { // Wrong permissions
  526.       if (error > 0)
  527. net_printf(net,error,thd->host ? thd->host : thd->ip);
  528. #ifdef __NT__
  529.       if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
  530. sleep(1); /* must wait after eof() */
  531. #endif
  532.       statistic_increment(aborted_connects,&LOCK_thread_count);
  533.       goto end_thread;
  534.     }
  536.     if (thd->max_join_size == HA_POS_ERROR)
  537.       thd->options |= OPTION_BIG_SELECTS;
  538.     if (thd->client_capabilities & CLIENT_COMPRESS)
  539.       net->compress=1; // Use compression
  540.     if (thd->options & OPTION_ANSI_MODE)
  541.       thd->client_capabilities|=CLIENT_IGNORE_SPACE;
  543.     thd->proc_info=0; // Remove 'login'
  544.     thd->command=COM_SLEEP;
  545.     thd->version=refresh_version;
  546.     thd->set_time();
  547.     init_sql_alloc(&thd->mem_root,8192,8192);
  548.     while (!net->error && net->vio != 0 && !thd->killed)
  549.     {
  550.       if (do_command(thd))
  551. break;
  552.     }
  553.     free_root(&thd->mem_root,MYF(0));
  554.     if (net->error && net->vio != 0)
  555.     {
  556.       sql_print_error(ER(ER_NEW_ABORTING_CONNECTION),
  557.       thd->thread_id,(thd->db ? thd->db : "unconnected"),
  558.       thd->user ? thd->user : "unauthenticated",
  559.       (thd->host ? thd->host : thd->ip ? thd->ip : "unknown"),
  560.       (net->last_errno ? ER(net->last_errno) :
  561.        ER(ER_UNKNOWN_ERROR)));
  562.       send_error(net,net->last_errno,NullS);
  563.       thread_safe_increment(aborted_threads,&LOCK_thread_count);
  564.     }
  566.     decrease_user_connections(thd->user,thd->host);
  567. end_thread:
  568.     close_connection(net);
  569.     end_thread(thd,1);
  570.     /*
  571.       If end_thread returns, we are either running with --one-thread
  572.       or this thread has been schedule to handle the next query
  573.     */
  574.     thd= current_thd;
  575.   } while (!(test_flags & TEST_NO_THREADS));
  576.   /* The following is only executed if we are not using --one-thread */
  577.   return(0); /* purecov: deadcode */
  578. }
  580. /*
  581.   Execute commands from bootstrap_file.
  582.   Used when creating the initial grant tables
  583. */
  585. pthread_handler_decl(handle_bootstrap,arg)
  586. {
  587.   THD *thd=(THD*) arg;
  588.   FILE *file=bootstrap_file;
  589.   char *buff;
  591.   /* The following must be called before DBUG_ENTER */
  592.   if (my_thread_init() || thd->store_globals())
  593.   {
  594.     close_connection(&thd->net,ER_OUT_OF_RESOURCES);
  595.     thd->fatal_error=1;
  596.     goto end;
  597.   }
  598.   DBUG_ENTER("handle_bootstrap");
  600.   pthread_detach_this_thread();
  601.   thd->thread_stack= (char*) &thd;
  602.   thd->mysys_var=my_thread_var;
  603.   thd->dbug_thread_id=my_thread_id();
  604. #ifndef __WIN__
  605.   sigset_t set;
  606.   VOID(sigemptyset(&set)); // Get mask in use
  607.   VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
  608. #endif
  610.   if (thd->max_join_size == (ulong) ~0L)
  611.     thd->options |= OPTION_BIG_SELECTS;
  613.   thd->proc_info=0;
  614.   thd->version=refresh_version;
  615.   thd->priv_user=thd->user=(char*)"boot";
  617.   buff= (char*) thd->net.buff;
  618.   init_sql_alloc(&thd->mem_root,8192,8192);
  619.   while (fgets(buff, thd->net.max_packet, file))
  620.   {
  621.     uint length=(uint) strlen(buff);
  622.     while (length && (isspace(buff[length-1]) || buff[length-1] == ';'))
  623.       length--;
  624.     buff[length]=0;
  625.     thd->current_tablenr=0;
  626.     thd->query= thd->memdup(buff,length+1);
  627.     thd->query_id=query_id++;
  628.     mysql_parse(thd,thd->query,length);
  629.     close_thread_tables(thd); // Free tables
  630.     if (thd->fatal_error)
  631.       break;
  632.     free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
  633.   }
  634.   thd->priv_user=thd->user=0;
  636.   /* thd->fatal_error should be set in case something went wrong */
  637. end:
  638.   (void) pthread_mutex_lock(&LOCK_thread_count);
  639.   thread_count--;
  640.   (void) pthread_cond_broadcast(&COND_thread_count);
  641.   (void) pthread_mutex_unlock(&LOCK_thread_count);
  642.   my_thread_end();
  643.   pthread_exit(0);
  644.   DBUG_RETURN(0); // Never reached
  645. }
  648. inline void free_items(THD *thd)
  649. {
  650.     /* This works because items are allocated with sql_alloc() */
  651.   for (Item *item=thd->free_list ; item ; item=item->next)
  652.     delete item;
  653. }
  655. int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd)
  656. {
  657.   TABLE* table;
  658.   TABLE_LIST* table_list;
  659.   int error = 0;
  660.   DBUG_ENTER("mysql_table_dump");
  661.   db = (db && db[0]) ? db : thd->db;
  662.   if (!(table_list = (TABLE_LIST*) sql_calloc(sizeof(TABLE_LIST))))
  663.     DBUG_RETURN(1); // out of memory
  664.   table_list->db = db;
  665.   table_list->real_name = table_list->name = tbl_name;
  666.   table_list->lock_type = TL_READ_NO_INSERT;
  667.   table_list->next = 0;
  668.   remove_escape(table_list->real_name);
  670.   if (!(table=open_ltable(thd, table_list, TL_READ_NO_INSERT)))
  671.     DBUG_RETURN(1);
  673.   if (!db || check_db_name(db))
  674.   {
  675.     net_printf(&thd->net,ER_WRONG_DB_NAME, db ? db : "NULL");
  676.     goto err;
  677.   }
  678.   if (check_access(thd, SELECT_ACL, db, &table_list->grant.privilege))
  679.     goto err;
  680.   if (grant_option && check_grant(thd, SELECT_ACL, table_list))
  681.     goto err;
  683.   thd->free_list = 0;
  684.   thd->query = tbl_name;
  685.   if((error = mysqld_dump_create_info(thd, table, -1)))
  686.     {
  687.       my_error(ER_GET_ERRNO, MYF(0));
  688.       goto err;
  689.     }
  690.   net_flush(&thd->net);
  691.   error = table->file->dump(thd,fd);
  692.   if(error)
  693.       my_error(ER_GET_ERRNO, MYF(0));
  695. err:
  697.   close_thread_tables(thd);
  699.   DBUG_RETURN(error);
  700. }
  704. /* Execute one command from socket (query or simple command) */
  706. bool do_command(THD *thd)
  707. {
  708.   char *packet;
  709.   uint old_timeout,packet_length;
  710.   bool error=0;
  711.   NET *net;
  712.   enum enum_server_command command;
  713.   // commands which will always take a long time should be marked with
  714.   // this so that they will not get logged to the slow query log
  715.   bool slow_command=FALSE;
  716.   DBUG_ENTER("do_command");
  718.   net= &thd->net;
  719.   thd->current_tablenr=0;
  721.   packet=0;
  722.   old_timeout=net->timeout;
  723.   net->timeout=thd->inactive_timeout; /* Wait max for 8 hours */
  724.   net->last_error[0]=0; // Clear error message
  725.   net->last_errno=0;
  727.   net_new_transaction(net);
  728.   if ((packet_length=my_net_read(net)) == packet_error)
  729.   {
  730.      DBUG_PRINT("general",("Got error reading command from socket %s",
  731. vio_description(net->vio) ));
  732.     return TRUE;
  733.   }
  734.   else
  735.   {
  736.     packet=(char*) net->read_pos;
  737.     command = (enum enum_server_command) (uchar) packet[0];
  738.     DBUG_PRINT("general",("Command on %s = %d (%s)",
  739.   vio_description(net->vio), command,
  740.   command_name[command]));
  741.   }
  742.   net->timeout=old_timeout; /* Timeout */
  743.   thd->command=command;
  744.   VOID(pthread_mutex_lock(&LOCK_thread_count));
  745.   thd->query_id=query_id;
  746.   if (command != COM_STATISTICS && command != COM_PING)
  747.     query_id++;
  748.   thread_running++;
  749.   VOID(pthread_mutex_unlock(&LOCK_thread_count));
  750.   thd->set_time();
  751.   thd->lex.options=0; // We store status here
  752.   switch(command) {
  753.   case COM_INIT_DB:
  754.     if (!mysql_change_db(thd,packet+1))
  755.       mysql_log.write(thd,command,"%s",thd->db);
  756.     break;
  757.   case COM_TABLE_DUMP:
  758.     {
  759.       slow_command = TRUE;
  760.       char* data = packet + 1;
  761.       uint db_len = *data;
  762.       uint tbl_len = *(data + db_len + 1);
  763.       char* db = sql_alloc(db_len + tbl_len + 2);
  764.       memcpy(db, data + 1, db_len);
  765.       char* tbl_name = db + db_len;
  766.       *tbl_name++ = 0;
  767.       memcpy(tbl_name, data + db_len + 2, tbl_len);
  768.       tbl_name[tbl_len] = 0;
  769.       if(mysql_table_dump(thd, db, tbl_name, -1))
  770. send_error(&thd->net); // dump to NET
  772.       break;
  773.     }
  774.   case COM_CHANGE_USER:
  775.   {
  776.     char *user=   (char*) packet+1;
  777.     char *passwd= strend(user)+1;
  778.     char *db=     strend(passwd)+1;
  780.     /* Save user and privileges */
  781.     uint save_master_access=thd->master_access;
  782.     uint save_db_access=    thd->db_access;
  783.     char *save_user=     thd->user;
  784.     char *save_priv_user=   thd->priv_user;
  785.     char *save_db=     thd->db;
  787.     if ((uint) ((uchar*) db - net->read_pos) > packet_length)
  788.     { // Check if protocol is ok
  789.       send_error(net, ER_UNKNOWN_COM_ERROR);
  790.       break;
  791.     }
  792.     if (check_user(thd, COM_CHANGE_USER, user, passwd, db, 0))
  793.     { // Restore old user
  794.       x_free(thd->user);
  795.       x_free(thd->db);
  796.       thd->master_access=save_master_access;
  797.       thd->db_access=save_db_access;
  798.       thd->db=save_db;
  799.       thd->user=save_user;
  800.       thd->priv_user=save_priv_user;
  801.       break;
  802.     }
  803.     decrease_user_connections (save_user, thd->host);
  804.     x_free((gptr) save_db);
  805.     x_free((gptr) save_user);
  806.     thd->password=test(passwd[0]);
  807.     break;
  808.   }
  810.   case COM_QUERY:
  811.   {
  812.     char *pos=packet+packet_length; // Point at end null
  813.     /* Remove garage at end of query */
  814.     while (packet_length > 0 && pos[-1] == ';')
  815.     {
  816.       pos--;
  817.       packet_length--;
  818.     }
  819.     *pos=0;
  820.     if (!(thd->query= (char*) thd->memdup((gptr) (packet+1),packet_length)))
  821.       break;
  822.     thd->packet.shrink(net_buffer_length); // Reclaim some memory
  823.     if (!(specialflag & SPECIAL_NO_PRIOR))
  824.       my_pthread_setprio(pthread_self(),QUERY_PRIOR);
  825.     mysql_log.write(thd,command,"%s",thd->query);
  826.     DBUG_PRINT("query",("%s",thd->query));
  827.     mysql_parse(thd,thd->query,packet_length-1);
  828.     if (!(specialflag & SPECIAL_NO_PRIOR))
  829.       my_pthread_setprio(pthread_self(),WAIT_PRIOR);
  830.     DBUG_PRINT("info",("query ready"));
  831.     break;
  832.   }
  833.   case COM_FIELD_LIST: // This isn't actually neaded
  834. #ifdef DONT_ALLOW_SHOW_COMMANDS
  835.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  836.     break;
  837. #else
  838.   {
  839.     char *fields;
  840.     TABLE_LIST table_list;
  841.     bzero((char*) &table_list,sizeof(table_list));
  842.     if (!(table_list.db=thd->db))
  843.     {
  844.       send_error(net,ER_NO_DB_ERROR);
  845.       break;
  846.     }
  847.     thd->free_list=0;
  848.     table_list.name=table_list.real_name=thd->strdup(packet+1);
  849.     thd->query=fields=thd->strdup(strend(packet+1)+1);
  850.     mysql_log.write(thd,command,"%s %s",table_list.real_name,fields);
  851.     remove_escape(table_list.real_name); // This can't have wildcards
  853.     if (check_access(thd,SELECT_ACL,table_list.db,&thd->col_access))
  854.       break;
  855.     table_list.grant.privilege=thd->col_access;
  856.     if (grant_option && check_grant(thd,SELECT_ACL,&table_list,2))
  857.       break;
  858.     mysqld_list_fields(thd,&table_list,fields);
  859.     free_items(thd);
  860.     break;
  861.   }
  862. #endif
  863.   case COM_QUIT:
  864.     mysql_log.write(thd,command,NullS);
  865.     net->error=0; // Don't give 'abort' message
  866.     error=TRUE; // End server
  867.     break;
  869.   case COM_CREATE_DB:
  870.     {
  871.       char *db=thd->strdup(packet+1);
  872.       // null test to handle EOM
  873.       if (!db || !stripp_sp(db) || check_db_name(db))
  874.       {
  875. net_printf(&thd->net,ER_WRONG_DB_NAME, db ? db : "NULL");
  876. break;
  877.       }
  878.       if (check_access(thd,CREATE_ACL,db,0,1))
  879. break;
  880.       mysql_log.write(thd,command,packet+1);
  881.       mysql_create_db(thd,db,0);
  882.       break;
  883.     }
  884.   case COM_DROP_DB:
  885.     {
  886.       char *db=thd->strdup(packet+1);
  887.       // null test to handle EOM
  888.       if (!db || !stripp_sp(db) || check_db_name(db))
  889.       {
  890. net_printf(&thd->net,ER_WRONG_DB_NAME, db ? db : "NULL");
  891. break;
  892.       }
  893.       if (check_access(thd,DROP_ACL,db,0,1) || end_active_trans(thd))
  894. break;
  895.       mysql_log.write(thd,command,db);
  896.       mysql_rm_db(thd,db,0);
  897.       break;
  898.     }
  899.   case COM_BINLOG_DUMP:
  900.     {
  901.       slow_command = TRUE;
  902.       if(check_access(thd, FILE_ACL, any_db))
  903. break;
  904.       mysql_log.write(thd,command, 0);
  906.       ulong pos;
  907.       ushort flags;
  908.       uint32 slave_server_id;
  909.       pos = uint4korr(packet + 1);
  910.       flags = uint2korr(packet + 5);
  911.       pthread_mutex_lock(&LOCK_server_id);
  912.       kill_zombie_dump_threads(slave_server_id = uint4korr(packet+7));
  913.       thd->server_id = slave_server_id;
  914.       pthread_mutex_unlock(&LOCK_server_id);
  915.       mysql_binlog_send(thd, thd->strdup(packet + 11), pos, flags);
  916.       // fake COM_QUIT -- if we get here, the thread needs to terminate
  917.       error = TRUE;
  918.       net->error = 0;
  919.       break;
  920.     }
  921.   case COM_REFRESH:
  922.     {
  923.       uint options=(uchar) packet[1];
  924.       if (check_access(thd,RELOAD_ACL,any_db))
  925. break;
  926.       mysql_log.write(thd,command,NullS);
  927.       if (reload_acl_and_cache(thd, options, (TABLE_LIST*) 0))
  928. send_error(net,0);
  929.       else
  930. send_eof(net);
  931.       break;
  932.     }
  933.   case COM_SHUTDOWN:
  934.     if (check_access(thd,SHUTDOWN_ACL,any_db))
  935.       break; /* purecov: inspected */
  936.     DBUG_PRINT("quit",("Got shutdown command"));
  937.     mysql_log.write(thd,command,NullS);
  938.     send_eof(net);
  939. #ifdef __WIN__
  940.     sleep(1); // must wait after eof()
  941. #endif
  942.     send_eof(net); // This is for 'quit request'
  943.     close_connection(net);
  944.     close_thread_tables(thd); // Free before kill
  945.     free_root(&thd->mem_root,MYF(0));
  946.     kill_mysql();
  947.     error=TRUE;
  948.     break;
  950.   case COM_STATISTICS:
  951.   {
  952.     mysql_log.write(thd,command,NullS);
  953.     char buff[200];
  954.     ulong uptime = (ulong) (thd->start_time - start_time);
  955.     sprintf((char*) buff,
  956.     "Uptime: %ld  Threads: %d  Questions: %lu  Slow queries: %ld  Opens: %ld  Flush tables: %ld  Open tables: %d Queries per second avg: %.3f",
  957.     uptime,
  958.     (int) thread_count,thd->query_id,long_query_count,
  959.     opened_tables,refresh_version, cached_tables(),
  960.     uptime ? (float)thd->query_id/(float)uptime : 0);
  961. #ifdef SAFEMALLOC
  962.     if (lCurMemory) // Using SAFEMALLOC
  963.       sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
  964.       (lCurMemory+1023L)/1024L,(lMaxMemory+1023L)/1024L);
  965.  #endif
  966.     VOID(my_net_write(net, buff,(uint) strlen(buff)));
  967.     VOID(net_flush(net));
  968.     break;
  969.   }
  970.   case COM_PING:
  971.     send_ok(net); // Tell client we are alive
  972.     break;
  973.   case COM_PROCESS_INFO:
  974.     if (!thd->priv_user[0] && check_access(thd,PROCESS_ACL,any_db))
  975.       break;
  976.     mysql_log.write(thd,command,NullS);
  977.     mysqld_list_processes(thd,thd->master_access & PROCESS_ACL ? NullS :
  978.   thd->priv_user,0);
  979.     break;
  980.   case COM_PROCESS_KILL:
  981.   {
  982.     ulong id=(ulong) uint4korr(packet+1);
  983.     kill_one_thread(thd,id);
  984.     break;
  985.   }
  986.   case COM_DEBUG:
  987.     if (check_access(thd,PROCESS_ACL,any_db))
  988.       break; /* purecov: inspected */
  989.     mysql_print_status(thd);
  990.     mysql_log.write(thd,command,NullS);
  991.     send_eof(net);
  992.     break;
  993.   case COM_SLEEP:
  994.   case COM_CONNECT: // Impossible here
  995.   case COM_TIME: // Impossible from client
  996.   case COM_DELAYED_INSERT:
  997.   default:
  998.     send_error(net, ER_UNKNOWN_COM_ERROR);
  999.     break;
  1000.   }
  1001.   if (thd->lock || thd->open_tables)
  1002.   {
  1003.     thd->proc_info="closing tables";
  1004.     close_thread_tables(thd); /* Free tables */
  1005.   }
  1007.   if (thd->fatal_error)
  1008.     send_error(net,0); // End of memory ?
  1010.   time_t start_of_query=thd->start_time;
  1011.   thd->end_time(); // Set start time
  1013.   /* If not reading from backup and if the query took too long */
  1014.   if (!slow_command && !thd->user_time) // do not log 'slow_command' queries
  1015.   {
  1016.     thd->proc_info="logging slow query";
  1018.     if ((ulong) (thd->start_time - thd->time_after_lock) > long_query_time ||
  1019. ((thd->lex.options &
  1020.   (QUERY_NO_INDEX_USED | QUERY_NO_GOOD_INDEX_USED)) &&
  1021.  (specialflag & SPECIAL_LONG_LOG_FORMAT)))
  1022.     {
  1023.       long_query_count++;
  1024.       mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
  1025.     }
  1026.   }
  1027.   thd->proc_info="cleaning up";
  1028.   VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
  1029.   thd->proc_info=0;
  1030.   thd->command=COM_SLEEP;
  1031.   thd->query=0;
  1032.   thread_running--;
  1033.   VOID(pthread_mutex_unlock(&LOCK_thread_count));
  1034.   thd->packet.shrink(net_buffer_length); // Reclaim some memory
  1035.   free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
  1036.   DBUG_RETURN(error);
  1037. }
  1039. /****************************************************************************
  1040. ** mysql_execute_command
  1041. ** Execute command saved in thd and current_lex->sql_command
  1042. ****************************************************************************/
  1044. void
  1045. mysql_execute_command(void)
  1046. {
  1047.   int res=0;
  1048.   THD *thd=current_thd;
  1049.   LEX *lex= &thd->lex;
  1050.   TABLE_LIST *tables=(TABLE_LIST*) lex->table_list.first;
  1051.   DBUG_ENTER("mysql_execute_command");
  1053.   if(table_rules_on && thd->slave_thread && tables && !tables_ok(thd,tables))
  1054.     DBUG_VOID_RETURN; // skip if we are in the slave thread, some table
  1055.   // rules have been given and the table list says the query should not be
  1056.   // replicated
  1057.   
  1058.   switch (lex->sql_command) {
  1059.   case SQLCOM_SELECT:
  1060.   {
  1061.     select_result *result;
  1062.     if (lex->options & SELECT_DESCRIBE)
  1063.       lex->exchange=0;
  1064.     if (tables)
  1065.     {
  1066.       res=check_table_access(thd,
  1067.      lex->exchange ? SELECT_ACL | FILE_ACL :
  1068.      SELECT_ACL,
  1069.      tables);
  1070.     }
  1071.     else
  1072.       res=check_access(thd, lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
  1073.        any_db);
  1074.     if (res)
  1075.     {
  1076.       res=0;
  1077.       break; // Error message is given
  1078.     }
  1080.     thd->offset_limit=lex->offset_limit;
  1081.     thd->select_limit=lex->select_limit+lex->offset_limit;
  1082.     if (thd->select_limit < lex->select_limit)
  1083.       thd->select_limit= HA_POS_ERROR; // no limit
  1085.     if (lex->exchange)
  1086.     {
  1087.       if (lex->exchange->dumpfile)
  1088.       {
  1089. if (!(result=new select_dump(lex->exchange)))
  1090. {
  1091.   res= -1;
  1092.   break;
  1093. }
  1094.       }
  1095.       else
  1096.       {
  1097. if (!(result=new select_export(lex->exchange)))
  1098. {
  1099.   res= -1;
  1100.   break;
  1101. }
  1102.       }
  1103.     }
  1104.     else if (!(result=new select_send()))
  1105.     {
  1106.       res= -1;
  1107. #ifdef DELETE_ITEMS
  1108.       delete lex->having;
  1109.       delete lex->where;
  1110. #endif
  1111.       break;
  1112.     }
  1114.     if (lex->options & SELECT_HIGH_PRIORITY)
  1115.     {
  1116.       TABLE_LIST *table;
  1117.       for (table = tables ; table ; table=table->next)
  1118. table->lock_type=TL_READ_HIGH_PRIORITY;
  1119.     }
  1121.     if (!(res=open_and_lock_tables(thd,tables)))
  1122.     {
  1123.       res=mysql_select(thd,tables,lex->item_list,
  1124.        lex->where,
  1125.                        lex->ftfunc_list,
  1126.        (ORDER*) lex->order_list.first,
  1127.        (ORDER*) lex->group_list.first,
  1128.        lex->having,
  1129.        (ORDER*) lex->proc_list.first,
  1130.        lex->options | thd->options,
  1131.        result);
  1132.       if (res)
  1133. result->abort();
  1134.     }
  1135.     delete result;
  1136. #ifdef DELETE_ITEMS
  1137.     delete lex->having;
  1138.     delete lex->where;
  1139. #endif
  1140.     break;
  1141.   }
  1142.   case SQLCOM_PURGE:
  1143.     {
  1144.       if(check_access(thd, PROCESS_ACL, any_db))
  1145. goto error;
  1146.       res = purge_master_logs(thd, lex->to_log);
  1147.       break;
  1148.     }
  1149.   case SQLCOM_BACKUP_TABLE:
  1150.     {
  1151.       if (check_db_used(thd,tables) ||
  1152.   check_table_access(thd,SELECT_ACL, tables) ||
  1153.   check_access(thd, FILE_ACL, any_db))
  1154. goto error; /* purecov: inspected */
  1155.       res = mysql_backup_table(thd, tables);
  1157.       break;
  1158.     }
  1159.   case SQLCOM_RESTORE_TABLE:
  1160.     {
  1161.       if (check_db_used(thd,tables) ||
  1162.   check_table_access(thd,INSERT_ACL, tables) ||
  1163.   check_access(thd, FILE_ACL, any_db))
  1164. goto error; /* purecov: inspected */
  1165.       res = mysql_restore_table(thd, tables);
  1166.       break;
  1167.     }
  1168.   case SQLCOM_CHANGE_MASTER:
  1169.     {
  1170.       if(check_access(thd, PROCESS_ACL, any_db))
  1171. goto error;
  1172.       res = change_master(thd);
  1173.       break;
  1174.     }
  1175.   case SQLCOM_SHOW_SLAVE_STAT:
  1176.     {
  1177.       if(check_access(thd, PROCESS_ACL, any_db))
  1178. goto error;
  1179.       res = show_master_info(thd);
  1180.       break;
  1181.     }
  1182.   case SQLCOM_SHOW_MASTER_STAT:
  1183.     {
  1184.       if (check_access(thd, PROCESS_ACL, any_db))
  1185. goto error;
  1186.       res = show_binlog_info(thd);
  1187.       break;
  1188.     }
  1189.   case SQLCOM_LOAD_MASTER_TABLE:
  1191.     if (!tables->db)
  1192.       tables->db=thd->db;
  1193.     if (check_access(thd,CREATE_ACL,tables->db,&tables->grant.privilege))
  1194.       goto error; /* purecov: inspected */
  1195.     if (grant_option)
  1196.     {
  1197.       /* Check that the first table has CREATE privilege */
  1198.       TABLE_LIST *tmp_table_list=tables->next;
  1199.       tables->next=0;
  1200.       bool error=check_grant(thd,CREATE_ACL,tables);
  1201.       tables->next=tmp_table_list;
  1202.       if (error)
  1203.   goto error;
  1204.     }
  1205.     if (strlen(tables->name) > NAME_LEN)
  1206.     {
  1207.       net_printf(&thd->net,ER_WRONG_TABLE_NAME,tables->name);
  1208.       res=0;
  1209.       break;
  1210.     }
  1212.     thd->last_nx_table = tables->real_name;
  1213.     thd->last_nx_db = tables->db;
  1214.     if(fetch_nx_table(thd, &glob_mi))
  1215.       // fetch_nx_table is responsible for sending
  1216.       // the error
  1217.       {
  1218. res = 0;
  1219. thd->net.no_send_ok = 0; // easier to do it here
  1220. // this way we make sure that when we are done, we are clean
  1221.         break;
  1222.       }
  1224.     res = 0;
  1225.     send_ok(&thd->net);
  1226.     break;
  1228.   case SQLCOM_CREATE_TABLE:
  1229.     if (!tables->db)
  1230.       tables->db=thd->db;
  1231.     if (check_access(thd,CREATE_ACL,tables->db,&tables->grant.privilege) ||
  1232. check_merge_table_access(thd, tables->db,
  1233.  (TABLE_LIST *)
  1234.  lex->create_info.merge_list.first))
  1235.       goto error; /* purecov: inspected */
  1236.     if (grant_option)
  1237.     {
  1238.       /* Check that the first table has CREATE privilege */
  1239.       TABLE_LIST *tmp_table_list=tables->next;
  1240.       tables->next=0;
  1241.       bool error=check_grant(thd,CREATE_ACL,tables);
  1242.       tables->next=tmp_table_list;
  1243.       if (error)
  1244. goto error;
  1245.     }
  1246.     if (strlen(tables->name) > NAME_LEN)
  1247.     {
  1248.       net_printf(&thd->net,ER_WRONG_TABLE_NAME,tables->name);
  1249.       res=0;
  1250.       break;
  1251.     }
  1252.     if (lex->item_list.elements) // With select
  1253.     {
  1254.       select_result *result;
  1256.       if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
  1257.   check_dup(thd,tables->db,tables->real_name,tables->next))
  1258.       {
  1259. net_printf(&thd->net,ER_INSERT_TABLE_USED,tables->real_name);
  1260. DBUG_VOID_RETURN;
  1261.       }
  1262.       if (tables->next)
  1263.       {
  1264. if (check_table_access(thd, SELECT_ACL, tables->next))
  1265.   goto error; // Error message is given
  1266.       }
  1267.       thd->offset_limit=lex->offset_limit;
  1268.       thd->select_limit=lex->select_limit+lex->offset_limit;
  1269.       if (thd->select_limit < lex->select_limit)
  1270. thd->select_limit= HA_POS_ERROR; // No limit
  1272.       if (!(res=open_and_lock_tables(thd,tables->next)))
  1273.       {
  1274. if ((result=new select_create(tables->db ? tables->db : thd->db,
  1275.       tables->real_name, &lex->create_info,
  1276.       lex->create_list,
  1277.       lex->key_list,
  1278.       lex->item_list,lex->duplicates)))
  1279. {
  1280.   res=mysql_select(thd,tables->next,lex->item_list,
  1281.    lex->where,
  1282.                            lex->ftfunc_list,
  1283.    (ORDER*) lex->order_list.first,
  1284.    (ORDER*) lex->group_list.first,
  1285.    lex->having,
  1286.    (ORDER*) lex->proc_list.first,
  1287.    lex->options | thd->options,
  1288.    result);
  1289.   if (res)
  1290.     result->abort();
  1291.   delete result;
  1292. }
  1293. else
  1294.   res= -1;
  1295.       }
  1296.     }
  1297.     else // regular create
  1298.     {
  1299.       res = mysql_create_table(thd,tables->db ? tables->db : thd->db,
  1300.        tables->real_name, &lex->create_info,
  1301.        lex->create_list,
  1302.        lex->key_list,0, 0); // do logging
  1303.       if (!res)
  1304. send_ok(&thd->net);
  1305.     }
  1306.     break;
  1307.   case SQLCOM_CREATE_INDEX:
  1308.     if (!tables->db)
  1309.       tables->db=thd->db;
  1310.     if (check_access(thd,INDEX_ACL,tables->db,&tables->grant.privilege))
  1311.       goto error; /* purecov: inspected */
  1312.     if (grant_option && check_grant(thd,INDEX_ACL,tables))
  1313.       goto error;
  1314.     if (end_active_trans(thd))
  1315.       res= -1;
  1316.     else
  1317.       res = mysql_create_index(thd, tables, lex->key_list);
  1318.     break;
  1320.   case SQLCOM_SLAVE_START:
  1321.     start_slave(thd);
  1322.     break;
  1323.   case SQLCOM_SLAVE_STOP:
  1324.     stop_slave(thd);
  1325.     break;
  1327.   case SQLCOM_ALTER_TABLE:
  1328. #if defined(DONT_ALLOW_SHOW_COMMANDS)
  1329.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  1330.     break;
  1331. #else
  1332.     {
  1333.       uint priv=0;
  1334.       if (lex->name && strlen(lex->name) > NAME_LEN)
  1335.       {
  1336. net_printf(&thd->net,ER_WRONG_TABLE_NAME,lex->name);
  1337. res=0;
  1338. break;
  1339.       }
  1340.       if (!tables->db)
  1341. tables->db=thd->db;
  1342.       if (!lex->db)
  1343. lex->db=tables->db;
  1344.       if (check_access(thd,ALTER_ACL,tables->db,&tables->grant.privilege) ||
  1345.   check_access(thd,INSERT_ACL | CREATE_ACL,lex->db,&priv) ||
  1346.   check_merge_table_access(thd, tables->db, 
  1347.    (TABLE_LIST *)
  1348.    lex->create_info.merge_list.first))
  1349. goto error; /* purecov: inspected */
  1350.       if (!tables->db)
  1351. tables->db=thd->db;
  1352.       if (grant_option)
  1353.       {
  1354. if (check_grant(thd,ALTER_ACL,tables))
  1355.   goto error;
  1356. if (lex->name && !test_all_bits(priv,INSERT_ACL | CREATE_ACL))
  1357. { // Rename of table
  1358.   TABLE_LIST tmp_table;
  1359.   bzero((char*) &tmp_table,sizeof(tmp_table));
  1360.   tmp_table.real_name=lex->name;
  1361.   tmp_table.db=lex->db;
  1362.   tmp_table.grant.privilege=priv;
  1363.   if (check_grant(thd,INSERT_ACL | CREATE_ACL,tables))
  1364.     goto error;
  1365. }
  1366.       }
  1367.       /* ALTER TABLE ends previous transaction */
  1368.       if (end_active_trans(thd))
  1369. res= -1;
  1370.       else
  1371. res= mysql_alter_table(thd, lex->db, lex->name,
  1372.        &lex->create_info,
  1373.        tables, lex->create_list,
  1374.        lex->key_list, lex->drop_list, lex->alter_list,
  1375.                                (ORDER *) lex->order_list.first,
  1376.        lex->drop_primary, lex->duplicates);
  1377.       break;
  1378.     }
  1379. #endif
  1380.   case SQLCOM_RENAME_TABLE:
  1381.   {
  1382.     TABLE_LIST *table;
  1383.     if (check_db_used(thd,tables))
  1384.       goto error;
  1385.     for (table=tables ; table ; table=table->next->next)
  1386.     {
  1387.       if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
  1388.        &table->grant.privilege) ||
  1389.   check_access(thd, INSERT_ACL | CREATE_ACL, table->next->db,
  1390.        &table->next->grant.privilege))
  1391. goto error;
  1392.       if (grant_option)
  1393.       {
  1394. TABLE_LIST old_list,new_list;
  1395. old_list=table[0];
  1396. new_list=table->next[0];
  1397. old_list.next=new_list.next=0;
  1398. if (check_grant(thd,ALTER_ACL,&old_list) ||
  1399.     (!test_all_bits(table->next->grant.privilege,
  1400.    INSERT_ACL | CREATE_ACL) &&
  1401.      check_grant(thd,INSERT_ACL | CREATE_ACL, &new_list)))
  1402.   goto error;
  1403.       }
  1404.     }
  1405.     if (end_active_trans(thd))
  1406.       res= -1;
  1407.     else if (mysql_rename_tables(thd,tables))
  1408.       res= -1;
  1409.     break;
  1410.   }
  1411.   case SQLCOM_SHOW_BINLOGS:
  1412. #ifdef DONT_ALLOW_SHOW_COMMANDS
  1413.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  1414.     DBUG_VOID_RETURN;
  1415. #else
  1416.     {
  1417.       if(check_access(thd, PROCESS_ACL, any_db))
  1418. goto error;
  1419.       res = show_binlogs(thd);
  1420.       break;
  1421.     }
  1422. #endif    
  1423.   case SQLCOM_SHOW_CREATE:
  1424. #ifdef DONT_ALLOW_SHOW_COMMANDS
  1425.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  1426.     DBUG_VOID_RETURN;
  1427. #else
  1428.     {
  1429.       if (check_db_used(thd, tables) ||
  1430.   check_access(thd, SELECT_ACL | EXTRA_ACL, tables->db,
  1431.        &tables->grant.privilege))
  1432. goto error;
  1433.       res = mysqld_show_create(thd, tables);
  1434.       break;
  1435.     }
  1436. #endif
  1437.   case SQLCOM_REPAIR:
  1438.     {
  1439.       if (check_db_used(thd,tables) ||
  1440.   check_table_access(thd,SELECT_ACL | INSERT_ACL, tables))
  1441. goto error; /* purecov: inspected */
  1442.       res = mysql_repair_table(thd, tables, &lex->check_opt);
  1443.       break;
  1444.     }
  1445.   case SQLCOM_CHECK:
  1446.     {
  1447.       if (check_db_used(thd,tables) ||
  1448.   check_table_access(thd, SELECT_ACL | EXTRA_ACL , tables))
  1449. goto error; /* purecov: inspected */
  1450.       res = mysql_check_table(thd, tables, &lex->check_opt);
  1451.       break;
  1452.     }
  1453.   case SQLCOM_ANALYZE:
  1454.   {
  1455.     if (check_db_used(thd,tables) ||
  1456. check_table_access(thd,SELECT_ACL | INSERT_ACL, tables))
  1457.       goto error; /* purecov: inspected */
  1458.     res = mysql_analyze_table(thd, tables, &lex->check_opt);
  1459.     break;
  1460.   }
  1462.   case SQLCOM_OPTIMIZE:
  1463.   {
  1464.     HA_CREATE_INFO create_info;
  1465.     if (check_db_used(thd,tables) ||
  1466. check_table_access(thd,SELECT_ACL | INSERT_ACL, tables))
  1467.       goto error; /* purecov: inspected */
  1468.     if (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC))
  1469.     {
  1470.       /* Use ALTER TABLE */
  1471.       lex->create_list.empty();
  1472.       lex->key_list.empty();
  1473.       lex->col_list.empty();
  1474.       lex->drop_list.empty();
  1475.       lex->alter_list.empty();
  1476.       bzero((char*) &create_info,sizeof(create_info));
  1477.       create_info.db_type=DB_TYPE_DEFAULT;
  1478.       create_info.row_type=ROW_TYPE_DEFAULT;
  1479.       res= mysql_alter_table(thd, NullS, NullS, &create_info,
  1480.      tables, lex->create_list,
  1481.      lex->key_list, lex->drop_list, lex->alter_list,
  1482.                              (ORDER *) 0,
  1483.      0,DUP_ERROR);
  1484.     }
  1485.     else
  1486.       res = mysql_optimize_table(thd, tables, &lex->check_opt);
  1487.     break;
  1488.   }
  1489.   case SQLCOM_UPDATE:
  1490.     if (check_access(thd,UPDATE_ACL,tables->db,&tables->grant.privilege))
  1491.       goto error;
  1492.     if (grant_option && check_grant(thd,UPDATE_ACL,tables))
  1493.       goto error;
  1494.     if (lex->item_list.elements != lex->value_list.elements)
  1495.     {
  1496.       send_error(&thd->net,ER_WRONG_VALUE_COUNT);
  1497.       DBUG_VOID_RETURN;
  1498.     }
  1499.     res = mysql_update(thd,tables,
  1500.        lex->item_list,
  1501.        lex->value_list,
  1502.        lex->where,
  1503.        lex->select_limit,
  1504.        lex->duplicates,
  1505.        lex->lock_option);
  1507. #ifdef DELETE_ITEMS
  1508.     delete lex->where;
  1509. #endif
  1510.     break;
  1511.   case SQLCOM_INSERT:
  1512.     if (check_access(thd,INSERT_ACL,tables->db,&tables->grant.privilege))
  1513.       goto error; /* purecov: inspected */
  1514.     if (grant_option && check_grant(thd,INSERT_ACL,tables))
  1515.       goto error;
  1516.     res = mysql_insert(thd,tables,lex->field_list,lex->many_values,
  1517.        lex->duplicates,
  1518.        lex->lock_option);
  1519.     break;
  1520.   case SQLCOM_REPLACE:
  1521.     if (check_access(thd,INSERT_ACL | UPDATE_ACL | DELETE_ACL,
  1522.      tables->db,&tables->grant.privilege))
  1523.       goto error; /* purecov: inspected */
  1524.     if (grant_option && check_grant(thd,INSERT_ACL | UPDATE_ACL | DELETE_ACL,
  1525.     tables))
  1527.       goto error;
  1528.     res = mysql_insert(thd,tables,lex->field_list,lex->many_values,
  1529.        DUP_REPLACE,
  1530.        lex->lock_option);
  1531.     break;
  1532.   case SQLCOM_REPLACE_SELECT:
  1533.   case SQLCOM_INSERT_SELECT:
  1534.   {
  1535.     // Check that we have modify privileges for the first table and
  1536.     // select privileges for the rest
  1537.     uint privilege= (lex->sql_command == SQLCOM_INSERT_SELECT ?
  1538.      INSERT_ACL : INSERT_ACL | UPDATE_ACL | DELETE_ACL);
  1539.     TABLE_LIST *save_next=tables->next;
  1540.     tables->next=0;
  1541.     if (check_access(thd, privilege,
  1542.      tables->db,&tables->grant.privilege) ||
  1543. (grant_option && check_grant(thd, privilege, tables)))
  1544.       goto error;
  1545.     tables->next=save_next;
  1546.     if ((res=check_table_access(thd, SELECT_ACL, save_next)))
  1547.       goto error;
  1549.     select_result *result;
  1550.     thd->offset_limit=lex->offset_limit;
  1551.     thd->select_limit=lex->select_limit+lex->offset_limit;
  1552.     if (thd->select_limit < lex->select_limit)
  1553.       thd->select_limit= HA_POS_ERROR; // No limit
  1555.     if (check_dup(thd,tables->db,tables->real_name,tables->next))
  1556.     {
  1557.       net_printf(&thd->net,ER_INSERT_TABLE_USED,tables->real_name);
  1558.       DBUG_VOID_RETURN;
  1559.     }
  1560.     tables->lock_type=TL_WRITE; // update first table
  1561.     if (!(res=open_and_lock_tables(thd,tables)))
  1562.     {
  1563.       if ((result=new select_insert(tables->table,&lex->field_list,
  1564.     lex->sql_command == SQLCOM_REPLACE_SELECT ?
  1565.     DUP_REPLACE : DUP_IGNORE)))
  1566.       {
  1567. res=mysql_select(thd,tables->next,lex->item_list,
  1568.  lex->where,
  1569.                          lex->ftfunc_list,
  1570.  (ORDER*) lex->order_list.first,
  1571.  (ORDER*) lex->group_list.first,
  1572.  lex->having,
  1573.  (ORDER*) lex->proc_list.first,
  1574.  lex->options | thd->options,
  1575.  result);
  1576. delete result;
  1577.       }
  1578.       else
  1579. res= -1;
  1580.     }
  1581. #ifdef DELETE_ITEMS
  1582.     delete lex->having;
  1583.     delete lex->where;
  1584. #endif
  1585.     break;
  1586.   }
  1587.   case SQLCOM_TRUNCATE:
  1588.     lex->where=0;
  1589.     lex->select_limit=HA_POS_ERROR;
  1590.     /* Fall through */
  1591.   case SQLCOM_DELETE:
  1592.   {
  1593.     if (check_access(thd,DELETE_ACL,tables->db,&tables->grant.privilege))
  1594.       goto error; /* purecov: inspected */
  1595.     if (grant_option && check_grant(thd,DELETE_ACL,tables))
  1596.       goto error;
  1597.     // Set privilege for the WHERE clause
  1598.     tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
  1599.     /* TRUNCATE ends previous transaction */
  1600.     if (lex->sql_command == SQLCOM_TRUNCATE && end_active_trans(thd))
  1601.       res= -1;
  1602.     else
  1603.       res = mysql_delete(thd,tables,lex->where,lex->select_limit,
  1604.  lex->lock_option, lex->options);
  1605.     break;
  1606.   }
  1607.   case SQLCOM_DROP_TABLE:
  1608.     {
  1609.       if (check_table_access(thd,DROP_ACL,tables))
  1610. goto error; /* purecov: inspected */
  1611.       if (end_active_trans(thd))
  1612. res= -1;
  1613.       else
  1614. res = mysql_rm_table(thd,tables,lex->drop_if_exists);
  1615.     }
  1616.     break;
  1617.   case SQLCOM_DROP_INDEX:
  1618.     if (!tables->db)
  1619.       tables->db=thd->db;
  1620.     if (check_access(thd,INDEX_ACL,tables->db,&tables->grant.privilege))
  1621.       goto error; /* purecov: inspected */
  1622.     if (grant_option && check_grant(thd,INDEX_ACL,tables))
  1623.       goto error;
  1624.     if (end_active_trans(thd))
  1625.       res= -1;
  1626.     else
  1627.       res = mysql_drop_index(thd, tables, lex->drop_list);
  1628.     break;
  1629.   case SQLCOM_SHOW_DATABASES:
  1630. #if defined(DONT_ALLOW_SHOW_COMMANDS)
  1631.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  1632.     DBUG_VOID_RETURN;
  1633. #else
  1634.     if ((specialflag & SPECIAL_SKIP_SHOW_DB) &&
  1635. check_access(thd,PROCESS_ACL,any_db))
  1636.       goto error;
  1637.     res= mysqld_show_dbs(thd, (lex->wild ? lex->wild->ptr() : NullS));
  1638.     break;
  1639. #endif
  1640.   case SQLCOM_SHOW_PROCESSLIST:
  1641.     if (!thd->priv_user[0] && check_access(thd,PROCESS_ACL,any_db))
  1642.       break;
  1643.     mysqld_list_processes(thd,thd->master_access & PROCESS_ACL ? NullS :
  1644.   thd->priv_user,lex->verbose);
  1645.     break;
  1646.   case SQLCOM_SHOW_STATUS:
  1647.     res= mysqld_show(thd,(lex->wild ? lex->wild->ptr() : NullS),status_vars);
  1648.     break;
  1649.   case SQLCOM_SHOW_VARIABLES:
  1650.     res= mysqld_show(thd, (lex->wild ? lex->wild->ptr() : NullS),
  1651.      init_vars);
  1652.     break;
  1653.   case SQLCOM_SHOW_LOGS:
  1654. #ifdef DONT_ALLOW_SHOW_COMMANDS
  1655.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  1656.     DBUG_VOID_RETURN;
  1657. #else
  1658.     {
  1659.       if (grant_option && check_access(thd, FILE_ACL, any_db))
  1660. goto error;
  1661.       res= mysqld_show_logs(thd);
  1662.       break;
  1663.     }
  1664. #endif
  1665.   case SQLCOM_SHOW_TABLES:
  1666.     /* FALL THROUGH */
  1667.   case SQLCOM_SHOW_OPEN_TABLES:
  1668. #ifdef DONT_ALLOW_SHOW_COMMANDS
  1669.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  1670.     DBUG_VOID_RETURN;
  1671. #else
  1672.     {
  1673.       char *db=lex->db ? lex->db : thd->db;
  1674.       if (!db)
  1675.       {
  1676. send_error(&thd->net,ER_NO_DB_ERROR); /* purecov: inspected */
  1677. goto error; /* purecov: inspected */
  1678.       }
  1679.       remove_escape(db); // Fix escaped '_'
  1680.       if (check_db_name(db))
  1681.       {
  1682.         net_printf(&thd->net,ER_WRONG_DB_NAME, db);
  1683.         goto error;
  1684.       }
  1685.       if (check_access(thd,SELECT_ACL,db,&thd->col_access))
  1686. goto error; /* purecov: inspected */
  1687.       /* grant is checked in mysqld_show_tables */
  1688.       if (lex->sql_command == SQLCOM_SHOW_OPEN_TABLES)
  1689.         res= mysqld_show_open_tables(thd,db,
  1690.      (lex->wild ? lex->wild->ptr() : NullS));
  1691.       else if (lex->options & SELECT_DESCRIBE)
  1692.         res= mysqld_extend_show_tables(thd,db,
  1693.      (lex->wild ? lex->wild->ptr() : NullS));
  1694.       else
  1695. res= mysqld_show_tables(thd,db,
  1696. (lex->wild ? lex->wild->ptr() : NullS));
  1697.       break;
  1698.     }
  1699. #endif
  1700.   case SQLCOM_SHOW_FIELDS:
  1701. #ifdef DONT_ALLOW_SHOW_COMMANDS
  1702.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  1703.     DBUG_VOID_RETURN;
  1704. #else
  1705.     {
  1706.       char *db=tables->db ? tables->db : thd->db;
  1707.       if (!db)
  1708.       {
  1709. send_error(&thd->net,ER_NO_DB_ERROR); /* purecov: inspected */
  1710. goto error; /* purecov: inspected */
  1711.       }
  1712.       remove_escape(db); // Fix escaped '_'
  1713.       remove_escape(tables->name);
  1714.       if (!tables->db)
  1715. tables->db=thd->db;
  1716.       if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,&thd->col_access))
  1717. goto error; /* purecov: inspected */
  1718.       tables->grant.privilege=thd->col_access;
  1719.       if (grant_option && check_grant(thd,SELECT_ACL,tables,2))
  1720. goto error;
  1721.       res= mysqld_show_fields(thd,tables,
  1722.       (lex->wild ? lex->wild->ptr() : NullS),
  1723.       lex->verbose);
  1724.       break;
  1725.     }
  1726. #endif
  1727.   case SQLCOM_SHOW_KEYS:
  1728. #ifdef DONT_ALLOW_SHOW_COMMANDS
  1729.     send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
  1730.     DBUG_VOID_RETURN;
  1731. #else
  1732.     {
  1733.       char *db=tables->db ? tables->db : thd->db;
  1734.       if (!db)
  1735.       {
  1736. send_error(&thd->net,ER_NO_DB_ERROR); /* purecov: inspected */
  1737. goto error; /* purecov: inspected */
  1738.       }
  1739.       remove_escape(db); // Fix escaped '_'
  1740.       remove_escape(tables->name);
  1741.       if (!tables->db)
  1742. tables->db=thd->db;
  1743.       if (check_access(thd,SELECT_ACL,db,&thd->col_access))
  1744. goto error; /* purecov: inspected */
  1745.       tables->grant.privilege=thd->col_access;
  1746.       if (grant_option && check_grant(thd,SELECT_ACL,tables,2))
  1747. goto error;
  1748.       res= mysqld_show_keys(thd,tables);
  1749.       break;
  1750.     }
  1751. #endif
  1752.   case SQLCOM_CHANGE_DB:
  1753.     mysql_change_db(thd,lex->db);
  1754.     break;
  1755.   case SQLCOM_LOAD:
  1756.   {
  1757.     uint privilege= (lex->duplicates == DUP_REPLACE ?
  1758.      INSERT_ACL | UPDATE_ACL | DELETE_ACL : INSERT_ACL);
  1759.     if (!(lex->local_file && (thd->client_capabilities & CLIENT_LOCAL_FILES)))
  1760.     {
  1761.       if (check_access(thd,privilege | FILE_ACL,tables->db))
  1762. goto error;
  1763.     }
  1764.     else
  1765.     {
  1766.       if (check_access(thd,privilege,tables->db,&tables->grant.privilege) ||
  1767.  grant_option && check_grant(thd,privilege,tables))
  1768. goto error;
  1769.     }
  1770.     res=mysql_load(thd, lex->exchange, tables, lex->field_list,
  1771.    lex->duplicates, (bool) lex->local_file, lex->lock_option);
  1772.     break;
  1773.   }
  1774.   case SQLCOM_SET_OPTION:
  1775.   {
  1776.     uint org_options=thd->options;
  1777.     thd->options=lex->options;
  1778.     thd->update_lock_default= ((thd->options & OPTION_LOW_PRIORITY_UPDATES) ?
  1779.        TL_WRITE_LOW_PRIORITY : TL_WRITE);
  1780.     thd->default_select_limit=lex->select_limit;
  1781.     DBUG_PRINT("info",("options: %ld  limit: %ld",
  1782.        thd->options,(long) thd->default_select_limit));
  1784.     /* Check if auto_commit mode changed */
  1785.     if ((org_options ^ lex->options) & OPTION_NOT_AUTO_COMMIT)
  1786.     {
  1787.       if ((org_options & OPTION_NOT_AUTO_COMMIT))
  1788.       {
  1789. /* We changed to auto_commit mode */
  1790. thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
  1791. thd->server_status|= SERVER_STATUS_AUTOCOMMIT;
  1792. if (ha_commit(thd))
  1793. {
  1794.   res= -1;
  1795.   break;
  1796. }
  1797.       }
  1798.       else
  1799.       {
  1800. thd->options&= ~(ulong) (OPTION_STATUS_NO_TRANS_UPDATE);
  1801. thd->server_status&= ~SERVER_STATUS_AUTOCOMMIT;
  1802.       }
  1803.     }
  1804.     send_ok(&thd->net);
  1805.     break;
  1806.   }
  1807.   case SQLCOM_UNLOCK_TABLES:
  1808.     if (thd->locked_tables)
  1809.     {
  1810.       thd->lock=thd->locked_tables;
  1811.       thd->locked_tables=0; // Will be automaticly closed
  1812.     }
  1813.     if (thd->global_read_lock)
  1814.     {
  1815.       thd->global_read_lock=0;
  1816.       pthread_mutex_lock(&LOCK_open);
  1817.       global_read_lock--;
  1818.       pthread_cond_broadcast(&COND_refresh);
  1819.       pthread_mutex_unlock(&LOCK_open);
  1820.     }
  1821.     send_ok(&thd->net);
  1822.     break;
  1823.   case SQLCOM_LOCK_TABLES:
  1824.     if (thd->locked_tables)
  1825.     {
  1826.       thd->lock=thd->locked_tables;
  1827.       thd->locked_tables=0; // Will be automaticly closed
  1828.       close_thread_tables(thd);
  1829.     }
  1830.     if (check_db_used(thd,tables) || end_active_trans(thd))
  1831.       goto error;
  1832.     thd->in_lock_tables=1;
  1833.     if (!(res=open_and_lock_tables(thd,tables)))
  1834.     {
  1835.       thd->locked_tables=thd->lock;
  1836.       thd->lock=0;
  1837.       send_ok(&thd->net);
  1838.     }
  1839.     thd->in_lock_tables=0;
  1840.     break;
  1841.   case SQLCOM_CREATE_DB:
  1842.     {
  1843.       if (!stripp_sp(lex->name) || check_db_name(lex->name))
  1844.       {
  1845. net_printf(&thd->net,ER_WRONG_DB_NAME, lex->name);
  1846. break;
  1847.       }
  1848.       if (check_access(thd,CREATE_ACL,lex->name,0,1))
  1849. break;
  1850.       mysql_create_db(thd,lex->name,lex->create_info.options);
  1851.       break;
  1852.     }
  1853.   case SQLCOM_DROP_DB:
  1854.     {
  1855.       if (!stripp_sp(lex->name) || check_db_name(lex->name))
  1856.       {
  1857. net_printf(&thd->net,ER_WRONG_DB_NAME, lex->name);
  1858. break;
  1859.       }
  1860.       if (check_access(thd,DROP_ACL,lex->name,0,1) ||
  1861.   end_active_trans(thd))
  1862. break;
  1863.       mysql_rm_db(thd,lex->name,lex->drop_if_exists);
  1864.       break;
  1865.     }
  1866.   case SQLCOM_CREATE_FUNCTION:
  1867.     if (check_access(thd,INSERT_ACL,"mysql",0,1))
  1868.       break;
  1869. #ifdef HAVE_DLOPEN
  1870.     if (!(res = mysql_create_function(thd,&lex->udf)))
  1871.       send_ok(&thd->net);
  1872. #else
  1873.     res= -1;
  1874. #endif
  1875.     break;
  1876.   case SQLCOM_DROP_FUNCTION:
  1877.     if (check_access(thd,DELETE_ACL,"mysql",0,1))
  1878.       break;
  1879. #ifdef HAVE_DLOPEN
  1880.     if (!(res = mysql_drop_function(thd,lex->udf.name)))
  1881.       send_ok(&thd->net);
  1882. #else
  1883.     res= -1;
  1884. #endif
  1885.     break;
  1886.  case SQLCOM_REVOKE:
  1887.  case SQLCOM_GRANT:
  1888.    {
  1889.      if (tables && !tables->db)
  1890.        tables->db=thd->db;
  1891.      if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
  1892.       tables && tables->db ? tables->db : lex->db,
  1893.       tables ? &tables->grant.privilege : 0,
  1894.       tables ? 0 : 1))
  1895.        goto error;
  1897.      /* Check that the user isn't trying to change a password for another
  1898. user if he doesn't have UPDATE privilege to the MySQL database */
  1900.      if (thd->user) // If not replication
  1901.      {
  1902.        LEX_USER *user;
  1903.        List_iterator <LEX_USER> user_list(lex->users_list);
  1904.        while ((user=user_list++))
  1905.        {
  1906.  if (user->password.str &&
  1907.      (strcmp(thd->user,user->user.str) ||
  1908.       user->host.str &&
  1909.       my_strcasecmp(user->host.str, thd->host ? thd->host : thd->ip)))
  1910.  {
  1911.    if (check_access(thd, UPDATE_ACL, "mysql",0,1))
  1912.      goto error;
  1913.    break; // We are allowed to do changes
  1914.  }
  1915.        }
  1916.      }
  1917.      if (tables)
  1918.      {
  1919.        if (grant_option && check_grant(thd,
  1920.        (lex->grant | lex->grant_tot_col |
  1921. GRANT_ACL),
  1922.        tables))
  1923.  goto error;
  1924.        res = mysql_table_grant(thd,tables,lex->users_list, lex->columns,
  1925.        lex->grant, lex->sql_command == SQLCOM_REVOKE);
  1926.        if(!res)
  1927.        {
  1928.  mysql_update_log.write(thd, thd->query,thd->query_length);
  1929.  if (mysql_bin_log.is_open())
  1930.  {
  1931.    Query_log_event qinfo(thd, thd->query);
  1932.    mysql_bin_log.write(&qinfo);
  1933.  }
  1934.        }
  1935.      }
  1936.      else
  1937.      {
  1938.        if (lex->columns.elements)
  1939.        {
  1940.  net_printf(&thd->net,ER_ILLEGAL_GRANT_FOR_TABLE);
  1941.  res=1;
  1942.        }
  1943.        else
  1944.  res = mysql_grant(thd, lex->db, lex->users_list, lex->grant,
  1945.    lex->sql_command == SQLCOM_REVOKE);
  1946.        if(!res)
  1947.        {
  1948.  mysql_update_log.write(thd, thd->query,thd->query_length);
  1949.  if (mysql_bin_log.is_open())
  1950.  {
  1951.    Query_log_event qinfo(thd, thd->query);
  1952.    mysql_bin_log.write(&qinfo);
  1953.  }
  1954.        }
  1955.      }
  1956.      break;
  1957.    }
  1958.   case SQLCOM_FLUSH:
  1959.   case SQLCOM_RESET:
  1960.     if (check_access(thd,RELOAD_ACL,any_db) || check_db_used(thd, tables))
  1961.       goto error;
  1962.     if (reload_acl_and_cache(thd, lex->type, tables))
  1963.       send_error(&thd->net,0);
  1964.     else
  1965.       send_ok(&thd->net);
  1966.     break;
  1967.   case SQLCOM_KILL:
  1968.     kill_one_thread(thd,lex->thread_id);
  1969.     break;
  1970.   case SQLCOM_SHOW_GRANTS:
  1971.     res=0;
  1972.     if ((thd->priv_user && !strcmp(thd->priv_user,lex->grant_user->user.str)) ||
  1973. !check_access(thd, SELECT_ACL, "mysql",0,1))
  1974.     {
  1975.       res = mysql_show_grants(thd,lex->grant_user);
  1976.     }
  1977.     break;
  1978.   case SQLCOM_BEGIN:
  1979.     if (end_active_trans(thd))
  1980.     {
  1981.       res= -1;
  1982.     }
  1983.     else
  1984.     {
  1985.       thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
  1986.      OPTION_BEGIN);
  1987.       thd->server_status|= SERVER_STATUS_IN_TRANS;
  1988.       send_ok(&thd->net);
  1989.     }
  1990.     break;
  1991.   case SQLCOM_COMMIT:
  1992.     /*
  1993.       We don't use end_active_trans() here to ensure that this works
  1994.       even if there is a problem with the OPTION_AUTO_COMMIT flag
  1995.       (Which of course should never happen...)
  1996.     */
  1997.     thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
  1998.     thd->server_status&= ~SERVER_STATUS_IN_TRANS;
  1999.     if (!ha_commit(thd))
  2000.       send_ok(&thd->net);
  2001.     else
  2002.       res= -1;
  2003.     break;
  2004.   case SQLCOM_ROLLBACK:
  2005.     thd->server_status&= ~SERVER_STATUS_IN_TRANS;
  2006.     if (!ha_rollback(thd))
  2007.     {
  2008.       if (thd->options & OPTION_STATUS_NO_TRANS_UPDATE)
  2009. send_warning(&thd->net,ER_WARNING_NOT_COMPLETE_ROLLBACK,0);
  2010.       else
  2011. send_ok(&thd->net);
  2012.     }
  2013.     else
  2014.       res= -1;
  2015.     thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
  2016.     break;
  2017.   default: /* Impossible */
  2018.     send_ok(&thd->net);
  2019.     break;
  2020.   }
  2021.   thd->proc_info="query end"; // QQ
  2022.   if (res < 0)
  2023.     send_error(&thd->net,thd->killed ? ER_SERVER_SHUTDOWN : 0);
  2025. error:
  2026.   DBUG_VOID_RETURN;
  2027. }
  2030. /****************************************************************************
  2031. ** Get the user (global) and database privileges for all used tables
  2032. ** Returns true (error) if we can't get the privileges and we don't use
  2033. ** table/column grants.
  2034. ** The idea of EXTRA_ACL is that one will be granted access to the table if
  2035. ** one has the asked privilege on any column combination of the table; For
  2036. ** example to be able to check a table one needs to have SELECT privilege on
  2037. ** any column of the table.
  2038. ****************************************************************************/
  2040. bool
  2041. check_access(THD *thd,uint want_access,const char *db, uint *save_priv,
  2042.      bool dont_check_global_grants)
  2043. {
  2044.   uint db_access,dummy;
  2045.   if (save_priv)
  2046.     *save_priv=0;
  2047.   else
  2048.     save_priv= &dummy;
  2050.   if (!db && !thd->db && !dont_check_global_grants)
  2051.   {
  2052.     send_error(&thd->net,ER_NO_DB_ERROR); /* purecov: tested */
  2053.     return TRUE; /* purecov: tested */
  2054.   }
  2056.   if ((thd->master_access & want_access) == want_access)
  2057.   {
  2058.     *save_priv=thd->master_access;
  2059.     return FALSE;
  2060.   }
  2061.   if ((want_access & ~thd->master_access) & ~(DB_ACLS | EXTRA_ACL) ||
  2062.       ! db && dont_check_global_grants)
  2063.   { // We can never grant this
  2064.     net_printf(&thd->net,ER_ACCESS_DENIED_ERROR,
  2065.        thd->priv_user,
  2066.        thd->host ? thd->host : (thd->ip ? thd->ip : "unknown"),
  2067.        thd->password ? ER(ER_YES) : ER(ER_NO));/* purecov: tested */
  2068.     return TRUE; /* purecov: tested */
  2069.   }
  2071.   if (db == any_db)
  2072.     return FALSE; // Allow select on anything
  2073.   
  2074.   if (db && (!thd->db || strcmp(db,thd->db)))
  2075.     db_access=acl_get(thd->host, thd->ip, (char*) &thd->remote.sin_addr,
  2076.       thd->priv_user, db); /* purecov: inspected */
  2077.   else
  2078.     db_access=thd->db_access;
  2079.   want_access &= ~EXTRA_ACL; // Remove SHOW attribute
  2080.   db_access= ((*save_priv=(db_access | thd->master_access)) & want_access);
  2082.   /* grant_option is set if there exists a single table or column grant */
  2083.   if (db_access == want_access ||
  2084.       ((grant_option && !dont_check_global_grants) &&
  2085.        !(want_access & ~TABLE_ACLS)))
  2086.     return FALSE; /* Ok */
  2087.   net_printf(&thd->net,ER_DBACCESS_DENIED_ERROR,
  2088.      thd->priv_user,
  2089.      thd->host ? thd->host : (thd->ip ? thd->ip : "unknown"),
  2090.      db ? db : thd->db ? thd->db : "unknown"); /* purecov: tested */
  2091.   return TRUE; /* purecov: tested */
  2092. }
  2095. /*
  2096. ** Check the privilege for all used tables.  Table privileges are cached
  2097. ** in the table list for GRANT checking
  2098. */
  2100. static bool
  2101. check_table_access(THD *thd,uint want_access,TABLE_LIST *tables)
  2102. {
  2103.   uint found=0,found_access=0;
  2104.   TABLE_LIST *org_tables=tables;
  2105.   for (; tables ; tables=tables->next)
  2106.   {
  2107.     if ((thd->master_access & want_access) == (want_access & ~EXTRA_ACL) &&
  2108. thd->db)
  2109.       tables->grant.privilege= want_access;
  2110.     else if (tables->db && tables->db == thd->db)
  2111.     {
  2112.       if (found && !grant_option) // db already checked
  2113. tables->grant.privilege=found_access;
  2114.       else
  2115.       {
  2116. if (check_access(thd,want_access,tables->db,&tables->grant.privilege))
  2117.   return TRUE; // Access denied
  2118. found_access=tables->grant.privilege;
  2119. found=1;
  2120.       }
  2121.     }
  2122.     else if (check_access(thd,want_access,tables->db,&tables->grant.privilege))
  2123.       return TRUE; // Access denied
  2124.   }
  2125.   if (grant_option)
  2126.   {
  2127.     want_access &= ~EXTRA_ACL; // Remove SHOW attribute
  2128.     return check_grant(thd,want_access,org_tables);
  2129.   }
  2130.   return FALSE;
  2131. }
  2134. static bool check_db_used(THD *thd,TABLE_LIST *tables)
  2135. {
  2136.   for (; tables ; tables=tables->next)
  2137.   {
  2138.     if (!tables->db)
  2139.     {
  2140.       if (!(tables->db=thd->db))
  2141.       {
  2142. send_error(&thd->net,ER_NO_DB_ERROR); /* purecov: tested */
  2143. return TRUE; /* purecov: tested */
  2144.       }
  2145.     }
  2146.   }
  2147.   return FALSE;
  2148. }
  2151. static bool check_merge_table_access(THD *thd, char *db,
  2152.      TABLE_LIST *table_list)
  2153. {
  2154.   int error=0;
  2155.   if (table_list)
  2156.   {
  2157.     /* Force all tables to use the current database */
  2158.     TABLE_LIST *tmp;
  2159.     for (tmp=table_list; tmp ; tmp=tmp->next)
  2160.       tmp->db=db;
  2161.     error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
  2162.      table_list);
  2163.   }
  2164.   return error;
  2165. }
  2168. /****************************************************************************
  2169. Check stack size; Send error if there isn't enough stack to continue
  2170. ****************************************************************************/
  2172. #if STACK_DIRECTION < 0
  2173. #define used_stack(A,B) (long) (A - B)
  2174. #else
  2175. #define used_stack(A,B) (long) (B - A)
  2176. #endif
  2178. bool check_stack_overrun(THD *thd,char *buf __attribute__((unused)))
  2179. {
  2180.   long stack_used;
  2181.   if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
  2182.       (long) thread_stack_min)
  2183.   {
  2184.     sprintf(errbuff[0],ER(ER_STACK_OVERRUN),stack_used,thread_stack);
  2185.     my_message(ER_STACK_OVERRUN,errbuff[0],MYF(0));
  2186.     thd->fatal_error=1;
  2187.     return 1;
  2188.   }
  2189.   return 0;
  2190. }
  2192. #define MY_YACC_INIT 1000 // Start with big alloc
  2193. #define MY_YACC_MAX  32000 // Because of 'short'
  2195. bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, int *yystacksize)
  2196. {
  2197.   LEX *lex=current_lex;
  2198.   int  old_info=0;
  2199.   if ((uint) *yystacksize >= MY_YACC_MAX)
  2200.     return 1;
  2201.   if (!lex->yacc_yyvs)
  2202.     old_info= *yystacksize;
  2203.   *yystacksize= set_zone((*yystacksize)*2,MY_YACC_INIT,MY_YACC_MAX);
  2204.   if (!(lex->yacc_yyvs= (char*)
  2205. my_realloc((gptr) lex->yacc_yyvs,
  2206.    *yystacksize*sizeof(**yyvs),
  2207.    MYF(MY_ALLOW_ZERO_PTR | MY_FREE_ON_ERROR))) ||
  2208.       !(lex->yacc_yyss= (char*)
  2209. my_realloc((gptr) lex->yacc_yyss,
  2210.    *yystacksize*sizeof(**yyss),
  2211.    MYF(MY_ALLOW_ZERO_PTR | MY_FREE_ON_ERROR))))
  2212.     return 1;
  2213.   if (old_info)
  2214.   { // Copy old info from stack
  2215.     memcpy(lex->yacc_yyss, (gptr) *yyss, old_info*sizeof(**yyss));
  2216.     memcpy(lex->yacc_yyvs, (gptr) *yyvs, old_info*sizeof(**yyvs));
  2217.   }
  2218.   *yyss=(short*) lex->yacc_yyss;
  2219.   *yyvs=(YYSTYPE*) lex->yacc_yyvs;
  2220.   return 0;
  2221. }
  2224. /****************************************************************************
  2225. Initialize global thd variables neaded for query
  2226. ****************************************************************************/
  2228. static void
  2229. mysql_init_query(THD *thd)
  2230. {
  2231.   DBUG_ENTER("mysql_init_query");
  2232.   thd->lex.item_list.empty();
  2233.   thd->lex.value_list.empty();
  2234.   thd->lex.table_list.elements=0;
  2235.   thd->free_list=0;
  2237.   thd->lex.table_list.first=0;
  2238.   thd->lex.table_list.next= (byte**) &thd->lex.table_list.first;
  2239.   thd->fatal_error=0; // Safety
  2240.   thd->last_insert_id_used=thd->query_start_used=thd->insert_id_used=0;
  2241.   thd->sent_row_count=0;
  2242.   DBUG_VOID_RETURN;
  2243. }
  2245. void
  2246. mysql_init_select(LEX *lex)
  2247. {
  2248.   lex->where=lex->having=0;
  2249.   lex->select_limit=current_thd->default_select_limit;
  2250.   lex->offset_limit=0L;
  2251.   lex->options=0;
  2252.   lex->exchange = 0;
  2253.   lex->proc_list.first=0;
  2254.   lex->order_list.elements=lex->group_list.elements=0;
  2255.   lex->order_list.first=0;
  2256.   lex->order_list.next= (byte**) &lex->order_list.first;
  2257.   lex->group_list.first=0;
  2258.   lex->group_list.next= (byte**) &lex->group_list.first;
  2259. }
  2262. void
  2263. mysql_parse(THD *thd,char *inBuf,uint length)
  2264. {
  2265.   DBUG_ENTER("mysql_parse");
  2267.   mysql_init_query(thd);
  2268.   thd->query_length = length;
  2269.   LEX *lex=lex_start(thd, (uchar*) inBuf, length);
  2270.   if (!yyparse() && ! thd->fatal_error)
  2271.     mysql_execute_command();
  2272.   thd->proc_info="freeing items";
  2273.   free_items(thd);  /* Free strings used by items */
  2274.   lex_end(lex);
  2275.   DBUG_VOID_RETURN;
  2276. }
  2279. inline static void
  2280. link_in_list(SQL_LIST *list,byte *element,byte **next)
  2281. {
  2282.   list->elements++;
  2283.   (*list->next)=element;
  2284.   list->next=next;
  2285.   *next=0;
  2286. }
  2289. /*****************************************************************************
  2290. ** Store field definition for create
  2291. ** Return 0 if ok
  2292. ******************************************************************************/
  2294. bool add_field_to_list(char *field_name, enum_field_types type,
  2295.        char *length, char *decimals,
  2296.        uint type_modifier, Item *default_value,char *change,
  2297.        TYPELIB *interval)
  2298. {
  2299.   register create_field *new_field;
  2300.   THD *thd=current_thd;
  2301.   LEX  *lex= &thd->lex;
  2302.   uint allowed_type_modifier=0;
  2303.   DBUG_ENTER("add_field_to_list");
  2305.   if (strlen(field_name) > NAME_LEN)
  2306.   {
  2307.     net_printf(&thd->net, ER_TOO_LONG_IDENT, field_name); /* purecov: inspected */
  2308.     DBUG_RETURN(1); /* purecov: inspected */
  2309.   }
  2310.   if (type_modifier & PRI_KEY_FLAG)
  2311.   {
  2312.     lex->col_list.push_back(new key_part_spec(field_name,0));
  2313.     lex->key_list.push_back(new Key(Key::PRIMARY,NullS,
  2314.     lex->col_list));
  2315.     lex->col_list.empty();
  2316.   }
  2317.   if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  2318.   {
  2319.     lex->col_list.push_back(new key_part_spec(field_name,0));
  2320.     lex->key_list.push_back(new Key(Key::UNIQUE,NullS,
  2321.     lex->col_list));
  2322.     lex->col_list.empty();
  2323.   }
  2325.   if (default_value && default_value->type() == Item::NULL_ITEM)
  2326.   {
  2327.     if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
  2328. NOT_NULL_FLAG)
  2329.     {
  2330.       net_printf(&thd->net,ER_INVALID_DEFAULT,field_name);
  2331.       DBUG_RETURN(1);
  2332.     }
  2333.     default_value=0;
  2334.   }
  2335.   if (!(new_field=new create_field()))
  2336.     DBUG_RETURN(1);
  2337.   new_field->field=0;
  2338.   new_field->field_name=field_name;
  2339.   new_field->def= (type_modifier & AUTO_INCREMENT_FLAG ? 0 : default_value);
  2340.   new_field->flags= type_modifier;
  2341.   new_field->unireg_check= (type_modifier & AUTO_INCREMENT_FLAG ?
  2342.     Field::NEXT_NUMBER : Field::NONE);
  2343.   new_field->decimals= decimals ? (uint) set_zone(atoi(decimals),0,
  2344.   NOT_FIXED_DEC-1) : 0;
  2345.   new_field->sql_type=type;
  2346.   new_field->length=0;
  2347.   new_field->change=change;
  2348.   new_field->interval=0;
  2349.   new_field->pack_length=0;
  2350.   if (length)
  2351.     if (!(new_field->length= (uint) atoi(length)))
  2352.       length=0; /* purecov: inspected */
  2353.   uint sign_len=type_modifier & UNSIGNED_FLAG ? 0 : 1;
  2355.   if (new_field->length && new_field->decimals &&
  2356.       new_field->length < new_field->decimals+2 &&
  2357.       new_field->decimals != NOT_FIXED_DEC)
  2358.     new_field->length=new_field->decimals+2; /* purecov: inspected */
  2360.   switch (type) {
  2361.   case FIELD_TYPE_TINY:
  2362.     if (!length) new_field->length=3+sign_len;
  2363.     allowed_type_modifier= AUTO_INCREMENT_FLAG;
  2364.     break;
  2365.   case FIELD_TYPE_SHORT:
  2366.     if (!length) new_field->length=5+sign_len;
  2367.     allowed_type_modifier= AUTO_INCREMENT_FLAG;
  2368.     break;
  2369.   case FIELD_TYPE_INT24:
  2370.     if (!length) new_field->length=8+sign_len;
  2371.     allowed_type_modifier= AUTO_INCREMENT_FLAG;
  2372.     break;
  2373.   case FIELD_TYPE_LONG:
  2374.     if (!length) new_field->length=10+sign_len;
  2375.     allowed_type_modifier= AUTO_INCREMENT_FLAG;
  2376.     break;
  2377.   case FIELD_TYPE_LONGLONG:
  2378.     if (!length) new_field->length=20;
  2379.     allowed_type_modifier= AUTO_INCREMENT_FLAG;
  2380.     break;
  2381.   case FIELD_TYPE_STRING:
  2382.   case FIELD_TYPE_VAR_STRING:
  2383.   case FIELD_TYPE_NULL:
  2384.     break;
  2385.   case FIELD_TYPE_DECIMAL:
  2386.     if (!length)
  2387.       new_field->length = 10; // Default length for DECIMAL
  2388.     new_field->length+=sign_len;
  2389.     if (new_field->decimals)
  2390.       new_field->length++;
  2391.     break;
  2392.   case FIELD_TYPE_BLOB:
  2393.   case FIELD_TYPE_TINY_BLOB:
  2394.   case FIELD_TYPE_LONG_BLOB:
  2395.   case FIELD_TYPE_MEDIUM_BLOB:
  2396.     if (default_value) // Allow empty as default value
  2397.     {
  2398.       String str,*res;
  2399.       res=default_value->val_str(&str);
  2400.       if (res->length())
  2401.       {
  2402. net_printf(&thd->net,ER_BLOB_CANT_HAVE_DEFAULT,field_name); /* purecov: inspected */
  2403. DBUG_RETURN(1); /* purecov: inspected */
  2404.       }
  2405.       new_field->def=0;
  2406.     }
  2407.     new_field->flags|=BLOB_FLAG;
  2408.     break;
  2409.   case FIELD_TYPE_YEAR:
  2410.     if (!length || new_field->length != 2)
  2411.       new_field->length=4; // Default length
  2412.     new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
  2413.     break;
  2414.   case FIELD_TYPE_FLOAT:
  2415.     /* change FLOAT(precision) to FLOAT or DOUBLE */
  2416.     allowed_type_modifier= AUTO_INCREMENT_FLAG;
  2417.     if (length && !decimals)
  2418.     {
  2419.       uint tmp_length=new_field->length;
  2420.       if (tmp_length > PRECISION_FOR_DOUBLE)
  2421.       {
  2422. net_printf(&thd->net,ER_WRONG_FIELD_SPEC,field_name);
  2423. DBUG_RETURN(1);
  2424.       }
  2425.       else if (tmp_length > PRECISION_FOR_FLOAT)
  2426.       {
  2427. new_field->sql_type=FIELD_TYPE_DOUBLE;
  2428. new_field->length=DBL_DIG+7; // -[digits].E+###
  2429.       }
  2430.       else
  2431. new_field->length=FLT_DIG+6; // -[digits].E+##
  2432.       new_field->decimals= NOT_FIXED_DEC;
  2433.       break;
  2434.     }
  2435.     if (!length)
  2436.     {
  2437.       new_field->length =  FLT_DIG+6;
  2438.       new_field->decimals= NOT_FIXED_DEC;
  2439.     }
  2440.     break;
  2441.   case FIELD_TYPE_DOUBLE:
  2442.     allowed_type_modifier= AUTO_INCREMENT_FLAG;
  2443.     if (!length)
  2444.     {
  2445.       new_field->length = DBL_DIG+7;
  2446.       new_field->decimals=NOT_FIXED_DEC;
  2447.     }
  2448.     break;
  2449.   case FIELD_TYPE_TIMESTAMP:
  2450.     if (!length)
  2451.       new_field->length= 14; // Full date YYYYMMDDHHMMSS
  2452.     else
  2453.     {
  2454.       new_field->length=((new_field->length+1)/2)*2; /* purecov: inspected */
  2455.       new_field->length= min(new_field->length,14); /* purecov: inspected */
  2456.     }
  2457.     new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG | NOT_NULL_FLAG;
  2458.     break;
  2459.   case FIELD_TYPE_DATE: // Old date type
  2460.     if (protocol_version != PROTOCOL_VERSION-1)
  2461.       new_field->sql_type=FIELD_TYPE_NEWDATE;
  2462.     /* fall trough */
  2463.   case FIELD_TYPE_NEWDATE:
  2464.     new_field->length=10;
  2465.     break;
  2466.   case FIELD_TYPE_TIME:
  2467.     new_field->length=10;
  2468.     break;
  2469.   case FIELD_TYPE_DATETIME:
  2470.     new_field->length=19;
  2471.     break;
  2472.   case FIELD_TYPE_SET:
  2473.     {
  2474.       if (interval->count > sizeof(longlong)*8)
  2475.       {
  2476. net_printf(&thd->net,ER_TOO_BIG_SET,field_name); /* purecov: inspected */
  2477. DBUG_RETURN(1); /* purecov: inspected */
  2478.       }
  2479.       new_field->pack_length=(interval->count+7)/8;
  2480.       if (new_field->pack_length > 4)
  2481. new_field->pack_length=8;
  2482.       new_field->interval=interval;
  2483.       new_field->length=0;
  2484.       for (const char **pos=interval->type_names; *pos ; pos++)
  2485. new_field->length+=(uint) strlen(*pos)+1;
  2486.       new_field->length--;
  2487.       set_if_smaller(new_field->length,MAX_FIELD_WIDTH-1);
  2488.       if (default_value)
  2489.       {
  2490. thd->cuted_fields=0;
  2491. String str,*res;
  2492. res=default_value->val_str(&str);
  2493. (void) find_set(interval,res->ptr(),res->length());
  2494. if (thd->cuted_fields)
  2495. {
  2496.   net_printf(&thd->net,ER_INVALID_DEFAULT,field_name);
  2497.   DBUG_RETURN(1);
  2498. }
  2499.       }
  2500.     }
  2501.     break;
  2502.   case FIELD_TYPE_ENUM:
  2503.     {
  2504.       new_field->interval=interval;
  2505.       new_field->pack_length=interval->count < 256 ? 1 : 2; // Should be safe
  2506.       new_field->length=(uint) strlen(interval->type_names[0]);
  2507.       for (const char **pos=interval->type_names+1; *pos ; pos++)
  2508.       {
  2509. uint length=(uint) strlen(*pos);
  2510. set_if_bigger(new_field->length,length);
  2511.       }
  2512.       set_if_smaller(new_field->length,MAX_FIELD_WIDTH-1);
  2513.       if (default_value)
  2514.       {
  2515. String str,*res;
  2516. res=default_value->val_str(&str);
  2517. if (!find_enum(interval,res->ptr(),res->length()))
  2518. {
  2519.   net_printf(&thd->net,ER_INVALID_DEFAULT,field_name);
  2520.   DBUG_RETURN(1);
  2521. }
  2522.       }
  2523.       break;
  2524.     }
  2525.   }
  2527.   if (new_field->length >= MAX_FIELD_WIDTH ||
  2528.       (!new_field->length && !(new_field->flags & BLOB_FLAG) &&
  2529.        type != FIELD_TYPE_STRING))
  2530.   {
  2531.     net_printf(&thd->net,ER_TOO_BIG_FIELDLENGTH,field_name,
  2532.        MAX_FIELD_WIDTH-1); /* purecov: inspected */
  2533.     DBUG_RETURN(1); /* purecov: inspected */
  2534.   }
  2535.   type_modifier&= AUTO_INCREMENT_FLAG;
  2536.   if ((~allowed_type_modifier) & type_modifier)
  2537.   {
  2538.     net_printf(&thd->net,ER_WRONG_FIELD_SPEC,field_name);
  2539.     DBUG_RETURN(1);
  2540.   }
  2541.   if (!new_field->pack_length)
  2542.     new_field->pack_length=calc_pack_length(new_field->sql_type ==
  2543.     FIELD_TYPE_VAR_STRING ?
  2544.     FIELD_TYPE_STRING :
  2545.     new_field->sql_type,
  2546.     new_field->length);
  2547.   lex->create_list.push_back(new_field);
  2548.   lex->last_field=new_field;
  2549.   DBUG_RETURN(0);
  2550. }
  2552. /* Store position for column in ALTER TABLE .. ADD column */
  2554. void store_position_for_column(const char *name)
  2555. {
  2556.   current_lex->last_field->after=my_const_cast(char*) (name);
  2557. }
  2559. bool
  2560. add_proc_to_list(Item *item)
  2561. {
  2562.   ORDER *order;
  2563.   Item **item_ptr;
  2565.   if (!(order = (ORDER *) sql_alloc(sizeof(ORDER)+sizeof(Item*))))
  2566.     return 1;
  2567.   item_ptr = (Item**) (order+1);
  2568.   *item_ptr= item;
  2569.   order->item=item_ptr;
  2570.   order->free_me=0;
  2571.   link_in_list(&current_lex->proc_list,(byte*) order,(byte**) &order->next);
  2572.   return 0;
  2573. }
  2576. /* Fix escaping of _, % and  in database and table names (for ODBC) */
  2578. static void remove_escape(char *name)
  2579. {
  2580.   char *to;
  2581. #ifdef USE_MB
  2582.   char *strend=name+(uint) strlen(name);
  2583. #endif
  2584.   for (to=name; *name ; name++)
  2585.   {
  2586. #ifdef USE_MB
  2587.     int l;
  2588. /*    if ((l = ismbchar(name, name+MBMAXLEN))) { Wei He: I think it's wrong */
  2589.     if (use_mb(default_charset_info) &&
  2590.         (l = my_ismbchar(default_charset_info, name, strend)))
  2591.     {
  2592. while (l--)
  2593.     *to++ = *name++;
  2594. name--;
  2595. continue;
  2596.     }
  2597. #endif
  2598.     if (*name == '\' && name[1])
  2599.       name++; // Skipp '\'
  2600.     *to++= *name;
  2601.   }
  2602.   *to=0;
  2603. }
  2605. /****************************************************************************
  2606. ** save order by and tables in own lists
  2607. ****************************************************************************/
  2610. bool add_to_list(SQL_LIST &list,Item *item,bool asc)
  2611. {
  2612.   ORDER *order;
  2613.   Item **item_ptr;
  2614.   DBUG_ENTER("add_to_list");
  2615.   if (!(order = (ORDER *) sql_alloc(sizeof(ORDER)+sizeof(Item*))))
  2616.     DBUG_RETURN(1);
  2617.   item_ptr = (Item**) (order+1);
  2618.   *item_ptr=item;
  2619.   order->item= item_ptr;
  2620.   order->asc = asc;
  2621.   order->free_me=0;
  2622.   order->used=0;
  2623.   link_in_list(&list,(byte*) order,(byte**) &order->next);
  2624.   DBUG_RETURN(0);
  2625. }
  2628. TABLE_LIST *add_table_to_list(Table_ident *table, LEX_STRING *alias,
  2629.       bool updating,
  2630.       thr_lock_type flags,
  2631.       List<String> *use_index,
  2632.       List<String> *ignore_index
  2633.       )
  2634. {
  2635.   register TABLE_LIST *ptr;
  2636.   THD *thd=current_thd;
  2637.   char *alias_str;
  2638.   const char *current_db;
  2639.   DBUG_ENTER("add_table_to_list");
  2641.   if (!table)
  2642.     DBUG_RETURN(0); // End of memory
  2643.   alias_str= alias ? alias->str : table->table.str;
  2644.   if (table->table.length > NAME_LEN ||
  2645.       check_table_name(table->table.str,table->table.length) ||
  2646.       table->db.str && check_db_name(table->db.str))
  2647.   {
  2648.     net_printf(&thd->net,ER_WRONG_TABLE_NAME,table->table.str);
  2649.     DBUG_RETURN(0);
  2650.   }
  2652. #ifdef FN_LOWER_CASE
  2653.   if (!alias) /* Alias is case sensitive */
  2654.     if (!(alias_str=sql_strmake(alias_str,table->table.length)))
  2655.       DBUG_RETURN(0);
  2656.   if (lower_case_table_names)
  2657.     casedn_str(table->table.str);
  2658. #endif
  2659.   if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
  2660.     DBUG_RETURN(0); /* purecov: inspected */
  2661.   ptr->db= table->db.str;
  2662.   ptr->real_name=table->table.str;
  2663.   ptr->name=alias_str;
  2664.   ptr->lock_type=flags;
  2665.   ptr->updating=updating;
  2666.   if (use_index)
  2667.     ptr->use_index=(List<String> *) thd->memdup((gptr) use_index,
  2668.        sizeof(*use_index));
  2669.   if (ignore_index)
  2670.     ptr->ignore_index=(List<String> *) thd->memdup((gptr) ignore_index,
  2671.    sizeof(*ignore_index));
  2673.   /* check that used name is unique */
  2674.   current_db=thd->db ? thd->db : "";
  2676.   if (flags != TL_IGNORE)
  2677.   {
  2678.     for (TABLE_LIST *tables=(TABLE_LIST*) thd->lex.table_list.first ; tables ;
  2679.  tables=tables->next)
  2680.     {
  2681.       if (!strcmp(alias_str,tables->name) &&
  2682.   !strcmp(ptr->db ? ptr->db : current_db,
  2683.   tables->db ? tables->db : current_db))
  2684.       {
  2685. net_printf(&thd->net,ER_NONUNIQ_TABLE,alias_str); /* purecov: tested */
  2686. DBUG_RETURN(0); /* purecov: tested */
  2687.       }
  2688.     }
  2689.   }
  2690.   link_in_list(&thd->lex.table_list,(byte*) ptr,(byte**) &ptr->next);
  2691.   DBUG_RETURN(ptr);
  2692. }
  2694. void add_join_on(TABLE_LIST *b,Item *expr)
  2695. {
  2696.   if (!b->on_expr)
  2697.     b->on_expr=expr;
  2698.   else
  2699.   {
  2700.     // This only happens if you have both a right and left join
  2701.     b->on_expr=new Item_cond_and(b->on_expr,expr);
  2702.   }
  2703. }
  2706. void add_join_natural(TABLE_LIST *a,TABLE_LIST *b)
  2707. {
  2708.   b->natural_join=a;
  2709. }
  2711. /* Check if name is used in table list */
  2713. static bool check_dup(THD *thd,const char *db,const char *name,
  2714.       TABLE_LIST *tables)
  2715. {
  2716.   const char *thd_db=thd->db ? thd->db : any_db;
  2717.   for (; tables ; tables=tables->next)
  2718.     if (!strcmp(name,tables->real_name) &&
  2719. !strcmp(db ? db : thd_db, tables->db ? tables->db : thd_db))
  2720.       return 1;
  2721.   return 0;
  2722. }
  2724. bool reload_acl_and_cache(THD *thd, uint options, TABLE_LIST *tables)
  2725. {
  2726.   bool result=0;
  2728.   select_errors=0; /* Write if more errors */
  2729.   // mysql_log.flush(); // Flush log
  2730.   if (options & REFRESH_GRANT)
  2731.   {
  2732.     acl_reload();
  2733.     grant_reload();
  2734.   }
  2735.   if (options & REFRESH_LOG)
  2736.   {
  2737.     mysql_log.new_file();
  2738.     mysql_update_log.new_file();
  2739.     mysql_bin_log.new_file();
  2740.     mysql_slow_log.new_file();
  2741.     if (ha_flush_logs())
  2742.       result=1;
  2743.   }
  2744.   if (options & (REFRESH_TABLES | REFRESH_READ_LOCK))
  2745.   {
  2746.     if ((options & REFRESH_READ_LOCK) && thd && ! thd->global_read_lock)
  2747.     {
  2748.       thd->global_read_lock=1;
  2749.       thread_safe_increment(global_read_lock,&LOCK_open);
  2750.     }
  2751.     result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
  2752.   }
  2753.   if (options & REFRESH_HOSTS)
  2754.     hostname_cache_refresh();
  2755.   if (options & REFRESH_STATUS)
  2756.     refresh_status();
  2757.   if (options & REFRESH_THREADS)
  2758.     flush_thread_cache();
  2759.   if (options & REFRESH_MASTER)
  2760.     reset_master();
  2761.   if (options & REFRESH_SLAVE)
  2762.     reset_slave();
  2764.   return result;
  2765. }
  2768. void kill_one_thread(THD *thd, ulong id)
  2769. {
  2770.   VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  2771.   I_List_iterator<THD> it(threads);
  2772.   THD *tmp;
  2773.   uint error=ER_NO_SUCH_THREAD;
  2774.   while ((tmp=it++))
  2775.   {
  2776.     if (tmp->thread_id == id)
  2777.     {
  2778.       if ((thd->master_access & PROCESS_ACL) ||
  2779.   !strcmp(thd->user,tmp->user))
  2780.       {
  2781. tmp->prepare_to_die();
  2782. error=0;
  2783.       }
  2784.       else
  2785. error=ER_KILL_DENIED_ERROR;
  2786.       break; // Found thread
  2787.     }
  2788.   }
  2789.   VOID(pthread_mutex_unlock(&LOCK_thread_count));
  2790.   if (!error)
  2791.     send_ok(&thd->net);
  2792.   else
  2793.     net_printf(&thd->net,error,id);
  2794. }
  2796. /* Clear most status variables */
  2798. static void refresh_status(void)
  2799. {
  2800.   pthread_mutex_lock(&THR_LOCK_keycache);
  2801.   pthread_mutex_lock(&LOCK_status);
  2802.   for (struct show_var_st *ptr=status_vars; ptr->name; ptr++)
  2803.   {
  2804.     if (ptr->type == SHOW_LONG)
  2805.       *(ulong*) ptr->value=0;
  2806.   }
  2807.   pthread_mutex_unlock(&LOCK_status);
  2808.   pthread_mutex_unlock(&THR_LOCK_keycache);
  2809. }