sql_parse.cc 226 KB
Newer Older
1
/* Copyright (C) 2000-2003 MySQL AB
2

unknown's avatar
unknown committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
6

unknown's avatar
unknown committed
7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
11

unknown's avatar
unknown committed
12 13 14 15
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

16
#define MYSQL_LEX 1
unknown's avatar
unknown committed
17
#include "mysql_priv.h"
18
#include "sql_repl.h"
19
#include "repl_failsafe.h"
unknown's avatar
unknown committed
20 21 22 23
#include <m_ctype.h>
#include <myisam.h>
#include <my_dir.h>

unknown's avatar
unknown committed
24
#ifdef HAVE_INNOBASE_DB
25
#include "ha_innodb.h"
unknown's avatar
unknown committed
26 27
#endif

28 29 30 31
#ifdef HAVE_NDBCLUSTER_DB
#include "ha_ndbcluster.h"
#endif

32
#include "sp_head.h"
33
#include "sp.h"
34
#include "sp_cache.h"
35
#include "sql_trigger.h"
36

unknown's avatar
unknown committed
37 38 39 40 41 42 43 44 45 46 47
#ifdef HAVE_OPENSSL
/*
  Without SSL the handshake consists of one packet. This packet
  has both client capabilites and scrambled password.
  With SSL the handshake might consist of two packets. If the first
  packet (client capabilities) has CLIENT_SSL flag set, we have to
  switch to SSL and read the second packet. The scrambled password
  is in the second packet and client_capabilites field will be ignored.
  Maybe it is better to accept flags other than CLIENT_SSL from the
  second packet?
*/
unknown's avatar
unknown committed
48 49 50
#define SSL_HANDSHAKE_SIZE      2
#define NORMAL_HANDSHAKE_SIZE   6
#define MIN_HANDSHAKE_SIZE      2
unknown's avatar
unknown committed
51
#else
unknown's avatar
unknown committed
52
#define MIN_HANDSHAKE_SIZE      6
unknown's avatar
unknown committed
53
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
54

55 56 57 58 59 60
/* Used in error handling only */
#define SP_TYPE_STRING(LP) \
  ((LP)->sphead->m_type == TYPE_ENUM_FUNCTION ? "FUNCTION" : "PROCEDURE")
#define SP_COM_STRING(LP) \
  ((LP)->sql_command == SQLCOM_CREATE_SPFUNCTION || \
   (LP)->sql_command == SQLCOM_ALTER_FUNCTION || \
61
   (LP)->sql_command == SQLCOM_SHOW_CREATE_FUNC || \
62 63 64
   (LP)->sql_command == SQLCOM_DROP_FUNCTION ? \
   "FUNCTION" : "PROCEDURE")

65 66 67
#ifdef SOLARIS
extern "C" int gethostname(char *name, int namelen);
#endif
unknown's avatar
unknown committed
68

unknown's avatar
unknown committed
69
#ifndef NO_EMBEDDED_ACCESS_CHECKS
70
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
71
static int check_for_max_user_connections(THD *thd, USER_CONN *uc);
72
static void decrease_user_connections(USER_CONN *uc);
73
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
74
static bool check_db_used(THD *thd,TABLE_LIST *tables);
unknown's avatar
unknown committed
75
static void remove_escape(char *name);
unknown's avatar
unknown committed
76 77
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name);
unknown's avatar
unknown committed
78

79
const char *any_db="*any*";	// Special symbol for check_access
unknown's avatar
unknown committed
80 81 82 83

const char *command_name[]={
  "Sleep", "Quit", "Init DB", "Query", "Field List", "Create DB",
  "Drop DB", "Refresh", "Shutdown", "Statistics", "Processlist",
84
  "Connect","Kill","Debug","Ping","Time","Delayed insert","Change user",
unknown's avatar
unknown committed
85
  "Binlog Dump","Table Dump",  "Connect Out", "Register Slave",
86
  "Prepare", "Execute", "Long Data", "Close stmt",
87
  "Reset stmt", "Set option", "Fetch",
88
  "Error"					// Last command number
unknown's avatar
unknown committed
89 90
};

unknown's avatar
unknown committed
91 92 93 94
const char *xa_state_names[]={
  "NON-EXISTING", "ACTIVE", "IDLE", "PREPARED"
};

unknown's avatar
unknown committed
95 96 97
#ifdef __WIN__
static void  test_signal(int sig_ptr)
{
unknown's avatar
unknown committed
98
#if !defined( DBUG_OFF)
unknown's avatar
unknown committed
99 100
  MessageBox(NULL,"Test signal","DBUG",MB_OK);
#endif
unknown's avatar
unknown committed
101
#if defined(OS2)
102 103
  fprintf(stderr, "Test signal %d\n", sig_ptr);
  fflush(stderr);
unknown's avatar
unknown committed
104
#endif
unknown's avatar
unknown committed
105 106 107 108
}
static void init_signals(void)
{
  int signals[7] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGBREAK,SIGABRT } ;
109
  for (int i=0 ; i < 7 ; i++)
unknown's avatar
unknown committed
110 111 112 113
    signal( signals[i], test_signal) ;
}
#endif

unknown's avatar
unknown committed
114 115 116 117 118
static void unlock_locked_tables(THD *thd)
{
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
119
    thd->locked_tables=0;			// Will be automatically closed
unknown's avatar
unknown committed
120 121 122 123
    close_thread_tables(thd);			// Free tables
  }
}

124

unknown's avatar
unknown committed
125
static bool end_active_trans(THD *thd)
126
{
unknown's avatar
unknown committed
127
  int error=0;
128
  DBUG_ENTER("end_active_trans");
129
  if (unlikely(thd->in_sub_stmt))
130 131 132 133
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
134 135 136 137 138 139
  if (thd->transaction.xid_state.xa_state != XA_NOTR)
  {
    my_error(ER_XAER_RMFAIL, MYF(0),
             xa_state_names[thd->transaction.xid_state.xa_state]);
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
140
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
unknown's avatar
unknown committed
141
		      OPTION_TABLE_LOCK))
142
  {
143
    DBUG_PRINT("info",("options: 0x%llx", thd->options));
144 145 146
    /* Safety if one did "drop table" on locked tables */
    if (!thd->locked_tables)
      thd->options&= ~OPTION_TABLE_LOCK;
147
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
148
    if (ha_commit(thd))
unknown's avatar
unknown committed
149
      error=1;
150
    thd->options&= ~(OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
151
  }
152
  DBUG_RETURN(error);
153 154
}

unknown's avatar
unknown committed
155 156 157
static bool begin_trans(THD *thd)
{
  int error=0;
158
  if (unlikely(thd->in_sub_stmt))
159 160 161 162
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    return 1;
  }
unknown's avatar
unknown committed
163 164 165 166 167 168 169 170 171 172
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
    thd->locked_tables=0;			// Will be automatically closed
    close_thread_tables(thd);			// Free tables
  }
  if (end_active_trans(thd))
    error= -1;
  else
  {
173
    LEX *lex= thd->lex;
174
    thd->options= ((thd->options &  ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
unknown's avatar
unknown committed
175 176 177
		   OPTION_BEGIN);
    thd->server_status|= SERVER_STATUS_IN_TRANS;
    if (lex->start_transaction_opt & MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT)
unknown's avatar
unknown committed
178
      error= ha_start_consistent_snapshot(thd);
unknown's avatar
unknown committed
179 180 181
  }
  return error;
}
182

unknown's avatar
unknown committed
183
#ifdef HAVE_REPLICATION
184 185 186
/*
  Returns true if all tables should be ignored
*/
187 188
inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables)
{
unknown's avatar
unknown committed
189
  return table_rules_on && tables && !tables_ok(thd,tables);
190
}
unknown's avatar
unknown committed
191
#endif
192 193


194 195 196 197 198 199 200 201 202 203 204 205
static bool some_non_temp_table_to_be_updated(THD *thd, TABLE_LIST *tables)
{
  for (TABLE_LIST *table= tables; table; table= table->next_global)
  {
    DBUG_ASSERT(table->db && table->table_name);
    if (table->updating &&
        !find_temporary_table(thd, table->db, table->table_name))
      return 1;
  }
  return 0;
}

206
#ifndef NO_EMBEDDED_ACCESS_CHECKS
207 208
static HASH hash_user_connections;

unknown's avatar
unknown committed
209 210
static int get_or_create_user_conn(THD *thd, const char *user,
				   const char *host,
unknown's avatar
unknown committed
211
				   USER_RESOURCES *mqh)
212
{
213
  int return_val= 0;
unknown's avatar
unknown committed
214
  uint temp_len, user_len;
215
  char temp_user[USER_HOST_BUFF_SIZE];
216 217 218 219 220
  struct  user_conn *uc;

  DBUG_ASSERT(user != 0);
  DBUG_ASSERT(host != 0);

221
  user_len= strlen(user);
222
  temp_len= (strmov(strmov(temp_user, user)+1, host) - temp_user)+1;
223
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
224 225
  if (!(uc = (struct  user_conn *) hash_search(&hash_user_connections,
					       (byte*) temp_user, temp_len)))
226
  {
unknown's avatar
unknown committed
227 228 229
    /* First connection for user; Create a user connection object */
    if (!(uc= ((struct user_conn*)
	       my_malloc(sizeof(struct user_conn) + temp_len+1,
unknown's avatar
unknown committed
230 231
			 MYF(MY_WME)))))
    {
232
      net_send_error(thd, 0, NullS);		// Out of memory
233
      return_val= 1;
234
      goto end;
unknown's avatar
unknown committed
235
    }
236 237
    uc->user=(char*) (uc+1);
    memcpy(uc->user,temp_user,temp_len+1);
238
    uc->host= uc->user + user_len +  1;
239
    uc->len= temp_len;
240
    uc->connections= uc->questions= uc->updates= uc->conn_per_hour= 0;
241 242
    uc->user_resources= *mqh;
    uc->intime= thd->thr_create_time;
unknown's avatar
SCRUM  
unknown committed
243
    if (my_hash_insert(&hash_user_connections, (byte*) uc))
244 245
    {
      my_free((char*) uc,0);
246
      net_send_error(thd, 0, NullS);		// Out of memory
247
      return_val= 1;
248 249 250 251
      goto end;
    }
  }
  thd->user_connect=uc;
252
  uc->connections++;
253 254 255
end:
  (void) pthread_mutex_unlock(&LOCK_user_conn);
  return return_val;
unknown's avatar
unknown committed
256

257
}
258
#endif /* !NO_EMBEDDED_ACCESS_CHECKS */
259 260 261


/*
262 263
  Check if user exist and password supplied is correct. 

264 265
  SYNOPSIS
    check_user()
266
    thd          thread handle, thd->security_ctx->{host,user,ip} are used
267 268 269
    command      originator of the check: now check_user is called
                 during connect and change user procedures; used for 
                 logging.
270
    passwd       scrambled password received from client
271 272 273 274
    passwd_len   length of scrambled password
    db           database name to connect to, may be NULL
    check_count  dont know exactly

275
    Note, that host, user and passwd may point to communication buffer.
276
    Current implementation does not depend on that, but future changes
277 278 279
    should be done with this in mind; 'thd' is INOUT, all other params
    are 'IN'.

280
  RETURN VALUE
281 282
    0  OK; thd->security_ctx->user/master_access/priv_user/db_access and
       thd->db are updated; OK is sent to client;
unknown's avatar
unknown committed
283 284
   -1  access denied or handshake error; error is sent to client;
   >0  error, not sent to client
unknown's avatar
unknown committed
285 286
*/

unknown's avatar
unknown committed
287 288 289
int check_user(THD *thd, enum enum_server_command command, 
	       const char *passwd, uint passwd_len, const char *db,
	       bool check_count)
unknown's avatar
unknown committed
290
{
291
  DBUG_ENTER("check_user");
unknown's avatar
unknown committed
292
  
unknown's avatar
unknown committed
293
#ifdef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
294
  thd->main_security_ctx.master_access= GLOBAL_ACLS;       // Full rights
295
  /* Change database if necessary */
296 297
  if (db && db[0])
  {
298 299 300 301
    /*
      thd->db is saved in caller and needs to be freed by caller if this
      function returns 0
    */
unknown's avatar
unknown committed
302
    thd->reset_db(NULL, 0);
303
    if (mysql_change_db(thd, db, FALSE))
304
    {
305 306
      /* Send the error to the client */
      net_send_error(thd);
307
      DBUG_RETURN(-1);
unknown's avatar
unknown committed
308
    }
309
  }
310
  send_ok(thd);
311
  DBUG_RETURN(0);
unknown's avatar
unknown committed
312 313
#else

314 315 316 317 318
  my_bool opt_secure_auth_local;
  pthread_mutex_lock(&LOCK_global_system_variables);
  opt_secure_auth_local= opt_secure_auth;
  pthread_mutex_unlock(&LOCK_global_system_variables);
  
319
  /*
320 321
    If the server is running in secure auth mode, short scrambles are 
    forbidden.
322
  */
323
  if (opt_secure_auth_local && passwd_len == SCRAMBLE_LENGTH_323)
unknown's avatar
unknown committed
324
  {
325
    net_printf_error(thd, ER_NOT_SUPPORTED_AUTH_MODE);
326 327
    mysql_log.write(thd, COM_CONNECT, ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
328
  }
unknown's avatar
unknown committed
329 330 331 332
  if (passwd_len != 0 &&
      passwd_len != SCRAMBLE_LENGTH &&
      passwd_len != SCRAMBLE_LENGTH_323)
    DBUG_RETURN(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
333

334
  /*
335
    Clear thd->db as it points to something, that will be freed when 
336
    connection is closed. We don't want to accidentally free a wrong pointer
337 338
    if connect failed. Also in case of 'CHANGE USER' failure, current
    database will be switched to 'no database selected'.
339
  */
unknown's avatar
unknown committed
340 341
  thd->reset_db(NULL, 0);

342
  USER_RESOURCES ur;
343
  int res= acl_getroot(thd, &ur, passwd, passwd_len);
unknown's avatar
unknown committed
344
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
345
  if (res == -1)
unknown's avatar
unknown committed
346
  {
unknown's avatar
unknown committed
347 348 349 350 351 352
    /*
      This happens when client (new) sends password scrambled with
      scramble(), but database holds old value (scrambled with
      scramble_323()). Here we please client to send scrambled_password
      in old format.
    */
353
    NET *net= &thd->net;
354
    if (opt_secure_auth_local)
355
    {
356
      net_printf_error(thd, ER_SERVER_IS_IN_SECURE_AUTH_MODE,
357 358
                       thd->main_security_ctx.user,
                       thd->main_security_ctx.host_or_ip);
359
      mysql_log.write(thd, COM_CONNECT, ER(ER_SERVER_IS_IN_SECURE_AUTH_MODE),
360 361
                      thd->main_security_ctx.user,
                      thd->main_security_ctx.host_or_ip);
362 363
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
364
    /* We have to read very specific packet size */
365
    if (send_old_password_request(thd) ||
unknown's avatar
unknown committed
366
        my_net_read(net) != SCRAMBLE_LENGTH_323 + 1)
367
    {
unknown's avatar
unknown committed
368 369 370 371 372
      inc_host_errors(&thd->remote.sin_addr);
      DBUG_RETURN(ER_HANDSHAKE_ERROR);
    }
    /* Final attempt to check the user based on reply */
    /* So as passwd is short, errcode is always >= 0 */
373
    res= acl_getroot(thd, &ur, (char *) net->read_pos, SCRAMBLE_LENGTH_323);
unknown's avatar
unknown committed
374
  }
unknown's avatar
unknown committed
375
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
376 377
  /* here res is always >= 0 */
  if (res == 0)
unknown's avatar
unknown committed
378
  {
379 380
    if (!(thd->main_security_ctx.master_access &
          NO_ACCESS)) // authentication is OK
381
    {
unknown's avatar
unknown committed
382
      DBUG_PRINT("info",
unknown's avatar
unknown committed
383
                 ("Capabilities: %lu  packet_length: %ld  Host: '%s'  "
unknown's avatar
unknown committed
384
                  "Login user: '%s' Priv_user: '%s'  Using password: %s "
unknown's avatar
unknown committed
385
                  "Access: %lu  db: '%s'",
386 387 388 389 390
                  thd->client_capabilities,
                  thd->max_client_packet_length,
                  thd->main_security_ctx.host_or_ip,
                  thd->main_security_ctx.user,
                  thd->main_security_ctx.priv_user,
unknown's avatar
unknown committed
391
                  passwd_len ? "yes": "no",
392 393
                  thd->main_security_ctx.master_access,
                  (thd->db ? thd->db : "*none*")));
unknown's avatar
unknown committed
394 395

      if (check_count)
396
      {
unknown's avatar
unknown committed
397
        VOID(pthread_mutex_lock(&LOCK_thread_count));
unknown's avatar
unknown committed
398
        bool count_ok= thread_count <= max_connections + delayed_insert_threads
399
                       || (thd->main_security_ctx.master_access & SUPER_ACL);
unknown's avatar
unknown committed
400 401
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
        if (!count_ok)
unknown's avatar
unknown committed
402
        {                                         // too many connections
403
          net_send_error(thd, ER_CON_COUNT_ERROR);
unknown's avatar
unknown committed
404 405
          DBUG_RETURN(-1);
        }
406
      }
unknown's avatar
unknown committed
407

unknown's avatar
unknown committed
408
      /* Why logging is performed before all checks've passed? */
409
      mysql_log.write(thd, command,
410 411
                      (thd->main_security_ctx.priv_user ==
                       thd->main_security_ctx.user ?
unknown's avatar
unknown committed
412 413
                       (char*) "%s@%s on %s" :
                       (char*) "%s@%s as anonymous on %s"),
414 415
                      thd->main_security_ctx.user,
                      thd->main_security_ctx.host_or_ip,
unknown's avatar
unknown committed
416 417
                      db ? db : (char*) "");

418
      /*
419 420 421
        This is the default access rights for the current database.  It's
        set to 0 here because we don't have an active database yet (and we
        may not have an active database to set.
422
      */
423
      thd->main_security_ctx.db_access=0;
unknown's avatar
unknown committed
424 425

      /* Don't allow user to connect if he has done too many queries */
426
      if ((ur.questions || ur.updates || ur.conn_per_hour || ur.user_conn ||
unknown's avatar
unknown committed
427
	   max_user_connections) &&
428
	  get_or_create_user_conn(thd,
429 430 431 432
            (opt_old_style_user_limits ? thd->main_security_ctx.user :
             thd->main_security_ctx.priv_user),
            (opt_old_style_user_limits ? thd->main_security_ctx.host_or_ip :
             thd->main_security_ctx.priv_host),
433
            &ur))
unknown's avatar
unknown committed
434 435
	DBUG_RETURN(-1);
      if (thd->user_connect &&
436 437
	  (thd->user_connect->user_resources.conn_per_hour ||
	   thd->user_connect->user_resources.user_conn ||
unknown's avatar
unknown committed
438 439 440
	   max_user_connections) &&
	  check_for_max_user_connections(thd, thd->user_connect))
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
441

442
      /* Change database if necessary */
unknown's avatar
unknown committed
443
      if (db && db[0])
444
      {
445
        if (mysql_change_db(thd, db, FALSE))
unknown's avatar
unknown committed
446
        {
447 448
          /* Send error to the client */
          net_send_error(thd);
unknown's avatar
unknown committed
449 450 451 452
          if (thd->user_connect)
            decrease_user_connections(thd->user_connect);
          DBUG_RETURN(-1);
        }
453
      }
454
      send_ok(thd);
unknown's avatar
unknown committed
455 456 457
      thd->password= test(passwd_len);          // remember for error messages 
      /* Ready to handle queries */
      DBUG_RETURN(0);
unknown's avatar
unknown committed
458 459
    }
  }
unknown's avatar
unknown committed
460
  else if (res == 2) // client gave short hash, server has long hash
unknown's avatar
unknown committed
461
  {
462
    net_printf_error(thd, ER_NOT_SUPPORTED_AUTH_MODE);
unknown's avatar
unknown committed
463 464
    mysql_log.write(thd,COM_CONNECT,ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
465
  }
466
  net_printf_error(thd, ER_ACCESS_DENIED_ERROR,
467 468
                   thd->main_security_ctx.user,
                   thd->main_security_ctx.host_or_ip,
469
                   passwd_len ? ER(ER_YES) : ER(ER_NO));
unknown's avatar
unknown committed
470
  mysql_log.write(thd, COM_CONNECT, ER(ER_ACCESS_DENIED_ERROR),
471 472
                  thd->main_security_ctx.user,
                  thd->main_security_ctx.host_or_ip,
unknown's avatar
unknown committed
473 474
                  passwd_len ? ER(ER_YES) : ER(ER_NO));
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
475
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
476 477
}

unknown's avatar
unknown committed
478
/*
unknown's avatar
unknown committed
479 480
  Check for maximum allowable user connections, if the mysqld server is
  started with corresponding variable that is greater then 0.
unknown's avatar
unknown committed
481 482
*/

483 484
extern "C" byte *get_key_conn(user_conn *buff, uint *length,
			      my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
485 486 487 488 489
{
  *length=buff->len;
  return (byte*) buff->user;
}

490
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
491 492 493 494
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
495
void init_max_user_conn(void)
unknown's avatar
unknown committed
496
{
497
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
498 499
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
500
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
501
		   0);
502
#endif
unknown's avatar
unknown committed
503 504 505
}


unknown's avatar
unknown committed
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
/*
  check if user has already too many connections
  
  SYNOPSIS
  check_for_max_user_connections()
  thd			Thread handle
  uc			User connect object

  NOTES
    If check fails, we decrease user connection count, which means one
    shouldn't call decrease_user_connections() after this function.

  RETURN
    0	ok
    1	error
*/

unknown's avatar
unknown committed
523 524
#ifndef NO_EMBEDDED_ACCESS_CHECKS

525
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
526
{
527
  int error=0;
528
  DBUG_ENTER("check_for_max_user_connections");
unknown's avatar
unknown committed
529

530
  (void) pthread_mutex_lock(&LOCK_user_conn);
531
  if (max_user_connections && !uc->user_resources.user_conn &&
unknown's avatar
unknown committed
532
      max_user_connections < (uint) uc->connections)
unknown's avatar
unknown committed
533
  {
534
    net_printf_error(thd, ER_TOO_MANY_USER_CONNECTIONS, uc->user);
535 536
    error=1;
    goto end;
unknown's avatar
unknown committed
537
  }
538
  time_out_user_resource_limits(thd, uc);
539 540 541 542 543 544 545 546 547 548 549
  if (uc->user_resources.user_conn &&
      uc->user_resources.user_conn < uc->connections)
  {
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user,
                     "max_user_connections",
                     (long) uc->user_resources.user_conn);
    error= 1;
    goto end;
  }
  if (uc->user_resources.conn_per_hour &&
      uc->user_resources.conn_per_hour <= uc->conn_per_hour)
550
  {
551
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user,
unknown's avatar
unknown committed
552
                     "max_connections_per_hour",
553
                     (long) uc->user_resources.conn_per_hour);
554 555 556
    error=1;
    goto end;
  }
557
  uc->conn_per_hour++;
unknown's avatar
unknown committed
558 559

  end:
560 561
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
562
  (void) pthread_mutex_unlock(&LOCK_user_conn);
563
  DBUG_RETURN(error);
unknown's avatar
unknown committed
564 565
}

unknown's avatar
unknown committed
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
/*
  Decrease user connection count

  SYNOPSIS
    decrease_user_connections()
    uc			User connection object

  NOTES
    If there is a n user connection object for a connection
    (which only happens if 'max_user_connections' is defined or
    if someone has created a resource grant for a user), then
    the connection count is always incremented on connect.

    The user connect object is not freed if some users has
    'max connections per hour' defined as we need to be able to hold
    count over the lifetime of the connection.
*/

584
static void decrease_user_connections(USER_CONN *uc)
unknown's avatar
unknown committed
585
{
586
  DBUG_ENTER("decrease_user_connections");
587 588 589
  (void) pthread_mutex_lock(&LOCK_user_conn);
  DBUG_ASSERT(uc->connections);
  if (!--uc->connections && !mqh_used)
unknown's avatar
unknown committed
590 591
  {
    /* Last connection for user; Delete it */
unknown's avatar
unknown committed
592
    (void) hash_delete(&hash_user_connections,(byte*) uc);
unknown's avatar
unknown committed
593
  }
594
  (void) pthread_mutex_unlock(&LOCK_user_conn);
595
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
596 597
}

598 599
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

600

unknown's avatar
unknown committed
601 602
void free_max_user_conn(void)
{
603
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
604
  hash_free(&hash_user_connections);
605
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
606 607
}

unknown's avatar
unknown committed
608

609

610 611 612
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
unknown's avatar
unknown committed
613 614 615

  sql_command is actually set to SQLCOM_END sometimes
  so we need the +1 to include it in the array.
unknown's avatar
unknown committed
616 617 618 619 620 621

  numbers are:
     0  - read-only query
  != 0  - query that may change a table
     2  - query that returns meaningful ROW_COUNT() -
          a number of modified rows
622 623
*/

unknown's avatar
unknown committed
624
char  uc_update_queries[SQLCOM_END+1];
625 626 627

void init_update_queries(void)
{
unknown's avatar
unknown committed
628 629
  bzero((gptr) &uc_update_queries, sizeof(uc_update_queries));

630 631 632
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
633 634 635 636 637 638
  uc_update_queries[SQLCOM_UPDATE]=2;
  uc_update_queries[SQLCOM_UPDATE_MULTI]=2;
  uc_update_queries[SQLCOM_INSERT]=2;
  uc_update_queries[SQLCOM_INSERT_SELECT]=2;
  uc_update_queries[SQLCOM_DELETE]=2;
  uc_update_queries[SQLCOM_DELETE_MULTI]=2;
639 640 641 642 643
  uc_update_queries[SQLCOM_TRUNCATE]=1;
  uc_update_queries[SQLCOM_DROP_TABLE]=1;
  uc_update_queries[SQLCOM_LOAD]=1;
  uc_update_queries[SQLCOM_CREATE_DB]=1;
  uc_update_queries[SQLCOM_DROP_DB]=1;
644 645
  uc_update_queries[SQLCOM_REPLACE]=2;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=2;
646 647 648 649
  uc_update_queries[SQLCOM_RENAME_TABLE]=1;
  uc_update_queries[SQLCOM_BACKUP_TABLE]=1;
  uc_update_queries[SQLCOM_RESTORE_TABLE]=1;
  uc_update_queries[SQLCOM_DROP_INDEX]=1;
unknown's avatar
VIEW  
unknown committed
650 651
  uc_update_queries[SQLCOM_CREATE_VIEW]=1;
  uc_update_queries[SQLCOM_DROP_VIEW]=1;
652 653
}

unknown's avatar
unknown committed
654 655
bool is_update_query(enum enum_sql_command command)
{
unknown's avatar
unknown committed
656
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
657
  return uc_update_queries[command] != 0;
unknown's avatar
unknown committed
658
}
659

unknown's avatar
unknown committed
660
/*
661 662
  Reset per-hour user resource limits when it has been more than
  an hour since they were last checked
unknown's avatar
unknown committed
663

664 665 666 667
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
unknown's avatar
unknown committed
668

669 670 671 672
  NOTE:
    This assumes that the LOCK_user_conn mutex has been acquired, so it is
    safe to test and modify members of the USER_CONN structure.
*/
673

674 675
#ifndef NO_EMBEDDED_ACCESS_CHECKS

676
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
677
{
unknown's avatar
unknown committed
678
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
679
  DBUG_ENTER("time_out_user_resource_limits");
unknown's avatar
unknown committed
680

unknown's avatar
unknown committed
681
  /* If more than a hour since last check, reset resource checking */
682 683 684 685 686 687 688
  if (check_time  - uc->intime >= 3600)
  {
    uc->questions=1;
    uc->updates=0;
    uc->conn_per_hour=0;
    uc->intime=check_time;
  }
689 690 691 692 693 694 695 696 697 698 699

  DBUG_VOID_RETURN;
}

/*
  Check if maximum queries per hour limit has been reached
  returns 0 if OK.
*/

static bool check_mqh(THD *thd, uint check_command)
{
700
  bool error= 0;
701 702 703 704 705 706 707 708
  USER_CONN *uc=thd->user_connect;
  DBUG_ENTER("check_mqh");
  DBUG_ASSERT(uc != 0);

  (void) pthread_mutex_lock(&LOCK_user_conn);

  time_out_user_resource_limits(thd, uc);

unknown's avatar
unknown committed
709
  /* Check that we have not done too many questions / hour */
710 711 712
  if (uc->user_resources.questions &&
      uc->questions++ >= uc->user_resources.questions)
  {
713 714
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user, "max_questions",
                     (long) uc->user_resources.questions);
715 716 717
    error=1;
    goto end;
  }
718
  if (check_command < (uint) SQLCOM_END)
unknown's avatar
unknown committed
719
  {
unknown's avatar
unknown committed
720 721 722 723
    /* Check that we have not done too many updates / hour */
    if (uc->user_resources.updates && uc_update_queries[check_command] &&
	uc->updates++ >= uc->user_resources.updates)
    {
724 725
      net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user, "max_updates",
                       (long) uc->user_resources.updates);
unknown's avatar
unknown committed
726 727 728
      error=1;
      goto end;
    }
unknown's avatar
unknown committed
729 730
  }
end:
731
  (void) pthread_mutex_unlock(&LOCK_user_conn);
732
  DBUG_RETURN(error);
unknown's avatar
unknown committed
733 734
}

735 736
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

unknown's avatar
unknown committed
737

unknown's avatar
unknown committed
738
static void reset_mqh(LEX_USER *lu, bool get_them= 0)
739
{
unknown's avatar
unknown committed
740
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
741
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
742
  if (lu)  // for GRANT
743
  {
744
    USER_CONN *uc;
745
    uint temp_len=lu->user.length+lu->host.length+2;
746
    char temp_user[USER_HOST_BUFF_SIZE];
747

unknown's avatar
unknown committed
748 749
    memcpy(temp_user,lu->user.str,lu->user.length);
    memcpy(temp_user+lu->user.length+1,lu->host.str,lu->host.length);
750
    temp_user[lu->user.length]='\0'; temp_user[temp_len-1]=0;
unknown's avatar
unknown committed
751
    if ((uc = (struct  user_conn *) hash_search(&hash_user_connections,
752
						(byte*) temp_user, temp_len)))
753 754
    {
      uc->questions=0;
755
      get_mqh(temp_user,&temp_user[lu->user.length+1],uc);
756 757
      uc->updates=0;
      uc->conn_per_hour=0;
758 759
    }
  }
unknown's avatar
unknown committed
760
  else
761
  {
unknown's avatar
unknown committed
762
    /* for FLUSH PRIVILEGES and FLUSH USER_RESOURCES */
unknown's avatar
unknown committed
763
    for (uint idx=0;idx < hash_user_connections.records; idx++)
764
    {
unknown's avatar
unknown committed
765 766
      USER_CONN *uc=(struct user_conn *) hash_element(&hash_user_connections,
						      idx);
767 768 769 770 771
      if (get_them)
	get_mqh(uc->user,uc->host,uc);
      uc->questions=0;
      uc->updates=0;
      uc->conn_per_hour=0;
772 773
    }
  }
unknown's avatar
unknown committed
774
  (void) pthread_mutex_unlock(&LOCK_user_conn);
unknown's avatar
unknown committed
775
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
776
}
unknown's avatar
unknown committed
777

778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
void thd_init_client_charset(THD *thd, uint cs_number)
{
  /*
   Use server character set and collation if
   - opt_character_set_client_handshake is not set
   - client has not specified a character set
   - client character set is the same as the servers
   - client character set doesn't exists in server
  */
  if (!opt_character_set_client_handshake ||
      !(thd->variables.character_set_client= get_charset(cs_number, MYF(0))) ||
      !my_strcasecmp(&my_charset_latin1,
                     global_system_variables.character_set_client->name,
                     thd->variables.character_set_client->name))
  {
    thd->variables.character_set_client=
      global_system_variables.character_set_client;
    thd->variables.collation_connection=
      global_system_variables.collation_connection;
    thd->variables.character_set_results=
      global_system_variables.character_set_results;
  }
  else
  {
    thd->variables.character_set_results=
      thd->variables.collation_connection= 
      thd->variables.character_set_client;
  }
}


unknown's avatar
unknown committed
809
/*
810
    Perform handshake, authorize client and update thd ACL variables.
811
  SYNOPSIS
812
    check_connection()
813
    thd  thread handle
814 815

  RETURN
816
     0  success, OK is sent to user, thd is updated.
817 818
    -1  error, which is sent to user
   > 0  error code (not sent to user)
unknown's avatar
unknown committed
819 820
*/

unknown's avatar
unknown committed
821 822
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
unknown's avatar
unknown committed
823
{
824
  uint connect_errors= 0;
unknown's avatar
unknown committed
825
  NET *net= &thd->net;
unknown's avatar
unknown committed
826 827
  ulong pkt_len= 0;
  char *end;
828

829 830
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));
unknown's avatar
unknown committed
831
#ifdef SIGNAL_WITH_VIO_CLOSE
832
  thd->set_active_vio(net->vio);
unknown's avatar
unknown committed
833
#endif
834

835
  if (!thd->main_security_ctx.host)         // If TCP/IP connection
unknown's avatar
unknown committed
836
  {
837
    char ip[30];
838

839
    if (vio_peer_addr(net->vio, ip, &thd->peer_port))
unknown's avatar
unknown committed
840
      return (ER_BAD_HOST_ERROR);
841
    if (!(thd->main_security_ctx.ip= my_strdup(ip,MYF(0))))
unknown's avatar
unknown committed
842
      return (ER_OUT_OF_RESOURCES);
843
    thd->main_security_ctx.host_or_ip= thd->main_security_ctx.ip;
unknown's avatar
unknown committed
844
    vio_in_addr(net->vio,&thd->remote.sin_addr);
845
    if (!(specialflag & SPECIAL_NO_RESOLVE))
unknown's avatar
unknown committed
846
    {
847
      vio_in_addr(net->vio,&thd->remote.sin_addr);
848 849
      thd->main_security_ctx.host=
        ip_to_hostname(&thd->remote.sin_addr, &connect_errors);
850
      /* Cut very long hostnames to avoid possible overflows */
851
      if (thd->main_security_ctx.host)
852
      {
853 854 855 856
        if (thd->main_security_ctx.host != my_localhost)
          thd->main_security_ctx.host[min(strlen(thd->main_security_ctx.host),
                                          HOSTNAME_LENGTH)]= 0;
        thd->main_security_ctx.host_or_ip= thd->main_security_ctx.host;
857
      }
858 859
      if (connect_errors > max_connect_errors)
        return(ER_HOST_IS_BLOCKED);
unknown's avatar
unknown committed
860
    }
unknown's avatar
unknown committed
861
    DBUG_PRINT("info",("Host: %s  ip: %s",
862 863 864 865 866
		       (thd->main_security_ctx.host ?
                        thd->main_security_ctx.host : "unknown host"),
		       (thd->main_security_ctx.ip ?
                        thd->main_security_ctx.ip : "unknown ip")));
    if (acl_check_host(thd->main_security_ctx.host, thd->main_security_ctx.ip))
unknown's avatar
unknown committed
867 868
      return(ER_HOST_NOT_PRIVILEGED);
  }
869
  else /* Hostname given means that the connection was on a socket */
unknown's avatar
unknown committed
870
  {
871 872 873
    DBUG_PRINT("info",("Host: %s", thd->main_security_ctx.host));
    thd->main_security_ctx.host_or_ip= thd->main_security_ctx.host;
    thd->main_security_ctx.ip= 0;
874 875
    /* Reset sin_addr */
    bzero((char*) &thd->remote, sizeof(thd->remote));
unknown's avatar
unknown committed
876 877 878
  }
  vio_keepalive(net->vio, TRUE);
  {
unknown's avatar
unknown committed
879
    /* buff[] needs to big enough to hold the server_version variable */
880
    char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH + 64];
881 882
    ulong client_flags = (CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB |
			  CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION);
unknown's avatar
unknown committed
883

884 885 886 887 888
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
889 890
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
891
      client_flags |= CLIENT_SSL;       /* Wow, SSL is available! */
unknown's avatar
unknown committed
892
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
893

894 895 896 897 898 899 900 901 902 903 904
    end= strnmov(buff, server_version, SERVER_VERSION_LENGTH) + 1;
    int4store((uchar*) end, thd->thread_id);
    end+= 4;
    /*
      So as check_connection is the only entry point to authorization
      procedure, scramble is set here. This gives us new scramble for
      each handshake.
    */
    create_random_string(thd->scramble, SCRAMBLE_LENGTH, &thd->rand);
    /*
      Old clients does not understand long scrambles, but can ignore packet
unknown's avatar
unknown committed
905
      tail: that's why first part of the scramble is placed here, and second
906 907
      part at the end of packet.
    */
908
    end= strmake(end, thd->scramble, SCRAMBLE_LENGTH_323) + 1;
909 910 911
   
    int2store(end, client_flags);
    /* write server characteristics: up to 16 bytes allowed */
912
    end[2]=(char) default_charset_info->number;
913 914 915 916 917 918 919 920 921
    int2store(end+3, thd->server_status);
    bzero(end+5, 13);
    end+= 18;
    /* write scramble tail */
    end= strmake(end, thd->scramble + SCRAMBLE_LENGTH_323, 
                 SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323) + 1;

    /* At this point we write connection message and read reply */
    if (net_write_command(net, (uchar) protocol_version, "", 0, buff,
unknown's avatar
unknown committed
922
			  (uint) (end-buff)) ||
923
	(pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
924 925 926 927 928 929 930 931 932 933 934
	pkt_len < MIN_HANDSHAKE_SIZE)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
#ifdef _CUSTOMCONFIG_
#include "_cust_sql_parse.h"
#endif
  if (connect_errors)
    reset_host_errors(&thd->remote.sin_addr);
unknown's avatar
unknown committed
935
  if (thd->packet.alloc(thd->variables.net_buffer_length))
unknown's avatar
unknown committed
936 937 938
    return(ER_OUT_OF_RESOURCES);

  thd->client_capabilities=uint2korr(net->read_pos);
939 940 941 942
  if (thd->client_capabilities & CLIENT_PROTOCOL_41)
  {
    thd->client_capabilities|= ((ulong) uint2korr(net->read_pos+2)) << 16;
    thd->max_client_packet_length= uint4korr(net->read_pos+4);
unknown's avatar
unknown committed
943
    DBUG_PRINT("info", ("client_character_set: %d", (uint) net->read_pos[8]));
944
    thd_init_client_charset(thd, (uint) net->read_pos[8]);
unknown's avatar
unknown committed
945
    thd->update_charset();
946
    end= (char*) net->read_pos+32;
947 948 949 950 951 952 953
  }
  else
  {
    thd->max_client_packet_length= uint3korr(net->read_pos+2);
    end= (char*) net->read_pos+5;
  }

954
  if (thd->client_capabilities & CLIENT_IGNORE_SPACE)
955
    thd->variables.sql_mode|= MODE_IGNORE_SPACE;
unknown's avatar
unknown committed
956
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
957
  DBUG_PRINT("info", ("client capabilities: %lu", thd->client_capabilities));
unknown's avatar
unknown committed
958 959 960
  if (thd->client_capabilities & CLIENT_SSL)
  {
    /* Do the SSL layering. */
961 962 963 964 965
    if (!ssl_acceptor_fd)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
unknown's avatar
unknown committed
966
    DBUG_PRINT("info", ("IO layer change in progress..."));
967
    if (sslaccept(ssl_acceptor_fd, net->vio, net->read_timeout))
unknown's avatar
unknown committed
968
    {
969
      DBUG_PRINT("error", ("Failed to accept new SSL connection"));
unknown's avatar
unknown committed
970
      inc_host_errors(&thd->remote.sin_addr);
unknown's avatar
unknown committed
971
      return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
972
    }
unknown's avatar
unknown committed
973
    DBUG_PRINT("info", ("Reading user information over SSL layer"));
974
    if ((pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
975 976
	pkt_len < NORMAL_HANDSHAKE_SIZE)
    {
unknown's avatar
unknown committed
977 978
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
unknown's avatar
unknown committed
979 980 981 982
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
983 984 985
#endif

  if (end >= (char*) net->read_pos+ pkt_len +2)
unknown's avatar
unknown committed
986
  {
987 988
    inc_host_errors(&thd->remote.sin_addr);
    return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
989 990 991
  }

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
992
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
993
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
994 995
      opt_using_transactions)
    net->return_status= &thd->server_status;
unknown's avatar
unknown committed
996

997 998
  char *user= end;
  char *passwd= strend(user)+1;
999
  uint user_len= passwd - user - 1;
unknown's avatar
unknown committed
1000
  char *db= passwd;
unknown's avatar
unknown committed
1001 1002
  char db_buff[NAME_LEN + 1];           // buffer to store db in utf8
  char user_buff[USERNAME_LENGTH + 1];	// buffer to store user in utf8
1003 1004 1005
  uint dummy_errors;

  /*
unknown's avatar
unknown committed
1006 1007 1008 1009
    Old clients send null-terminated string as password; new clients send
    the size (1 byte) + string (not null-terminated). Hence in case of empty
    password both send '\0'.
  */
1010
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
unknown's avatar
unknown committed
1011 1012 1013
    *passwd++ : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
unknown's avatar
unknown committed
1014 1015
  uint db_len= db ? strlen(db) : 0;

unknown's avatar
unknown committed
1016
  if (passwd + passwd_len + db_len > (char *)net->read_pos + pkt_len)
unknown's avatar
unknown committed
1017 1018 1019 1020
  {
    inc_host_errors(&thd->remote.sin_addr);
    return ER_HANDSHAKE_ERROR;
  }
unknown's avatar
unknown committed
1021

unknown's avatar
unknown committed
1022 1023
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
unknown's avatar
unknown committed
1024
  {
1025 1026
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info,
unknown's avatar
unknown committed
1027
                             db, db_len,
1028
                             thd->charset(), &dummy_errors)]= 0;
1029
    db= db_buff;
unknown's avatar
unknown committed
1030
  }
unknown's avatar
unknown committed
1031

1032 1033 1034
  user_buff[user_len= copy_and_convert(user_buff, sizeof(user_buff)-1,
                                       system_charset_info, user, user_len,
                                       thd->charset(), &dummy_errors)]= '\0';
1035
  user= user_buff;
unknown's avatar
unknown committed
1036

1037 1038 1039 1040 1041 1042 1043 1044
  /* If username starts and ends in "'", chop them off */
  if (user_len > 1 && user[0] == '\'' && user[user_len - 1] == '\'')
  {
    user[user_len-1]= 0;
    user++;
    user_len-= 2;
  }

1045 1046 1047
  if (thd->main_security_ctx.user)
    x_free(thd->main_security_ctx.user);
  if (!(thd->main_security_ctx.user= my_strdup(user, MYF(0))))
1048
    return (ER_OUT_OF_RESOURCES);
unknown's avatar
unknown committed
1049
  return check_user(thd, COM_CONNECT, passwd, passwd_len, db, TRUE);
unknown's avatar
unknown committed
1050 1051
}

1052

1053 1054
void execute_init_command(THD *thd, sys_var_str *init_command_var,
			  rw_lock_t *var_mutex)
unknown's avatar
unknown committed
1055 1056 1057 1058
{
  Vio* save_vio;
  ulong save_client_capabilities;

1059
  thd_proc_info(thd, "Execution of init_command");
1060 1061 1062 1063 1064 1065 1066 1067
  /*
    We need to lock init_command_var because
    during execution of init_command_var query
    values of init_command_var can't be changed
  */
  rw_rdlock(var_mutex);
  thd->query= init_command_var->value;
  thd->query_length= init_command_var->value_length;
unknown's avatar
unknown committed
1068 1069
  save_client_capabilities= thd->client_capabilities;
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
1070 1071 1072 1073
  /*
    We don't need return result of execution to client side.
    To forbid this we should set thd->net.vio to 0.
  */
unknown's avatar
unknown committed
1074 1075
  save_vio= thd->net.vio;
  thd->net.vio= 0;
1076
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
1077
  dispatch_command(COM_QUERY, thd, thd->query, thd->query_length+1);
1078
  rw_unlock(var_mutex);
unknown's avatar
unknown committed
1079 1080 1081 1082 1083
  thd->client_capabilities= save_client_capabilities;
  thd->net.vio= save_vio;
}


1084
pthread_handler_t handle_one_connection(void *arg)
unknown's avatar
unknown committed
1085 1086 1087
{
  THD *thd=(THD*) arg;
  uint launch_time  =
unknown's avatar
unknown committed
1088
    (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
unknown's avatar
unknown committed
1089 1090 1091 1092 1093
  if (launch_time >= slow_launch_time)
    statistic_increment(slow_launch_threads,&LOCK_status );

  pthread_detach_this_thread();

1094
#if !defined( __WIN__) && !defined(OS2)	// Win32 calls this in pthread_create
unknown's avatar
unknown committed
1095
  /* The following calls needs to be done before we call DBUG_ macros */
1096
  if (!(test_flags & TEST_NO_THREADS) & my_thread_init())
unknown's avatar
unknown committed
1097
  {
1098
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
1099
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1100 1101 1102 1103 1104
    end_thread(thd,0);
    return 0;
  }
#endif

1105 1106 1107 1108 1109 1110 1111
  /*
    handle_one_connection() is the only way a thread would start
    and would always be on top of the stack, therefore, the thread
    stack always starts at the address of the first local variable
    of handle_one_connection, which is thd. We need to know the
    start of the stack so that we could check for stack overruns.
  */
unknown's avatar
unknown committed
1112
  DBUG_PRINT("info", ("handle_one_connection called by thread %lu\n",
unknown's avatar
unknown committed
1113
		      thd->thread_id));
unknown's avatar
unknown committed
1114
  /* now that we've called my_thread_init(), it is safe to call DBUG_* */
unknown's avatar
unknown committed
1115

unknown's avatar
unknown committed
1116
#if defined(__WIN__)
unknown's avatar
unknown committed
1117
  init_signals();
unknown's avatar
unknown committed
1118
#elif !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1119 1120 1121 1122
  sigset_t set;
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif
1123
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1124 1125
  if (thd->store_globals())
  {
1126
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
1127
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1128 1129 1130 1131 1132 1133 1134 1135
    end_thread(thd,0);
    return 0;
  }

  do
  {
    int error;
    NET *net= &thd->net;
1136
    Security_context *sctx= thd->security_ctx;
1137
    net->no_send_error= 0;
unknown's avatar
unknown committed
1138

1139 1140 1141 1142
    /* Use "connect_timeout" value during connection phase */
    net_set_read_timeout(net, connect_timeout);
    net_set_write_timeout(net, connect_timeout);

1143
    if ((error=check_connection(thd)))
unknown's avatar
unknown committed
1144 1145
    {						// Wrong permissions
      if (error > 0)
1146
	net_printf_error(thd, error, sctx->host_or_ip);
unknown's avatar
unknown committed
1147 1148
#ifdef __NT__
      if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
1149
	my_sleep(1000);				/* must wait after eof() */
unknown's avatar
unknown committed
1150
#endif
1151
      statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1152 1153
      goto end_thread;
    }
unknown's avatar
unknown committed
1154
#ifdef __NETWARE__
1155
    netware_reg_user(sctx->ip, sctx->user, "MySQL");
unknown's avatar
unknown committed
1156
#endif
1157
    if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1158 1159 1160 1161
      thd->options |= OPTION_BIG_SELECTS;
    if (thd->client_capabilities & CLIENT_COMPRESS)
      net->compress=1;				// Use compression

unknown's avatar
unknown committed
1162
    thd->version= refresh_version;
1163
    thd_proc_info(thd, 0);
1164
    thd->command= COM_SLEEP;
1165
    thd->init_for_queries();
unknown's avatar
unknown committed
1166

1167
    if (sys_init_connect.value_length && !(sctx->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1168
    {
1169 1170
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
1171
      {
unknown's avatar
unknown committed
1172
	thd->killed= THD::KILL_CONNECTION;
1173 1174 1175 1176 1177 1178
        sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
                          thd->thread_id,(thd->db ? thd->db : "unconnected"),
                          sctx->user ? sctx->user : "unauthenticated",
                          sctx->host_or_ip, "init_connect command failed");
        sql_print_warning("%s", net->last_error);
      }
1179
      thd_proc_info(thd, 0);
1180
      thd->init_for_queries();
unknown's avatar
unknown committed
1181 1182
    }

1183 1184 1185 1186
    /* Connect completed, set read/write timeouts back to tdefault */
    net_set_read_timeout(net, thd->variables.net_read_timeout);
    net_set_write_timeout(net, thd->variables.net_write_timeout);

1187 1188
    while (!net->error && net->vio != 0 &&
           !(thd->killed == THD::KILL_CONNECTION))
unknown's avatar
unknown committed
1189
    {
1190
      net->no_send_error= 0;
unknown's avatar
unknown committed
1191 1192 1193
      if (do_command(thd))
	break;
    }
1194 1195
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
unknown's avatar
unknown committed
1196
    if (net->error && net->vio != 0 && net->report_error)
unknown's avatar
unknown committed
1197
    {
1198
      if (!thd->killed && thd->variables.log_warnings > 1)
unknown's avatar
unknown committed
1199
	sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
unknown's avatar
unknown committed
1200
                          thd->thread_id,(thd->db ? thd->db : "unconnected"),
1201 1202
                          sctx->user ? sctx->user : "unauthenticated",
                          sctx->host_or_ip,
unknown's avatar
unknown committed
1203 1204
                          (net->last_errno ? ER(net->last_errno) :
                           ER(ER_UNKNOWN_ERROR)));
1205
      net_send_error(thd, net->last_errno, NullS);
unknown's avatar
unknown committed
1206
      statistic_increment(aborted_threads,&LOCK_status);
unknown's avatar
unknown committed
1207
    }
1208 1209 1210 1211
    else if (thd->killed)
    {
      statistic_increment(aborted_threads,&LOCK_status);
    }
1212
    
unknown's avatar
unknown committed
1213
end_thread:
1214
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1215 1216 1217 1218 1219 1220
    end_thread(thd,1);
    /*
      If end_thread returns, we are either running with --one-thread
      or this thread has been schedule to handle the next query
    */
    thd= current_thd;
1221
    thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1222 1223 1224 1225 1226
  } while (!(test_flags & TEST_NO_THREADS));
  /* The following is only executed if we are not using --one-thread */
  return(0);					/* purecov: deadcode */
}

unknown's avatar
unknown committed
1227 1228
#endif /* EMBEDDED_LIBRARY */

1229 1230 1231 1232
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
1233

1234
pthread_handler_t handle_bootstrap(void *arg)
unknown's avatar
unknown committed
1235
{
1236 1237 1238
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
unknown's avatar
unknown committed
1239

1240
  /* The following must be called before DBUG_ENTER */
1241
  thd->thread_stack= (char*) &thd;
1242
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
1243
  {
unknown's avatar
unknown committed
1244
#ifndef EMBEDDED_LIBRARY
1245
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
1246
#endif
1247
    thd->fatal_error();
1248
    goto end;
unknown's avatar
unknown committed
1249
  }
1250 1251
  DBUG_ENTER("handle_bootstrap");

unknown's avatar
unknown committed
1252
#ifndef EMBEDDED_LIBRARY
1253 1254
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1255
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1256
  sigset_t set;
1257 1258
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
1259
#endif
unknown's avatar
unknown committed
1260
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1261

1262
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1263 1264
    thd->options |= OPTION_BIG_SELECTS;

1265
  thd_proc_info(thd, 0);
unknown's avatar
unknown committed
1266
  thd->version=refresh_version;
1267 1268
  thd->security_ctx->priv_user=
    thd->security_ctx->user= (char*) my_strdup("boot", MYF(MY_WME));
1269 1270 1271 1272 1273 1274
  /*
    Make the "client" handle multiple results. This is necessary
    to enable stored procedures with SELECTs and Dynamic SQL
    in init-file.
  */
  thd->client_capabilities|= CLIENT_MULTI_RESULTS;
unknown's avatar
unknown committed
1275

1276
  buff= (char*) thd->net.buff;
1277
  thd->init_for_queries();
unknown's avatar
unknown committed
1278 1279
  while (fgets(buff, thd->net.max_packet, file))
  {
unknown's avatar
unknown committed
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
   ulong length= (ulong) strlen(buff);
   while (buff[length-1] != '\n' && !feof(file))
   {
     /*
       We got only a part of the current string. Will try to increase
       net buffer then read the rest of the current string.
     */
     if (net_realloc(&(thd->net), 2 * thd->net.max_packet))
     {
       net_send_error(thd, ER_NET_PACKET_TOO_LARGE, NullS);
       thd->fatal_error();
       break;
     }
     buff= (char*) thd->net.buff;
     fgets(buff + length, thd->net.max_packet - length, file);
     length+= (ulong) strlen(buff + length);
   }
   if (thd->is_fatal_error)
     break;

unknown's avatar
unknown committed
1300
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1301
           buff[length-1] == ';'))
unknown's avatar
unknown committed
1302 1303
      length--;
    buff[length]=0;
1304
    thd->query_length=length;
unknown's avatar
unknown committed
1305 1306
    thd->query= thd->memdup_w_gap(buff, length+1, 
				  thd->db_length+1+QUERY_CACHE_FLAGS_SIZE);
unknown's avatar
unknown committed
1307
    thd->query[length] = '\0';
1308
    DBUG_PRINT("query",("%-.4096s",thd->query));
1309 1310 1311 1312
    /*
      We don't need to obtain LOCK_thread_count here because in bootstrap
      mode we have only one thread.
    */
1313
    thd->query_id=next_query_id();
1314
    thd->set_time();
unknown's avatar
unknown committed
1315 1316
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
1317

1318
    if (thd->is_fatal_error)
1319
      break;
1320 1321 1322 1323 1324 1325 1326 1327 1328

    if (thd->net.report_error)
    {
      /* The query failed, send error to log and abort bootstrap */
      net_send_error(thd);
      thd->fatal_error();
      break;
    }

unknown's avatar
unknown committed
1329
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1330
#ifdef USING_TRANSACTIONS
1331
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
1332
#endif
unknown's avatar
unknown committed
1333
  }
1334 1335

end:
1336
  /* Remember the exit code of bootstrap */
1337 1338 1339 1340 1341 1342
  bootstrap_error= thd->is_fatal_error;

  net_end(&thd->net);
  thd->cleanup();
  delete thd;

unknown's avatar
unknown committed
1343
#ifndef EMBEDDED_LIBRARY
1344 1345 1346
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1347
  (void) pthread_cond_broadcast(&COND_thread_count);
1348 1349
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1350
#endif
1351
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1352 1353 1354
}


1355 1356 1357 1358
    /* This works because items are allocated with sql_alloc() */

void cleanup_items(Item *item)
{
unknown's avatar
unknown committed
1359
  DBUG_ENTER("cleanup_items");  
1360 1361
  for (; item ; item=item->next)
    item->cleanup();
unknown's avatar
unknown committed
1362
  DBUG_VOID_RETURN;
1363 1364
}

unknown's avatar
unknown committed
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
/*
  Handle COM_TABLE_DUMP command

  SYNOPSIS
    mysql_table_dump
      thd           thread handle
      db            database name or an empty string. If empty,
                    the current database of the connection is used
      tbl_name      name of the table to dump

  NOTES
    This function is written to handle one specific command only.

  RETURN VALUE
    0               success
    1               error, the error message is set in THD
*/

static
int mysql_table_dump(THD* thd, char* db, char* tbl_name)
unknown's avatar
unknown committed
1385 1386 1387 1388 1389 1390
{
  TABLE* table;
  TABLE_LIST* table_list;
  int error = 0;
  DBUG_ENTER("mysql_table_dump");
  db = (db && db[0]) ? db : thd->db;
1391
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1392
    DBUG_RETURN(1); // out of memory
unknown's avatar
VIEW  
unknown committed
1393
  table_list->db= db;
1394
  table_list->table_name= table_list->alias= tbl_name;
unknown's avatar
VIEW  
unknown committed
1395 1396
  table_list->lock_type= TL_READ_NO_INSERT;
  table_list->prev_global= &table_list;	// can be removed after merge with 4.1
unknown's avatar
unknown committed
1397

1398 1399
  if (!db || check_db_name(db))
  {
1400
    my_error(ER_WRONG_DB_NAME ,MYF(0), db ? db : "NULL");
1401 1402
    goto err;
  }
1403
  if (lower_case_table_names)
1404
    my_casedn_str(files_charset_info, tbl_name);
1405
  remove_escape(table_list->table_name);
1406 1407 1408 1409

  if (!(table=open_ltable(thd, table_list, TL_READ_NO_INSERT)))
    DBUG_RETURN(1);

unknown's avatar
unknown committed
1410
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1411 1412
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1413
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1414
  thd->query = tbl_name;
unknown's avatar
unknown committed
1415
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1416
  {
1417
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1418 1419
    goto err;
  }
unknown's avatar
unknown committed
1420
  net_flush(&thd->net);
unknown's avatar
unknown committed
1421
  if ((error= table->file->dump(thd,-1)))
1422
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1423

unknown's avatar
unknown committed
1424
err:
unknown's avatar
unknown committed
1425
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1426 1427
}

unknown's avatar
unknown committed
1428 1429 1430 1431
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1432
    end_trans()
unknown's avatar
unknown committed
1433 1434 1435 1436 1437 1438 1439
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1440
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
unknown's avatar
unknown committed
1441 1442 1443
{
  bool do_release= 0;
  int res= 0;
1444
  DBUG_ENTER("end_trans");
unknown's avatar
unknown committed
1445

1446
  if (unlikely(thd->in_sub_stmt))
1447 1448 1449 1450
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
1451 1452 1453 1454 1455 1456
  if (thd->transaction.xid_state.xa_state != XA_NOTR)
  {
    my_error(ER_XAER_RMFAIL, MYF(0),
             xa_state_names[thd->transaction.xid_state.xa_state]);
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
1457 1458 1459 1460 1461 1462 1463 1464
  switch (completion) {
  case COMMIT:
    /*
     We don't use end_active_trans() here to ensure that this works
     even if there is a problem with the OPTION_AUTO_COMMIT flag
     (Which of course should never happen...)
    */
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
1465
    res= ha_commit(thd);
1466
    thd->options&= ~(OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
1467 1468
    break;
  case COMMIT_RELEASE:
unknown's avatar
unknown committed
1469
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1470 1471 1472 1473 1474 1475
  case COMMIT_AND_CHAIN:
    res= end_active_trans(thd);
    if (!res && completion == COMMIT_AND_CHAIN)
      res= begin_trans(thd);
    break;
  case ROLLBACK_RELEASE:
unknown's avatar
unknown committed
1476
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1477 1478 1479 1480
  case ROLLBACK:
  case ROLLBACK_AND_CHAIN:
  {
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
unknown's avatar
unknown committed
1481
    if (ha_rollback(thd))
unknown's avatar
unknown committed
1482
      res= -1;
1483
    thd->options&= ~(OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
1484 1485 1486 1487 1488 1489 1490 1491 1492
    if (!res && (completion == ROLLBACK_AND_CHAIN))
      res= begin_trans(thd);
    break;
  }
  default:
    res= -1;
    my_error(ER_UNKNOWN_COM_ERROR, MYF(0));
    DBUG_RETURN(-1);
  }
unknown's avatar
unknown committed
1493

unknown's avatar
unknown committed
1494 1495 1496
  if (res < 0)
    my_error(thd->killed_errno(), MYF(0));
  else if ((res == 0) && do_release)
unknown's avatar
unknown committed
1497 1498
    thd->killed= THD::KILL_CONNECTION;

unknown's avatar
unknown committed
1499 1500
  DBUG_RETURN(res);
}
unknown's avatar
unknown committed
1501

1502
#ifndef EMBEDDED_LIBRARY
1503 1504

/*
1505
  Read one command from connection and execute it (query or simple command).
1506 1507 1508 1509 1510 1511 1512 1513
  This function is called in loop from thread function.
  SYNOPSIS
    do_command()
  RETURN VALUE
    0  success
    1  request of thread shutdown (see dispatch_command() description)
*/

unknown's avatar
unknown committed
1514 1515
bool do_command(THD *thd)
{
1516
  char *packet= 0;
unknown's avatar
unknown committed
1517
  ulong packet_length;
1518
  NET *net= &thd->net;
unknown's avatar
unknown committed
1519 1520 1521
  enum enum_server_command command;
  DBUG_ENTER("do_command");

unknown's avatar
unknown committed
1522 1523 1524 1525
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1526
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1527

1528 1529 1530 1531 1532 1533 1534 1535
  /*
    This thread will do a blocking read from the client which
    will be interrupted when the next command is received from
    the client, the connection is closed or "net_wait_timeout"
    number of seconds has passed
  */
  net_set_read_timeout(net, thd->variables.net_wait_timeout);

unknown's avatar
unknown committed
1536
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1537 1538 1539 1540

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1541 1542 1543 1544 1545
    DBUG_PRINT("info",("Got error %d reading command from socket %s",
		       net->error,
		       vio_description(net->vio)));
    /* Check if we can continue without closing the connection */
    if (net->error != 3)
1546 1547
    {
      statistic_increment(aborted_threads,&LOCK_status);
1548
      DBUG_RETURN(TRUE);			// We have to close it.
1549
    }
1550
    net_send_error(thd, net->last_errno, NullS);
1551
    net->error= 0;
1552
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1553 1554 1555 1556 1557
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1558 1559
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
1560 1561 1562
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
1563
  }
1564 1565 1566 1567

  /* Restore read timeout value */
  net_set_read_timeout(net, thd->variables.net_read_timeout);

1568 1569 1570 1571 1572 1573 1574 1575 1576
  /*
    packet_length contains length of data, as it was stored in packet
    header. In case of malformed header, packet_length can be zero.
    If packet_length is not zero, my_net_read ensures that this number
    of bytes was actually read from network. Additionally my_net_read
    sets packet[packet_length]= 0 (thus if packet_length == 0,
    command == packet[0] == COM_SLEEP).
    In dispatch_command packet[packet_length] points beyond the end of packet.
  */
unknown's avatar
unknown committed
1577
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1578
}
1579
#endif  /* EMBEDDED_LIBRARY */
1580

1581

1582 1583
/*
   Perform one connection-level (COM_XXXX) command.
1584

1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
  SYNOPSIS
    dispatch_command()
    thd             connection handle
    command         type of command to perform 
    packet          data for the command, packet is always null-terminated
    packet_length   length of packet + 1 (to show that data is
                    null-terminated) except for COM_SLEEP, where it
                    can be zero.
  RETURN VALUE
    0   ok
    1   request of thread shutdown, i. e. if command is
        COM_QUIT/COM_SHUTDOWN
*/
1598

1599 1600 1601 1602
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1603
  bool error= 0;
1604 1605
  DBUG_ENTER("dispatch_command");

1606
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
1607
  {
1608
    thd->killed= THD::NOT_KILLED;
1609 1610
    thd->mysys_var->abort= 0;
  }
1611

1612
  thd->command=command;
unknown's avatar
unknown committed
1613
  /*
1614 1615
    Commands which always take a long time are logged into
    the slow log only if opt_log_slow_admin_statements is set.
unknown's avatar
unknown committed
1616
  */
1617
  thd->enable_slow_log= TRUE;
1618
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
unknown's avatar
unknown committed
1619
  thd->set_time();
unknown's avatar
unknown committed
1620
  VOID(pthread_mutex_lock(&LOCK_thread_count));
1621
  thd->query_id= global_query_id;
unknown's avatar
unknown committed
1622
  if (command != COM_STATISTICS && command != COM_PING)
1623
    next_query_id();
unknown's avatar
unknown committed
1624
  thread_running++;
1625
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1626
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1627

1628 1629
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1630
  switch (command) {
unknown's avatar
unknown committed
1631
  case COM_INIT_DB:
unknown's avatar
unknown committed
1632 1633
  {
    LEX_STRING tmp;
1634 1635
    statistic_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB],
			&LOCK_status);
unknown's avatar
unknown committed
1636 1637
    thd->convert_string(&tmp, system_charset_info,
			packet, strlen(packet), thd->charset());
1638 1639
    if (!mysql_change_db(thd, tmp.str, FALSE))
    {
unknown's avatar
unknown committed
1640
      mysql_log.write(thd,command,"%s",thd->db);
1641 1642
      send_ok(thd);
    }
unknown's avatar
unknown committed
1643 1644
    break;
  }
unknown's avatar
unknown committed
1645
#ifdef HAVE_REPLICATION
1646 1647
  case COM_REGISTER_SLAVE:
  {
1648
    if (!register_slave(thd, (uchar*)packet, packet_length))
1649
      send_ok(thd);
1650 1651
    break;
  }
1652
#endif
unknown's avatar
unknown committed
1653
  case COM_TABLE_DUMP:
1654 1655 1656
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
unknown's avatar
unknown committed
1657
    if (db_len >= packet_length || db_len > NAME_LEN)
unknown's avatar
unknown committed
1658
    {
unknown's avatar
unknown committed
1659
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
1660 1661
      break;
    }
1662
    uint tbl_len= *(uchar*) (packet + db_len + 1);
unknown's avatar
unknown committed
1663 1664
    if (db_len+tbl_len+2 > packet_length || tbl_len > NAME_LEN)
    {
unknown's avatar
unknown committed
1665
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
1666 1667
      break;
    }
1668

1669
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1670
    thd->enable_slow_log= opt_log_slow_admin_statements;
1671
    db= thd->alloc(db_len + tbl_len + 2);
1672 1673 1674 1675 1676
    if (!db)
    {
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
      break;
    }
1677 1678
    tbl_name= strmake(db, packet + 1, db_len)+1;
    strmake(tbl_name, packet + db_len + 2, tbl_len);
unknown's avatar
unknown committed
1679
    mysql_table_dump(thd, db, tbl_name);
1680 1681
    break;
  }
unknown's avatar
unknown committed
1682 1683
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1684
    thd->change_user();
1685
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1686

1687
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1688
    char *user= (char*) packet;
unknown's avatar
unknown committed
1689
    char *passwd= strend(user)+1;
1690
    /*
unknown's avatar
unknown committed
1691 1692 1693 1694
      Old clients send null-terminated string ('\0' for empty string) for
      password.  New clients send the size (1 byte) + string (not null
      terminated, so also '\0' for empty string).
    */
unknown's avatar
unknown committed
1695
    char db_buff[NAME_LEN+1];               // buffer to store db in utf8
unknown's avatar
unknown committed
1696
    char *db= passwd;
1697
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
unknown's avatar
unknown committed
1698 1699
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1700
#ifndef EMBEDDED_LIBRARY
1701
    /* Small check for incoming packet */
unknown's avatar
unknown committed
1702
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1703
    {
unknown's avatar
unknown committed
1704
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1705 1706
      break;
    }
1707
#endif
1708
    /* Convert database name to utf8 */
1709
    uint dummy_errors;
1710 1711
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1712
                             thd->charset(), &dummy_errors)]= 0;
1713
    db= db_buff;
unknown's avatar
unknown committed
1714

1715 1716 1717
    /* Save user and privileges */
    uint save_db_length= thd->db_length;
    char *save_db= thd->db;
1718
    Security_context save_security_ctx= *thd->security_ctx;
unknown's avatar
unknown committed
1719
    USER_CONN *save_user_connect= thd->user_connect;
1720 1721

    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
1722
    {
1723
      thd->security_ctx->user= save_security_ctx.user;
unknown's avatar
unknown committed
1724
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1725 1726
      break;
    }
unknown's avatar
unknown committed
1727

unknown's avatar
unknown committed
1728 1729
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1730
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1731

1732 1733
    if (res)
    {
1734
      /* authentication failure, we shall restore old user */
1735
      if (res > 0)
unknown's avatar
unknown committed
1736
        my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1737 1738
      x_free(thd->security_ctx->user);
      *thd->security_ctx= save_security_ctx;
unknown's avatar
unknown committed
1739
      thd->user_connect= save_user_connect;
1740 1741 1742 1743 1744
      thd->db= save_db;
      thd->db_length= save_db_length;
    }
    else
    {
1745
#ifndef NO_EMBEDDED_ACCESS_CHECKS
1746
      /* we've authenticated new user */
unknown's avatar
unknown committed
1747 1748
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1749
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
1750
      x_free((gptr) save_db);
1751
      x_free((gptr)  save_security_ctx.user);
1752
    }
unknown's avatar
unknown committed
1753 1754
    break;
  }
1755
  case COM_STMT_EXECUTE:
unknown's avatar
unknown committed
1756
  {
1757
    mysql_stmt_execute(thd, packet, packet_length);
unknown's avatar
unknown committed
1758 1759
    break;
  }
1760
  case COM_STMT_FETCH:
1761 1762 1763 1764
  {
    mysql_stmt_fetch(thd, packet, packet_length);
    break;
  }
1765
  case COM_STMT_SEND_LONG_DATA:
unknown's avatar
unknown committed
1766
  {
1767
    mysql_stmt_get_longdata(thd, packet, packet_length);
unknown's avatar
unknown committed
1768 1769
    break;
  }
1770
  case COM_STMT_PREPARE:
unknown's avatar
unknown committed
1771
  {
1772
    mysql_stmt_prepare(thd, packet, packet_length);
unknown's avatar
unknown committed
1773 1774
    break;
  }
1775
  case COM_STMT_CLOSE:
unknown's avatar
unknown committed
1776
  {
1777
    mysql_stmt_close(thd, packet);
unknown's avatar
unknown committed
1778 1779
    break;
  }
1780
  case COM_STMT_RESET:
1781 1782 1783 1784
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
unknown's avatar
unknown committed
1785 1786
  case COM_QUERY:
  {
1787 1788
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1789
    char *packet_end= thd->query + thd->query_length;
unknown's avatar
unknown committed
1790 1791 1792
    /* 'b' stands for 'buffer' parameter', special for 'my_snprintf' */
    const char *format= "%.*b";
    mysql_log.write(thd,command, format, thd->query_length, thd->query);
1793
    DBUG_PRINT("query",("%-.4096s",thd->query));
1794 1795 1796 1797

    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),QUERY_PRIOR);

1798
    mysql_parse(thd,thd->query, thd->query_length);
1799

1800
    while (!thd->killed && thd->lex->found_semicolon && !thd->net.report_error)
1801
    {
1802
      char *next_packet= thd->lex->found_semicolon;
1803
      net->no_send_error= 0;
1804
      /*
1805 1806
        Multiple queries exits, execute them individually
      */
1807 1808
      if (thd->lock || thd->open_tables || thd->derived_tables ||
          thd->prelocked_mode)
1809
        close_thread_tables(thd);
1810
      ulong length= (ulong)(packet_end - next_packet);
1811

1812
      log_slow_statement(thd);
1813

1814
      /* Remove garbage at start of query */
1815
      while (my_isspace(thd->charset(), *next_packet) && length > 0)
1816
      {
1817
        next_packet++;
1818 1819
        length--;
      }
unknown's avatar
unknown committed
1820
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1821
      thd->query_length= length;
1822
      thd->query= next_packet;
1823
      thd->query_id= next_query_id();
1824
      thd->set_time(); /* Reset the query start time. */
1825
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1826
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1827
      mysql_parse(thd, next_packet, length);
1828 1829
    }

unknown's avatar
unknown committed
1830 1831 1832 1833 1834
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1835
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1836
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
1837 1838
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
unknown's avatar
unknown committed
1839 1840 1841
    break;
#else
  {
1842
    char *fields, *pend;
1843
    /* Locked closure of all tables */
unknown's avatar
unknown committed
1844
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1845
    LEX_STRING conv_name;
1846

unknown's avatar
unknown committed
1847 1848
    /* used as fields initializator */
    lex_start(thd, 0, 0);
1849

1850 1851
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
unknown's avatar
unknown committed
1852
    bzero((char*) &table_list,sizeof(table_list));
unknown's avatar
unknown committed
1853
    if (thd->copy_db_to(&table_list.db, 0))
unknown's avatar
unknown committed
1854
      break;
1855
    pend= strend(packet);
unknown's avatar
unknown committed
1856 1857
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1858
    table_list.alias= table_list.table_name= conv_name.str;
1859
    packet= pend+1;
1860 1861 1862 1863 1864 1865 1866 1867 1868

    if (!my_strcasecmp(system_charset_info, table_list.db,
                       information_schema_name.str))
    {
      ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, table_list.alias);
      if (schema_table)
        table_list.schema_table= schema_table;
    }

1869
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
unknown's avatar
unknown committed
1870 1871
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1872
    mysql_log.write(thd,command,"%s %s",table_list.table_name, fields);
1873
    if (lower_case_table_names)
1874 1875
      my_casedn_str(files_charset_info, table_list.table_name);
    remove_escape(table_list.table_name);	// This can't have wildcards
unknown's avatar
unknown committed
1876

unknown's avatar
unknown committed
1877
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
1878
		     0, 0, test(table_list.schema_table)))
unknown's avatar
unknown committed
1879
      break;
unknown's avatar
unknown committed
1880 1881
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1882
      break;
1883 1884 1885 1886 1887 1888
    /* init structures for VIEW processing */
    table_list.select_lex= &(thd->lex->select_lex);
    mysql_init_query(thd, (uchar*)"", 0);
    thd->lex->
      select_lex.table_list.link_in_list((byte*) &table_list,
                                         (byte**) &table_list.next_local);
unknown's avatar
unknown committed
1889
    thd->lex->add_to_query_tables(&table_list);
1890

1891 1892
    /* switch on VIEW optimisation: do not fill temporary tables */
    thd->lex->sql_command= SQLCOM_SHOW_FIELDS;
unknown's avatar
unknown committed
1893
    mysqld_list_fields(thd,&table_list,fields);
1894
    thd->lex->unit.cleanup();
1895
    thd->cleanup_after_query();
unknown's avatar
unknown committed
1896 1897 1898 1899
    break;
  }
#endif
  case COM_QUIT:
1900
    /* We don't calculate statistics for this command */
1901
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1902 1903 1904 1905
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1906
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1907
    {
unknown's avatar
unknown committed
1908
      char *db=thd->strdup(packet), *alias;
1909
      HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1910

1911 1912
      statistic_increment(thd->status_var.com_stat[SQLCOM_CREATE_DB],
			  &LOCK_status);
1913
      // null test to handle EOM
unknown's avatar
unknown committed
1914
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1915
      {
1916
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1917 1918
	break;
      }
1919
      if (check_access(thd,CREATE_ACL,db,0,1,0,is_schema_db(db)))
unknown's avatar
unknown committed
1920
	break;
1921
      mysql_log.write(thd,command,packet);
1922
      bzero(&create_info, sizeof(create_info));
1923 1924
      mysql_create_db(thd, (lower_case_table_names == 2 ? alias : db),
                      &create_info, 0);
unknown's avatar
unknown committed
1925 1926
      break;
    }
unknown's avatar
unknown committed
1927
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1928
    {
1929 1930
      statistic_increment(thd->status_var.com_stat[SQLCOM_DROP_DB],
			  &LOCK_status);
1931
      char *db=thd->strdup(packet);
unknown's avatar
unknown committed
1932
      /*  null test to handle EOM */
1933
      if (!db || check_db_name(db))
1934
      {
1935
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1936 1937
	break;
      }
1938
      if (check_access(thd,DROP_ACL,db,0,1,0,is_schema_db(db)))
1939
	break;
unknown's avatar
unknown committed
1940 1941
      if (thd->locked_tables || thd->active_transaction())
      {
unknown's avatar
unknown committed
1942 1943
	my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                   ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
unknown's avatar
unknown committed
1944
	break;
unknown's avatar
unknown committed
1945
      }
1946
      mysql_log.write(thd,command,db);
1947
      mysql_rm_db(thd, db, 0, 0);
unknown's avatar
unknown committed
1948 1949
      break;
    }
1950
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1951 1952
  case COM_BINLOG_DUMP:
    {
unknown's avatar
unknown committed
1953 1954 1955 1956
      ulong pos;
      ushort flags;
      uint32 slave_server_id;

1957
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1958
      thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
unknown committed
1959
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1960
	break;
unknown's avatar
unknown committed
1961

1962
      /* TODO: The following has to be changed to an 8 byte integer */
1963 1964
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1965
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1966
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1967
	kill_zombie_dump_threads(slave_server_id);
1968
      thd->server_id = slave_server_id;
unknown's avatar
unknown committed
1969 1970 1971

      mysql_log.write(thd, command, "Log: '%s'  Pos: %ld", packet+10,
                      (long) pos);
1972
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1973
      unregister_slave(thd,1,1);
unknown's avatar
unknown committed
1974
      /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
1975 1976
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
1977 1978
      break;
    }
1979
#endif
unknown's avatar
unknown committed
1980
  case COM_REFRESH:
unknown's avatar
unknown committed
1981 1982 1983 1984 1985 1986
  {
    bool not_used;
    statistic_increment(thd->status_var.com_stat[SQLCOM_FLUSH],
                        &LOCK_status);
    ulong options= (ulong) (uchar) packet[0];
    if (check_global_access(thd,RELOAD_ACL))
unknown's avatar
unknown committed
1987
      break;
unknown's avatar
unknown committed
1988 1989 1990 1991 1992
    mysql_log.write(thd,command,NullS);
    if (!reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, &not_used))
      send_ok(thd);
    break;
  }
1993
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1994
  case COM_SHUTDOWN:
1995
  {
1996
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
1997
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
1998
      break; /* purecov: inspected */
1999
    /*
2000 2001 2002 2003
      If the client is < 4.1.3, it is going to send us no argument; then
      packet_length is 1, packet[0] is the end 0 of the packet. Note that
      SHUTDOWN_DEFAULT is 0. If client is >= 4.1.3, the shutdown level is in
      packet[0].
2004
    */
2005 2006
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
2007
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
2008 2009 2010 2011 2012 2013 2014
    if (level == SHUTDOWN_DEFAULT)
      level= SHUTDOWN_WAIT_ALL_BUFFERS; // soon default will be configurable
    else if (level != SHUTDOWN_WAIT_ALL_BUFFERS)
    {
      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "this shutdown level");
      break;
    }
2015
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
2016
    mysql_log.write(thd,command,NullS);
2017
    send_eof(thd);
unknown's avatar
unknown committed
2018 2019 2020
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
unknown's avatar
unknown committed
2021
#ifndef OS2
2022
    send_eof(thd);				// This is for 'quit request'
unknown's avatar
unknown committed
2023
#endif
2024
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
2025 2026 2027 2028
    close_thread_tables(thd);			// Free before kill
    kill_mysql();
    error=TRUE;
    break;
2029
  }
2030
#endif
unknown's avatar
unknown committed
2031 2032
  case COM_STATISTICS:
  {
2033
    mysql_log.write(thd,command,NullS);
2034 2035
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_STATUS],
			&LOCK_status);
unknown's avatar
unknown committed
2036
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2037
    char buff[200];
unknown's avatar
unknown committed
2038 2039 2040
#else
    char *buff= thd->net.last_error;
#endif
2041 2042 2043 2044

    STATUS_VAR current_global_status_var;
    calc_sum_of_all_status(&current_global_status_var);

2045
    ulong uptime = (ulong) (thd->start_time - server_start_time);
unknown's avatar
unknown committed
2046
    sprintf((char*) buff,
2047
	    "Uptime: %lu  Threads: %d  Questions: %lu  Slow queries: %lu  Opens: %lu  Flush tables: %lu  Open tables: %u  Queries per second avg: %.3f",
unknown's avatar
unknown committed
2048
	    uptime,
2049
	    (int) thread_count, (ulong) thd->query_id,
2050 2051
	    current_global_status_var.long_query_count,
	    current_global_status_var.opened_tables, refresh_version, cached_tables(),
2052 2053
	    (uptime ? (ulonglong2double(thd->query_id) / (double) uptime) :
	     (double) 0));
unknown's avatar
unknown committed
2054
#ifdef SAFEMALLOC
2055
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
2056
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
2057 2058
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
2059 2060
#endif
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2061
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
2062
    VOID(net_flush(net));
unknown's avatar
unknown committed
2063
#endif
unknown's avatar
unknown committed
2064 2065 2066
    break;
  }
  case COM_PING:
2067
    statistic_increment(thd->status_var.com_other, &LOCK_status);
2068
    send_ok(thd);				// Tell client we are alive
unknown's avatar
unknown committed
2069 2070
    break;
  case COM_PROCESS_INFO:
2071 2072
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST],
			&LOCK_status);
2073 2074
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd, PROCESS_ACL))
unknown's avatar
unknown committed
2075
      break;
2076
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
2077
    mysqld_list_processes(thd,
2078 2079
			  thd->security_ctx->master_access & PROCESS_ACL ? 
			  NullS : thd->security_ctx->priv_user, 0);
unknown's avatar
unknown committed
2080 2081 2082
    break;
  case COM_PROCESS_KILL:
  {
2083
    statistic_increment(thd->status_var.com_stat[SQLCOM_KILL], &LOCK_status);
2084
    ulong id=(ulong) uint4korr(packet);
unknown's avatar
SCRUM  
unknown committed
2085
    kill_one_thread(thd,id,false);
unknown's avatar
unknown committed
2086 2087
    break;
  }
2088 2089
  case COM_SET_OPTION:
  {
2090 2091
    statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
			&LOCK_status);
2092 2093 2094 2095
    uint opt_command= uint2korr(packet);

    switch (opt_command) {
    case (int) MYSQL_OPTION_MULTI_STATEMENTS_ON:
2096
      thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
2097
      send_eof(thd);
2098
      break;
2099
    case (int) MYSQL_OPTION_MULTI_STATEMENTS_OFF:
2100
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
2101
      send_eof(thd);
2102 2103
      break;
    default:
unknown's avatar
unknown committed
2104
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
2105 2106 2107 2108
      break;
    }
    break;
  }
unknown's avatar
unknown committed
2109
  case COM_DEBUG:
2110
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
2111
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2112
      break;					/* purecov: inspected */
2113
    mysql_print_status();
2114
    mysql_log.write(thd,command,NullS);
2115
    send_eof(thd);
unknown's avatar
unknown committed
2116 2117 2118 2119 2120
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
2121
  case COM_END:
unknown's avatar
unknown committed
2122
  default:
unknown's avatar
unknown committed
2123
    my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
2124 2125
    break;
  }
2126 2127
  if (thd->lock || thd->open_tables || thd->derived_tables ||
      thd->prelocked_mode)
unknown's avatar
unknown committed
2128
  {
2129
    thd_proc_info(thd, "closing tables");
unknown's avatar
unknown committed
2130 2131
    close_thread_tables(thd);			/* Free tables */
  }
2132 2133 2134 2135 2136 2137 2138 2139 2140 2141
  /*
    assume handlers auto-commit (if some doesn't - transaction handling
    in MySQL should be redesigned to support it; it's a big change,
    and it's not worth it - better to commit explicitly only writing
    transactions, read-only ones should better take care of themselves.
    saves some work in 2pc too)
    see also sql_base.cc - close_thread_tables()
  */
  bzero(&thd->transaction.stmt, sizeof(thd->transaction.stmt));
  if (!thd->active_transaction())
2142
    thd->transaction.xid_state.xid.null();
unknown's avatar
unknown committed
2143

unknown's avatar
unknown committed
2144 2145 2146
  /* report error issued during command execution */
  if (thd->killed_errno() && !thd->net.report_error)
    thd->send_kill_message();
unknown's avatar
unknown committed
2147
  if (thd->net.report_error)
2148
    net_send_error(thd);
unknown's avatar
unknown committed
2149

2150
  log_slow_statement(thd);
2151

2152
  thd_proc_info(thd, "cleaning up");
2153
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
2154
  thd_proc_info(thd, 0);
2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
  thd->command=COM_SLEEP;
  thd->query=0;
  thd->query_length=0;
  thread_running--;
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
  thd->packet.shrink(thd->variables.net_buffer_length);	// Reclaim some memory
  free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
  DBUG_RETURN(error);
}


2166
void log_slow_statement(THD *thd)
2167
{
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
  time_t start_of_query;

  /*
    The following should never be true with our current code base,
    but better to keep this here so we don't accidently try to log a
    statement in a trigger or stored function
  */
  if (unlikely(thd->in_sub_stmt))
    return;                                     // Don't set time for sub stmt

  start_of_query= thd->start_time;
2179
  thd->end_time();				// Set start time
2180

2181 2182 2183 2184 2185
  /*
    Do not log administrative statements unless the appropriate option is
    set; do not log into slow log if reading from backup.
  */
  if (thd->enable_slow_log && !thd->user_time)
unknown's avatar
unknown committed
2186
  {
2187
    thd_proc_info(thd, "logging slow query");
2188

2189 2190
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2191
        (thd->server_status &
2192
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2193 2194 2195
        (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES) &&
        /* == SQLCOM_END unless this is a SHOW command */
        thd->lex->orig_sql_command == SQLCOM_END)
2196
    {
2197
      thd_proc_info(thd, "logging slow query");
2198
      thd->status_var.long_query_count++;
2199 2200
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
unknown's avatar
unknown committed
2201 2202 2203
  }
}

2204

unknown's avatar
unknown committed
2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
/*
  Create a TABLE_LIST object for an INFORMATION_SCHEMA table.

  SYNOPSIS
    prepare_schema_table()
      thd              thread handle
      lex              current lex
      table_ident      table alias if it's used
      schema_table_idx the type of the INFORMATION_SCHEMA table to be
                       created

  DESCRIPTION
    This function is used in the parser to convert a SHOW or DESCRIBE
    table_name command to a SELECT from INFORMATION_SCHEMA.
    It prepares a SELECT_LEX and a TABLE_LIST object to represent the
    given command as a SELECT parse tree.

  NOTES
    Due to the way this function works with memory and LEX it cannot
    be used outside the parser (parse tree transformations outside
    the parser break PS and SP).

  RETURN VALUE
    0                 success
    1                 out of memory or SHOW commands are not allowed
                      in this version of the server.
*/

2233 2234 2235 2236 2237
int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
                         enum enum_schema_tables schema_table_idx)
{
  DBUG_ENTER("prepare_schema_table");
  SELECT_LEX *sel= 0;
2238
  switch (schema_table_idx) {
2239 2240
  case SCH_SCHEMATA:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
2241 2242
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0));   /* purecov: inspected */
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
    DBUG_RETURN(1);
#else
    if ((specialflag & SPECIAL_SKIP_SHOW_DB) &&
	check_global_access(thd, SHOW_DB_ACL))
      DBUG_RETURN(1);
    break;
#endif
  case SCH_TABLE_NAMES:
  case SCH_TABLES:
  case SCH_VIEWS:
2253
  case SCH_TRIGGERS:
2254
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2255 2256
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2257 2258 2259
    DBUG_RETURN(1);
#else
    {
unknown's avatar
unknown committed
2260 2261 2262
      char *db;
      if (lex->select_lex.db == NULL &&
          thd->copy_db_to(&lex->select_lex.db, 0))
2263
      {
unknown's avatar
unknown committed
2264
        DBUG_RETURN(1);
2265
      }
unknown's avatar
unknown committed
2266
      db= lex->select_lex.db;
2267 2268 2269
      remove_escape(db);				// Fix escaped '_'
      if (check_db_name(db))
      {
unknown's avatar
unknown committed
2270
        my_error(ER_WRONG_DB_NAME, MYF(0), db);
2271 2272
        DBUG_RETURN(1);
      }
2273 2274
      if (check_access(thd, SELECT_ACL, db, &thd->col_access, 0, 0,
                       is_schema_db(db)))
2275 2276 2277
        DBUG_RETURN(1);			        /* purecov: inspected */
      if (!thd->col_access && check_grant_db(thd,db))
      {
unknown's avatar
unknown committed
2278
	my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
2279 2280
                 thd->security_ctx->priv_user, thd->security_ctx->priv_host,
                 db);
2281 2282 2283 2284 2285 2286 2287 2288
	DBUG_RETURN(1);
      }
      break;
    }
#endif
  case SCH_COLUMNS:
  case SCH_STATISTICS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2289 2290
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2291 2292 2293 2294 2295 2296
    DBUG_RETURN(1);
#else
    if (table_ident)
    {
      TABLE_LIST **query_tables_last= lex->query_tables_last;
      sel= new SELECT_LEX();
unknown's avatar
unknown committed
2297 2298
      /* 'parent_lex' is used in init_query() so it must be before it. */
      sel->parent_lex= lex;
2299
      sel->init_query();
unknown's avatar
unknown committed
2300
      if (!sel->add_table_to_list(thd, table_ident, 0, 0, TL_READ, 
2301 2302 2303 2304 2305 2306
                                 (List<String> *) 0, (List<String> *) 0))
        DBUG_RETURN(1);
      lex->query_tables_last= query_tables_last;
      TABLE_LIST *table_list= (TABLE_LIST*) sel->table_list.first;
      char *db= table_list->db;
      remove_escape(db);			// Fix escaped '_'
2307
      remove_escape(table_list->table_name);
2308
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
2309 2310
                       &table_list->grant.privilege, 0, 0,
                       test(table_list->schema_table)))
2311 2312 2313 2314 2315 2316 2317
        DBUG_RETURN(1);				/* purecov: inspected */
      if (grant_option && check_grant(thd, SELECT_ACL, table_list, 2,
                                      UINT_MAX, 0))
        DBUG_RETURN(1);
      break;
    }
#endif
2318 2319 2320
  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
  case SCH_PROCEDURES:
  case SCH_CHARSETS:
  case SCH_COLLATIONS:
  case SCH_COLLATION_CHARACTER_SET_APPLICABILITY:
  case SCH_USER_PRIVILEGES:
  case SCH_SCHEMA_PRIVILEGES:
  case SCH_TABLE_PRIVILEGES:
  case SCH_COLUMN_PRIVILEGES:
  case SCH_TABLE_CONSTRAINTS:
  case SCH_KEY_COLUMN_USAGE:
  default:
    break;
  }
  
  SELECT_LEX *select_lex= lex->current_select;
  if (make_schema_select(thd, select_lex, schema_table_idx))
  {
    DBUG_RETURN(1);
  }
  TABLE_LIST *table_list= (TABLE_LIST*) select_lex->table_list.first;
  table_list->schema_select_lex= sel;
2342
  table_list->schema_table_reformed= 1;
2343 2344
  statistic_increment(thd->status_var.com_stat[lex->orig_sql_command],
                      &LOCK_status);
2345 2346 2347 2348
  DBUG_RETURN(0);
}


2349 2350
/*
  Read query from packet and store in thd->query
2351
  Used in COM_QUERY and COM_STMT_PREPARE
2352 2353 2354 2355 2356 2357 2358

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
unknown's avatar
unknown committed
2359 2360
    FALSE ok
    TRUE  error;  In this case thd->fatal_error is set
2361 2362
*/

2363
bool alloc_query(THD *thd, const char *packet, uint packet_length)
2364 2365
{
  packet_length--;				// Remove end null
2366
  /* Remove garbage at start and end of query */
unknown's avatar
unknown committed
2367
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
2368 2369 2370 2371
  {
    packet++;
    packet_length--;
  }
2372
  const char *pos= packet + packet_length;     // Point at end null
unknown's avatar
unknown committed
2373
  while (packet_length > 0 &&
unknown's avatar
unknown committed
2374
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
2375 2376 2377 2378 2379
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
2380
  thd->query_length= 0;                        // Extra safety: Avoid races
2381 2382
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
2383 2384
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
unknown's avatar
unknown committed
2385
    return TRUE;
2386 2387
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
2388 2389 2390 2391

  /* Reclaim some memory */
  thd->packet.shrink(thd->variables.net_buffer_length);
  thd->convert_buffer.shrink(thd->variables.net_buffer_length);
2392

unknown's avatar
unknown committed
2393
  return FALSE;
2394 2395
}

2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
static void reset_one_shot_variables(THD *thd) 
{
  thd->variables.character_set_client=
    global_system_variables.character_set_client;
  thd->variables.collation_connection=
    global_system_variables.collation_connection;
  thd->variables.collation_database=
    global_system_variables.collation_database;
  thd->variables.collation_server=
    global_system_variables.collation_server;
  thd->update_charset();
  thd->variables.time_zone=
    global_system_variables.time_zone;
2409
  thd->variables.lc_time_names= &my_locale_en_US;
2410 2411 2412
  thd->one_shot_set= 0;
}

2413

2414
/*
2415
  Execute command saved in thd and lex->sql_command
2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436

  SYNOPSIS
    mysql_execute_command()
      thd                       Thread handle

  IMPLEMENTATION

    Before every operation that can request a write lock for a table
    wait if a global read lock exists. However do not wait if this
    thread has locked tables already. No new locks can be requested
    until the other locks are released. The thread that requests the
    global read lock waits for write locked tables to become unlocked.

    Note that wait_if_global_read_lock() sets a protection against a new
    global read lock when it succeeds. This needs to be released by
    start_waiting_global_read_lock() after the operation.

  RETURN
    FALSE       OK
    TRUE        Error
*/
unknown's avatar
unknown committed
2437

unknown's avatar
unknown committed
2438
bool
2439
mysql_execute_command(THD *thd)
unknown's avatar
unknown committed
2440
{
2441 2442
  bool res= FALSE;
  bool need_start_waiting= FALSE; // have protection against global read lock
2443
  int  up_result= 0;
2444
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
2445
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
unknown's avatar
unknown committed
2446
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
2447
  /* first table of first SELECT_LEX */
unknown's avatar
unknown committed
2448
  TABLE_LIST *first_table= (TABLE_LIST*) select_lex->table_list.first;
unknown's avatar
VIEW  
unknown committed
2449 2450 2451
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
2452
  SELECT_LEX_UNIT *unit= &lex->unit;
2453
  /* Saved variable value */
unknown's avatar
unknown committed
2454
  DBUG_ENTER("mysql_execute_command");
2455
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
2456

2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470
  /*
    Remember first generated insert id value of the previous
    statement.  We remember it here at the beginning of the statement,
    and also in Item_func_last_insert_id::fix_fields() and
    sys_var_last_insert_id::value_ptr().  Last two places are required
    because LAST_INSERT_ID() and @@LAST_INSERT_ID may also be used in
    expression that is not executed with mysql_execute_command().

    And we remember it here because some statements read
    @@LAST_INSERT_ID indirectly, like "SELECT * FROM t1 WHERE id IS
    NULL", that may replace "id IS NULL" with "id = <LAST_INSERT_ID>".
  */
  thd->current_insert_id= thd->last_insert_id;

unknown's avatar
VIEW  
unknown committed
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
  /*
    In many cases first table of main SELECT_LEX have special meaning =>
    check that it is first table in global list and relink it first in 
    queries_tables list if it is necessary (we need such relinking only
    for queries with subqueries in select list, in this case tables of
    subqueries will go to global list first)

    all_tables will differ from first_table only if most upper SELECT_LEX
    do not contain tables.

    Because of above in place where should be at least one table in most
    outer SELECT_LEX we have following check:
    DBUG_ASSERT(first_table == all_tables);
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
  */
  lex->first_lists_tables_same();
2487
  /* should be assigned after making first tables same */
unknown's avatar
VIEW  
unknown committed
2488
  all_tables= lex->query_tables;
2489 2490 2491 2492
  /* set context for commands which do not use setup_tables */
  select_lex->
    context.resolve_in_table_list_only((TABLE_LIST*)select_lex->
                                       table_list.first);
unknown's avatar
VIEW  
unknown committed
2493

2494 2495 2496 2497 2498
  /*
    Reset warning count for each query that uses tables
    A better approach would be to reset this for any commands
    that is not a SHOW command or a select that only access local
    variables, but for now this is probably good enough.
2499
    Don't reset warnings when executing a stored routine.
2500
  */
2501
  if ((all_tables || &lex->select_lex != lex->all_selects_list ||
2502
       lex->sroutines.records) && !thd->spcont ||
2503
      lex->time_zone_tables_used)
unknown's avatar
unknown committed
2504
    mysql_reset_errors(thd, 0);
2505

unknown's avatar
SCRUM  
unknown committed
2506
#ifdef HAVE_REPLICATION
2507
  if (unlikely(thd->slave_thread))
2508
  {
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532
    if (lex->sql_command == SQLCOM_DROP_TRIGGER)
    {
      /*
        When dropping a trigger, we need to load its table name
        before checking slave filter rules.
      */
      add_table_for_trigger(thd, thd->lex->spname, 1, &all_tables);
      
      if (!all_tables)
      {
        /*
          If table name cannot be loaded,
          it means the trigger does not exists possibly because
          CREATE TRIGGER was previously skipped for this trigger
          according to slave filtering rules.
          Returning success without producing any errors in this case.
        */
        DBUG_RETURN(0);
      }
      
      // force searching in slave.cc:tables_ok() 
      all_tables->updating= 1;
    }
    
unknown's avatar
unknown committed
2533
    /*
unknown's avatar
unknown committed
2534 2535
      Check if statment should be skipped because of slave filtering
      rules
2536 2537

      Exceptions are:
unknown's avatar
unknown committed
2538 2539
      - UPDATE MULTI: For this statement, we want to check the filtering
        rules later in the code
2540
      - SET: we always execute it (Not that many SET commands exists in
unknown's avatar
unknown committed
2541 2542
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
2543 2544
      - DROP TEMPORARY TABLE IF EXISTS: we always execute it (otherwise we
        have stale files on slave caused by exclusion of one tmp table).
unknown's avatar
merge  
unknown committed
2545
    */
unknown's avatar
unknown committed
2546 2547
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
	!(lex->sql_command == SQLCOM_SET_OPTION) &&
2548
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2549
          lex->drop_temporary && lex->drop_if_exists) &&
unknown's avatar
Merge  
unknown committed
2550
        all_tables_not_ok(thd, all_tables))
unknown's avatar
unknown committed
2551 2552
    {
      /* we warn the slave SQL thread */
unknown's avatar
unknown committed
2553
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
      if (thd->one_shot_set)
      {
        /*
          It's ok to check thd->one_shot_set here:

          The charsets in a MySQL 5.0 slave can change by both a binlogged
          SET ONE_SHOT statement and the event-internal charset setting, 
          and these two ways to change charsets do not seems to work
          together.

          At least there seems to be problems in the rli cache for
          charsets if we are using ONE_SHOT.  Note that this is normally no
          problem because either the >= 5.0 slave reads a 4.1 binlog (with
          ONE_SHOT) *or* or 5.0 binlog (without ONE_SHOT) but never both."
        */
        reset_one_shot_variables(thd);
      }
2571
      DBUG_RETURN(0);
unknown's avatar
unknown committed
2572
    }
2573
  }
2574
  else
2575
  {
2576
#endif /* HAVE_REPLICATION */
2577 2578 2579 2580 2581
    /*
      When option readonly is set deny operations which change non-temporary
      tables. Except for the replication thread and the 'super' users.
    */
    if (opt_readonly &&
2582 2583 2584 2585 2586 2587 2588
        !(thd->security_ctx->master_access & SUPER_ACL) &&
        uc_update_queries[lex->sql_command] &&
        !((lex->sql_command == SQLCOM_CREATE_TABLE) &&
          (lex->create_info.options & HA_LEX_CREATE_TMP_TABLE)) &&
        !((lex->sql_command == SQLCOM_DROP_TABLE) && lex->drop_temporary) &&
        ((lex->sql_command != SQLCOM_UPDATE_MULTI) &&
          some_non_temp_table_to_be_updated(thd, all_tables)))
2589 2590 2591 2592 2593 2594 2595
    {
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
      DBUG_RETURN(-1);
    }
#ifdef HAVE_REPLICATION
  } /* endif unlikely slave */
#endif
2596 2597 2598
  if(lex->orig_sql_command == SQLCOM_END)
    statistic_increment(thd->status_var.com_stat[lex->sql_command],
                        &LOCK_status);
2599

unknown's avatar
unknown committed
2600 2601 2602
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2603 2604 2605 2606
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
2607 2608
	param->select_limit=
          new Item_int((ulonglong)thd->variables.select_limit);
2609 2610
    }

2611
    select_result *sel_result=lex->result;
unknown's avatar
VIEW  
unknown committed
2612
    if (all_tables)
unknown's avatar
unknown committed
2613
    {
2614 2615 2616 2617 2618 2619
      if (lex->orig_sql_command != SQLCOM_SHOW_STATUS_PROC &&
          lex->orig_sql_command != SQLCOM_SHOW_STATUS_FUNC)
        res= check_table_access(thd,
                                lex->exchange ? SELECT_ACL | FILE_ACL :
                                SELECT_ACL,
                                all_tables, 0);
unknown's avatar
unknown committed
2620 2621
    }
    else
unknown's avatar
VIEW  
unknown committed
2622 2623
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
2624
			any_db, 0, 0, 0, 0);
unknown's avatar
unknown committed
2625
    if (res)
unknown's avatar
unknown committed
2626
      goto error;
unknown's avatar
unknown committed
2627

unknown's avatar
VIEW  
unknown committed
2628
    if (!(res= open_and_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
2629
    {
unknown's avatar
unknown committed
2630
      if (lex->describe)
unknown's avatar
unknown committed
2631
      {
2632 2633 2634 2635 2636 2637
        /*
          We always use select_send for EXPLAIN, even if it's an EXPLAIN
          for SELECT ... INTO OUTFILE: a user application should be able
          to prepend EXPLAIN to any query and receive output for it,
          even if the query itself redirects the output.
        */
2638
	if (!(sel_result= new select_send()))
2639
	  goto error;
2640
	else
2641 2642
	  thd->send_explain_fields(sel_result);
	res= mysql_explain_union(thd, &thd->lex->unit, sel_result);
unknown's avatar
unknown committed
2643 2644 2645 2646 2647
	if (lex->describe & DESCRIBE_EXTENDED)
	{
	  char buff[1024];
	  String str(buff,(uint32) sizeof(buff), system_charset_info);
	  str.length(0);
unknown's avatar
unknown committed
2648
	  thd->lex->unit.print(&str);
unknown's avatar
unknown committed
2649 2650 2651 2652
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2653 2654
	sel_result->send_eof();
        delete sel_result;
unknown's avatar
unknown committed
2655 2656 2657
      }
      else
      {
2658
	if (!sel_result && !(sel_result= new select_send()))
unknown's avatar
unknown committed
2659
          goto error;
unknown's avatar
VIEW  
unknown committed
2660
	query_cache_store_query(thd, all_tables);
2661 2662 2663
	res= handle_select(thd, lex, sel_result, 0);
        if (sel_result != lex->result)
          delete sel_result;
unknown's avatar
unknown committed
2664
      }
unknown's avatar
unknown committed
2665
    }
unknown's avatar
unknown committed
2666 2667
    break;
  }
unknown's avatar
unknown committed
2668
  case SQLCOM_PREPARE:
2669
  {
2670
    mysql_sql_stmt_prepare(thd);
unknown's avatar
unknown committed
2671 2672 2673 2674
    break;
  }
  case SQLCOM_EXECUTE:
  {
2675
    mysql_sql_stmt_execute(thd);
unknown's avatar
unknown committed
2676 2677 2678 2679
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2680
    mysql_sql_stmt_close(thd);
unknown's avatar
unknown committed
2681 2682
    break;
  }
unknown's avatar
unknown committed
2683
  case SQLCOM_DO:
2684 2685
    if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
        open_and_lock_tables(thd, all_tables))
unknown's avatar
unknown committed
2686
      goto error;
unknown's avatar
unknown committed
2687 2688

    res= mysql_do(thd, *lex->insert_list);
unknown's avatar
unknown committed
2689 2690
    break;

2691
  case SQLCOM_EMPTY_QUERY:
2692
    send_ok(thd);
2693 2694
    break;

unknown's avatar
unknown committed
2695 2696 2697 2698
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2699
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2700
  case SQLCOM_PURGE:
2701
  {
unknown's avatar
unknown committed
2702
    if (check_global_access(thd, SUPER_ACL))
2703
      goto error;
unknown's avatar
unknown committed
2704
    /* PURGE MASTER LOGS TO 'file' */
2705 2706 2707
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2708 2709
  case SQLCOM_PURGE_BEFORE:
  {
2710 2711
    Item *it;

2712 2713
    if (check_global_access(thd, SUPER_ACL))
      goto error;
unknown's avatar
unknown committed
2714
    /* PURGE MASTER LOGS BEFORE 'data' */
2715
    it= (Item *)lex->value_list.head();
2716
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
unknown's avatar
unknown committed
2717
        it->check_cols(1))
2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
    {
      my_error(ER_WRONG_ARGUMENTS, MYF(0), "PURGE LOGS BEFORE");
      goto error;
    }
    it= new Item_func_unix_timestamp(it);
    /*
      it is OK only emulate fix_fieds, because we need only
      value of constant
    */
    it->quick_fix_field();
    res = purge_master_logs_before_date(thd, (ulong)it->val_int());
2729 2730
    break;
  }
2731
#endif
unknown's avatar
unknown committed
2732 2733
  case SQLCOM_SHOW_WARNS:
  {
2734 2735
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2736 2737 2738
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
unknown's avatar
unknown committed
2739 2740 2741 2742
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2743 2744
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
unknown's avatar
unknown committed
2745 2746
    break;
  }
unknown's avatar
unknown committed
2747 2748
  case SQLCOM_SHOW_PROFILES:
  {
2749
#ifdef ENABLED_PROFILING
unknown's avatar
unknown committed
2750 2751 2752
    thd->profiling.store();
    thd->profiling.discard();
    res= thd->profiling.show_profiles();
2753 2754 2755
    if (res)
      goto error;
#else
2756
    my_error(ER_FEATURE_DISABLED, MYF(0), "SHOW PROFILES", "enable-profiling");
2757 2758
    goto error;
#endif
unknown's avatar
unknown committed
2759 2760 2761 2762
    break;
  }
  case SQLCOM_SHOW_PROFILE:
  {
2763
#ifdef ENABLED_PROFILING
unknown's avatar
unknown committed
2764 2765
    thd->profiling.store();
    thd->profiling.discard(); // will get re-enabled by reset()
2766 2767 2768 2769 2770 2771 2772
    if (lex->profile_query_id != 0)
      res= thd->profiling.show(lex->profile_options, lex->profile_query_id);
    else
      res= thd->profiling.show_last(lex->profile_options);
    if (res)
      goto error;
#else
2773
    my_error(ER_FEATURE_DISABLED, MYF(0), "SHOW PROFILE", "enable-profiling");
2774 2775
    goto error;
#endif
unknown's avatar
unknown committed
2776 2777
    break;
  }
unknown's avatar
unknown committed
2778 2779
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
2780
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2781
      goto error;
2782
    /* This query don't work now. See comment in repl_failsafe.cc */
unknown's avatar
unknown committed
2783
#ifndef WORKING_NEW_MASTER
unknown's avatar
unknown committed
2784 2785
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "SHOW NEW MASTER");
    goto error;
unknown's avatar
unknown committed
2786
#else
unknown's avatar
unknown committed
2787 2788
    res = show_new_master(thd);
    break;
unknown's avatar
unknown committed
2789
#endif
unknown's avatar
unknown committed
2790
  }
2791

unknown's avatar
unknown committed
2792
#ifdef HAVE_REPLICATION
2793 2794
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2795
    if (check_global_access(thd, REPL_SLAVE_ACL))
2796 2797 2798 2799
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2800 2801
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2802
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2803
      goto error;
2804
    res = mysql_show_binlog_events(thd);
unknown's avatar
unknown committed
2805 2806
    break;
  }
2807 2808
#endif

unknown's avatar
unknown committed
2809
  case SQLCOM_BACKUP_TABLE:
2810
  {
unknown's avatar
VIEW  
unknown committed
2811 2812 2813
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
2814
	check_global_access(thd, FILE_ACL))
2815
      goto error; /* purecov: inspected */
2816
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2817
    res = mysql_backup_table(thd, first_table);
2818
    select_lex->table_list.first= (byte*) first_table;
2819
    lex->query_tables=all_tables;
2820 2821
    break;
  }
unknown's avatar
unknown committed
2822
  case SQLCOM_RESTORE_TABLE:
2823
  {
unknown's avatar
VIEW  
unknown committed
2824 2825 2826
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, INSERT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
2827
	check_global_access(thd, FILE_ACL))
2828
      goto error; /* purecov: inspected */
2829
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2830
    res = mysql_restore_table(thd, first_table);
2831
    select_lex->table_list.first= (byte*) first_table;
2832
    lex->query_tables=all_tables;
2833 2834
    break;
  }
unknown's avatar
unknown committed
2835 2836
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
unknown's avatar
VIEW  
unknown committed
2837 2838 2839
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
2840 2841
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2842
      goto error;
2843
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
unknown's avatar
unknown committed
2844 2845
    break;
  }
unknown's avatar
unknown committed
2846 2847
  case SQLCOM_PRELOAD_KEYS:
  {
unknown's avatar
VIEW  
unknown committed
2848 2849 2850
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
2851 2852
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
2853
      goto error;
unknown's avatar
VIEW  
unknown committed
2854
    res = mysql_preload_keys(thd, first_table);
unknown's avatar
unknown committed
2855 2856
    break;
  }
unknown's avatar
unknown committed
2857
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2858
  case SQLCOM_CHANGE_MASTER:
2859
  {
unknown's avatar
unknown committed
2860
    if (check_global_access(thd, SUPER_ACL))
2861
      goto error;
2862
    pthread_mutex_lock(&LOCK_active_mi);
2863
    res = change_master(thd,active_mi);
2864
    pthread_mutex_unlock(&LOCK_active_mi);
2865 2866
    break;
  }
unknown's avatar
unknown committed
2867
  case SQLCOM_SHOW_SLAVE_STAT:
2868
  {
2869 2870
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2871
      goto error;
2872
    pthread_mutex_lock(&LOCK_active_mi);
2873
    res = show_master_info(thd,active_mi);
2874
    pthread_mutex_unlock(&LOCK_active_mi);
2875 2876
    break;
  }
unknown's avatar
unknown committed
2877
  case SQLCOM_SHOW_MASTER_STAT:
2878
  {
2879 2880
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2881 2882 2883 2884
      goto error;
    res = show_binlog_info(thd);
    break;
  }
unknown's avatar
unknown committed
2885

2886
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
2887
    if (check_global_access(thd, SUPER_ACL))
2888
      goto error;
2889
    if (end_active_trans(thd))
unknown's avatar
unknown committed
2890
      goto error;
2891 2892
    else
      res = load_master_data(thd);
2893
    break;
unknown's avatar
unknown committed
2894
#endif /* HAVE_REPLICATION */
2895 2896 2897 2898 2899 2900 2901
#ifdef HAVE_NDBCLUSTER_DB
  case SQLCOM_SHOW_NDBCLUSTER_STATUS:
    {
      res = ndbcluster_show_status(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
2902 2903 2904
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
2905
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2906 2907 2908 2909
	goto error;
      res = innodb_show_status(thd);
      break;
    }
unknown's avatar
unknown committed
2910 2911 2912
  case SQLCOM_SHOW_MUTEX_STATUS:
    {
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2913
        goto error;
unknown's avatar
unknown committed
2914 2915 2916
      res = innodb_mutex_show_status(thd);
      break;
    }
unknown's avatar
unknown committed
2917
#endif
unknown's avatar
unknown committed
2918
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2919
  case SQLCOM_LOAD_MASTER_TABLE:
2920
  {
unknown's avatar
VIEW  
unknown committed
2921
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2922 2923
    DBUG_ASSERT(first_table->db); /* Must be set in the parser */

unknown's avatar
VIEW  
unknown committed
2924
    if (check_access(thd, CREATE_ACL, first_table->db,
2925 2926
		     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2927 2928 2929 2930
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
unknown's avatar
VIEW  
unknown committed
2931
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2932
	goto error;
unknown's avatar
unknown committed
2933
    }
2934
    if (strlen(first_table->table_name) > NAME_LEN)
unknown's avatar
unknown committed
2935
    {
2936
      my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name);
unknown's avatar
unknown committed
2937 2938
      break;
    }
2939
    pthread_mutex_lock(&LOCK_active_mi);
2940 2941 2942 2943
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2944
    if (!fetch_master_table(thd, first_table->db, first_table->table_name,
2945
			    active_mi, 0, 0))
2946
    {
2947
      send_ok(thd);
2948
    }
2949
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2950
    break;
2951
  }
unknown's avatar
unknown committed
2952
#endif /* HAVE_REPLICATION */
2953

unknown's avatar
unknown committed
2954
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
2955
  {
2956
    /* If CREATE TABLE of non-temporary table, do implicit commit */
2957 2958 2959 2960 2961 2962 2963 2964 2965 2966
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
    {
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
    else 
    {
unknown's avatar
unknown committed
2967 2968
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
2969
    }
unknown's avatar
VIEW  
unknown committed
2970 2971 2972 2973 2974
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    bool link_to_local;
    // Skip first table, which is the table we are creating
    TABLE_LIST *create_table= lex->unlink_first_table(&link_to_local);
    TABLE_LIST *select_tables= lex->query_tables;
unknown's avatar
unknown committed
2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988
    /*
      Code below (especially in mysql_create_table() and select_create
      methods) may modify HA_CREATE_INFO structure in LEX, so we have to
      use a copy of this structure to make execution prepared statement-
      safe. A shallow copy is enough as this code won't modify any memory
      referenced from this structure.
    */
    HA_CREATE_INFO create_info(lex->create_info);
    Alter_info alter_info(lex->alter_info, thd->mem_root);

    if (thd->is_fatal_error)
    {
      /* out of memory when creating a copy of alter_info */
      res= 1;
2989
      goto end_with_restore_list;
unknown's avatar
unknown committed
2990
    }
unknown's avatar
unknown committed
2991

unknown's avatar
VIEW  
unknown committed
2992
    if ((res= create_table_precheck(thd, select_tables, create_table)))
unknown's avatar
unknown committed
2993
      goto end_with_restore_list;
unknown's avatar
unknown committed
2994

2995
    create_info.alias= create_table->alias;
2996

2997
#ifndef HAVE_READLINK
2998
    if (create_info.data_file_name)
2999 3000
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                   "DATA DIRECTORY option ignored");
3001
    if (create_info.index_file_name)
3002 3003
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                   "INDEX DIRECTORY option ignored");
unknown's avatar
unknown committed
3004
    create_info.data_file_name= create_info.index_file_name= NULL;
3005
#else
3006
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
3007
    if (append_file_to_dir(thd, &create_info.data_file_name,
3008
			   create_table->table_name) ||
unknown's avatar
unknown committed
3009
	append_file_to_dir(thd, &create_info.index_file_name,
3010
			   create_table->table_name))
unknown's avatar
unknown committed
3011
      goto end_with_restore_list;
3012
#endif
3013
    /*
3014
      If we are using SET CHARSET without DEFAULT, add an implicit
3015 3016
      DEFAULT to not confuse old users. (This may change).
    */
unknown's avatar
unknown committed
3017
    if ((create_info.used_fields &
3018 3019 3020
	 (HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) ==
	HA_CREATE_USED_CHARSET)
    {
unknown's avatar
unknown committed
3021 3022 3023 3024
      create_info.used_fields&= ~HA_CREATE_USED_CHARSET;
      create_info.used_fields|= HA_CREATE_USED_DEFAULT_CHARSET;
      create_info.default_table_charset= create_info.table_charset;
      create_info.table_charset= 0;
3025
    }
3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038
    /*
      The create-select command will open and read-lock the select table
      and then create, open and write-lock the new table. If a global
      read lock steps in, we get a deadlock. The write lock waits for
      the global read lock, while the global read lock waits for the
      select table to be closed. So we wait until the global readlock is
      gone before starting both steps. Note that
      wait_if_global_read_lock() sets a protection against a new global
      read lock when it succeeds. This needs to be released by
      start_waiting_global_read_lock(). We protect the normal CREATE
      TABLE in the same way. That way we avoid that a new table is
      created during a gobal read lock.
    */
3039 3040
    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
3041
    {
unknown's avatar
unknown committed
3042 3043
      res= 1;
      goto end_with_restore_list;
3044
    }
3045
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
3046
    {
3047
      select_result *sel_result;
3048

3049
      select_lex->options|= SELECT_NO_UNLOCK;
3050
      unit->set_limit(select_lex);
3051

unknown's avatar
VIEW  
unknown committed
3052
      if (!(res= open_and_lock_tables(thd, select_tables)))
3053
      {
3054 3055 3056 3057
        /*
          Is table which we are changing used somewhere in other parts
          of query
        */
3058
        if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
3059
        {
3060
          TABLE_LIST *duplicate;
3061
          if ((duplicate= unique_table(thd, create_table, select_tables, 0)))
3062 3063 3064
          {
            update_non_unique_table_error(create_table, "CREATE", duplicate);
            res= 1;
3065
            goto end_with_restore_list;
3066
          }
3067
        }
unknown's avatar
unknown committed
3068
        /* If we create merge table, we have to test tables in merge, too */
3069
        if (create_info.used_fields & HA_CREATE_USED_UNION)
unknown's avatar
unknown committed
3070 3071
        {
          TABLE_LIST *tab;
3072
          for (tab= (TABLE_LIST*) create_info.merge_list.first;
unknown's avatar
unknown committed
3073 3074 3075
               tab;
               tab= tab->next_local)
          {
3076
            TABLE_LIST *duplicate;
3077
            if ((duplicate= unique_table(thd, tab, select_tables, 0)))
unknown's avatar
unknown committed
3078
            {
3079
              update_non_unique_table_error(tab, "CREATE", duplicate);
unknown's avatar
unknown committed
3080
              res= 1;
3081
              goto end_with_restore_list;
unknown's avatar
unknown committed
3082 3083 3084
            }
          }
        }
unknown's avatar
unknown committed
3085 3086 3087 3088
        /*
          select_create is currently not re-execution friendly and
          needs to be created for every execution of a PS/SP.
        */
3089
        if ((sel_result= new select_create(create_table,
3090 3091
                                           &create_info,
                                           &alter_info,
3092 3093 3094
                                           select_lex->item_list,
                                           lex->duplicates,
                                           lex->ignore)))
3095 3096 3097 3098 3099
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
3100 3101
          res= handle_select(thd, lex, sel_result, 0);
          delete sel_result;
3102
        }
3103 3104
      }
    }
unknown's avatar
unknown committed
3105
    else
unknown's avatar
unknown committed
3106
    {
unknown's avatar
unknown committed
3107
      /* regular create */
unknown's avatar
unknown committed
3108
      if (lex->name)
unknown's avatar
unknown committed
3109
        res= mysql_create_like_table(thd, create_table, &create_info,
3110
                                     (Table_ident *)lex->name);
unknown's avatar
unknown committed
3111
      else
3112
      {
unknown's avatar
VIEW  
unknown committed
3113
        res= mysql_create_table(thd, create_table->db,
3114
                                create_table->table_name, &create_info,
unknown's avatar
unknown committed
3115
                                &alter_info, 0, 0);
3116
      }
unknown's avatar
unknown committed
3117
      if (!res)
3118
	send_ok(thd);
unknown's avatar
unknown committed
3119
    }
3120

unknown's avatar
unknown committed
3121
    /* put tables back for PS rexecuting */
unknown's avatar
unknown committed
3122
end_with_restore_list:
unknown's avatar
VIEW  
unknown committed
3123
    lex->link_first_table_back(create_table, link_to_local);
unknown's avatar
unknown committed
3124
    break;
unknown's avatar
unknown committed
3125
  }
unknown's avatar
unknown committed
3126
  case SQLCOM_CREATE_INDEX:
unknown's avatar
unknown committed
3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147
    /* Fall through */
  case SQLCOM_DROP_INDEX:
  /*
    CREATE INDEX and DROP INDEX are implemented by calling ALTER
    TABLE with proper arguments. This isn't very fast but it
    should work for most cases.

    In the future ALTER TABLE will notice that only added
    indexes and create these one by one for the existing table
    without having to do a full rebuild.

    One should normally create all indexes with CREATE TABLE or
    ALTER TABLE.
  */
  {
    Alter_info alter_info(lex->alter_info, thd->mem_root);
    HA_CREATE_INFO create_info;

    if (thd->is_fatal_error) /* out of memory creating a copy of alter_info*/
      goto error;

unknown's avatar
VIEW  
unknown committed
3148
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3149
    if (check_one_table_access(thd, INDEX_ACL, first_table))
unknown's avatar
unknown committed
3150
      goto error; /* purecov: inspected */
3151
    if (end_active_trans(thd))
unknown's avatar
unknown committed
3152
      goto error;
unknown's avatar
unknown committed
3153 3154 3155 3156 3157 3158
    /*
      Currently CREATE INDEX or DROP INDEX cause a full table rebuild
      and thus classify as slow administrative statements just like
      ALTER TABLE.
    */
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
unknown committed
3159

unknown's avatar
unknown committed
3160 3161
    bzero((char*) &create_info, sizeof(create_info));
    create_info.db_type= DB_TYPE_DEFAULT;
unknown's avatar
unknown committed
3162
    create_info.row_type= ROW_TYPE_NOT_USED;
unknown's avatar
unknown committed
3163
    create_info.default_table_charset= thd->variables.collation_database;
unknown's avatar
unknown committed
3164

3165
    res= mysql_alter_table(thd, first_table->db, first_table->table_name,
3166
                           &create_info, first_table, &alter_info,
3167
                           0, (ORDER*) 0, 0);
unknown's avatar
unknown committed
3168 3169
    break;
  }
unknown's avatar
unknown committed
3170
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3171
  case SQLCOM_SLAVE_START:
3172
  {
3173
    pthread_mutex_lock(&LOCK_active_mi);
3174
    start_slave(thd,active_mi,1 /* net report*/);
3175
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
3176
    break;
3177
  }
unknown's avatar
unknown committed
3178
  case SQLCOM_SLAVE_STOP:
3179 3180 3181 3182 3183 3184
  /*
    If the client thread has locked tables, a deadlock is possible.
    Assume that
    - the client thread does LOCK TABLE t READ.
    - then the master updates t.
    - then the SQL slave thread wants to update t,
3185
      so it waits for the client thread because t is locked by it.
3186
    - then the client thread does SLAVE STOP.
3187 3188
      SLAVE STOP waits for the SQL slave thread to terminate its
      update t, which waits for the client thread because t is locked by it.
3189 3190 3191
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
3192
  if (thd->locked_tables || thd->active_transaction() || thd->global_read_lock)
3193
  {
3194 3195
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3196
    goto error;
3197
  }
3198
  {
3199
    pthread_mutex_lock(&LOCK_active_mi);
3200
    stop_slave(thd,active_mi,1/* net report*/);
3201
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
3202
    break;
3203
  }
unknown's avatar
unknown committed
3204
#endif /* HAVE_REPLICATION */
3205

unknown's avatar
unknown committed
3206
  case SQLCOM_ALTER_TABLE:
unknown's avatar
VIEW  
unknown committed
3207
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3208
    {
unknown's avatar
unknown committed
3209
      ulong priv=0;
unknown's avatar
unknown committed
3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220
      /*
        Code in mysql_alter_table() may modify its HA_CREATE_INFO argument,
        so we have to use a copy of this structure to make execution
        prepared statement- safe. A shallow copy is enough as no memory
        referenced from this structure will be modified.
      */
      HA_CREATE_INFO create_info(lex->create_info);
      Alter_info alter_info(lex->alter_info, thd->mem_root);

      if (thd->is_fatal_error) /* out of memory creating a copy of alter_info */
        goto error;
unknown's avatar
unknown committed
3221
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
unknown's avatar
unknown committed
3222
      {
3223
	my_error(ER_WRONG_TABLE_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3224
        goto error;
unknown's avatar
unknown committed
3225
      }
unknown's avatar
unknown committed
3226 3227
      /* Must be set in the parser */
      DBUG_ASSERT(select_lex->db);
unknown's avatar
VIEW  
unknown committed
3228
      if (check_access(thd, ALTER_ACL, first_table->db,
3229 3230 3231 3232
		       &first_table->grant.privilege, 0, 0,
                       test(first_table->schema_table)) ||
	  check_access(thd,INSERT_ACL | CREATE_ACL,select_lex->db,&priv,0,0,
                       is_schema_db(select_lex->db))||
unknown's avatar
VIEW  
unknown committed
3233
	  check_merge_table_access(thd, first_table->db,
3234
				   (TABLE_LIST *)
unknown's avatar
unknown committed
3235
				   create_info.merge_list.first))
3236
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
3237 3238
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
3239
	if (check_grant(thd, ALTER_ACL, all_tables, 0, UINT_MAX, 0))
unknown's avatar
unknown committed
3240 3241 3242 3243 3244
	  goto error;
	if (lex->name && !test_all_bits(priv,INSERT_ACL | CREATE_ACL))
	{					// Rename of table
	  TABLE_LIST tmp_table;
	  bzero((char*) &tmp_table,sizeof(tmp_table));
3245
	  tmp_table.table_name=lex->name;
3246
	  tmp_table.db=select_lex->db;
unknown's avatar
unknown committed
3247
	  tmp_table.grant.privilege=priv;
unknown's avatar
unknown committed
3248 3249
	  if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0,
			  UINT_MAX, 0))
unknown's avatar
unknown committed
3250 3251 3252
	    goto error;
	}
      }
3253
      /* Don't yet allow changing of symlinks with ALTER TABLE */
unknown's avatar
unknown committed
3254
      if (create_info.data_file_name)
3255 3256
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                     "DATA DIRECTORY option ignored");
unknown's avatar
unknown committed
3257
      if (create_info.index_file_name)
3258 3259
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                     "INDEX DIRECTORY option ignored");
unknown's avatar
unknown committed
3260
      create_info.data_file_name= create_info.index_file_name= NULL;
unknown's avatar
unknown committed
3261
      /* ALTER TABLE ends previous transaction */
3262
      if (end_active_trans(thd))
unknown's avatar
unknown committed
3263
	goto error;
unknown's avatar
unknown committed
3264
      else
unknown's avatar
unknown committed
3265
      {
3266 3267 3268 3269 3270 3271 3272
        if (!thd->locked_tables &&
            !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
        {
          res= 1;
          break;
        }

3273
        thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
unknown committed
3274 3275
        res= mysql_alter_table(thd, select_lex->db, lex->name,
                               &create_info,
3276
                               first_table,
unknown's avatar
unknown committed
3277 3278
                               &alter_info,
                               select_lex->order_list.elements,
3279
                               (ORDER *) select_lex->order_list.first,
3280
                               lex->ignore);
unknown's avatar
unknown committed
3281
      }
unknown's avatar
unknown committed
3282 3283
      break;
    }
unknown's avatar
unknown committed
3284
  case SQLCOM_RENAME_TABLE:
unknown's avatar
unknown committed
3285
  {
unknown's avatar
VIEW  
unknown committed
3286
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3287
    TABLE_LIST *table;
unknown's avatar
VIEW  
unknown committed
3288
    if (check_db_used(thd, all_tables))
unknown's avatar
unknown committed
3289
      goto error;
unknown's avatar
VIEW  
unknown committed
3290
    for (table= first_table; table; table= table->next_local->next_local)
unknown's avatar
unknown committed
3291
    {
unknown's avatar
unknown committed
3292
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
3293
		       &table->grant.privilege,0,0, test(table->schema_table)) ||
unknown's avatar
VIEW  
unknown committed
3294
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next_local->db,
3295 3296
		       &table->next_local->grant.privilege, 0, 0,
                       test(table->next_local->schema_table)))
unknown's avatar
unknown committed
3297 3298 3299
	goto error;
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
3300
	TABLE_LIST old_list, new_list;
unknown's avatar
unknown committed
3301 3302 3303 3304
	/*
	  we do not need initialize old_list and new_list because we will
	  come table[0] and table->next[0] there
	*/
unknown's avatar
VIEW  
unknown committed
3305 3306 3307 3308
	old_list= table[0];
	new_list= table->next_local[0];
	if (check_grant(thd, ALTER_ACL, &old_list, 0, 1, 0) ||
	    (!test_all_bits(table->next_local->grant.privilege,
3309
			    INSERT_ACL | CREATE_ACL) &&
unknown's avatar
VIEW  
unknown committed
3310
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0, 1, 0)))
unknown's avatar
unknown committed
3311 3312 3313
	  goto error;
      }
    }
unknown's avatar
VIEW  
unknown committed
3314
    query_cache_invalidate3(thd, first_table, 0);
unknown's avatar
unknown committed
3315 3316
    if (end_active_trans(thd) || mysql_rename_tables(thd, first_table))
      goto error;
unknown's avatar
unknown committed
3317
    break;
unknown's avatar
unknown committed
3318
  }
3319
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3320 3321
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3322 3323
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3324
    goto error;
unknown's avatar
unknown committed
3325 3326
#else
    {
unknown's avatar
unknown committed
3327
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
3328 3329 3330 3331
	goto error;
      res = show_binlogs(thd);
      break;
    }
unknown's avatar
unknown committed
3332
#endif
3333
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
3334
  case SQLCOM_SHOW_CREATE:
unknown's avatar
VIEW  
unknown committed
3335
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3336
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3337 3338
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3339
    goto error;
unknown's avatar
unknown committed
3340
#else
unknown's avatar
unknown committed
3341
    {
3342 3343 3344 3345
      /* Ignore temporary tables if this is "SHOW CREATE VIEW" */
      if (lex->only_view)
        first_table->skip_temporary= 1;

unknown's avatar
VIEW  
unknown committed
3346 3347
      if (check_db_used(thd, all_tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, first_table->db,
3348 3349
		       &first_table->grant.privilege, 0, 0, 
                       test(first_table->schema_table)))
unknown's avatar
unknown committed
3350
	goto error;
unknown's avatar
unknown committed
3351
      if (grant_option && check_grant(thd, SELECT_ACL, all_tables, 2, UINT_MAX, 0))
3352
	goto error;
unknown's avatar
unknown committed
3353
      res= mysqld_show_create(thd, first_table);
unknown's avatar
unknown committed
3354 3355
      break;
    }
unknown's avatar
unknown committed
3356
#endif
3357 3358
  case SQLCOM_CHECKSUM:
  {
unknown's avatar
VIEW  
unknown committed
3359 3360 3361
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | EXTRA_ACL, all_tables, 0))
3362
      goto error; /* purecov: inspected */
unknown's avatar
VIEW  
unknown committed
3363
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
3364 3365
    break;
  }
unknown's avatar
unknown committed
3366
  case SQLCOM_REPAIR:
3367
  {
unknown's avatar
VIEW  
unknown committed
3368 3369 3370
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables, 0))
3371
      goto error; /* purecov: inspected */
3372
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3373
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
3374 3375 3376
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3377
      /* Presumably, REPAIR and binlog writing doesn't require synchronization */
3378 3379
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3380
	thd->clear_error(); // No binlog error generated
3381
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3382 3383 3384
        mysql_bin_log.write(&qinfo);
      }
    }
3385
    select_lex->table_list.first= (byte*) first_table;
3386
    lex->query_tables=all_tables;
3387 3388
    break;
  }
unknown's avatar
unknown committed
3389
  case SQLCOM_CHECK:
3390
  {
unknown's avatar
VIEW  
unknown committed
3391 3392 3393
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | EXTRA_ACL , all_tables, 0))
3394
      goto error; /* purecov: inspected */
3395
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3396
    res = mysql_check_table(thd, first_table, &lex->check_opt);
3397
    select_lex->table_list.first= (byte*) first_table;
3398
    lex->query_tables=all_tables;
3399 3400
    break;
  }
unknown's avatar
unknown committed
3401 3402
  case SQLCOM_ANALYZE:
  {
unknown's avatar
VIEW  
unknown committed
3403 3404 3405
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables, 0))
unknown's avatar
unknown committed
3406
      goto error; /* purecov: inspected */
3407
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3408
    res = mysql_analyze_table(thd, first_table, &lex->check_opt);
3409 3410 3411
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3412
      /* Presumably, ANALYZE and binlog writing doesn't require synchronization */
3413 3414
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3415
	thd->clear_error(); // No binlog error generated
3416
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3417 3418 3419
        mysql_bin_log.write(&qinfo);
      }
    }
3420
    select_lex->table_list.first= (byte*) first_table;
3421
    lex->query_tables=all_tables;
unknown's avatar
unknown committed
3422
    break;
unknown's avatar
unknown committed
3423
  }
3424

unknown's avatar
unknown committed
3425 3426
  case SQLCOM_OPTIMIZE:
  {
unknown's avatar
VIEW  
unknown committed
3427 3428 3429
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables, 0))
unknown's avatar
unknown committed
3430
      goto error; /* purecov: inspected */
3431
    thd->enable_slow_log= opt_log_slow_admin_statements;
3432
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
3433
      mysql_recreate_table(thd, first_table) :
unknown's avatar
VIEW  
unknown committed
3434
      mysql_optimize_table(thd, first_table, &lex->check_opt);
3435 3436 3437
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3438
      /* Presumably, OPTIMIZE and binlog writing doesn't require synchronization */
3439 3440
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3441
	thd->clear_error(); // No binlog error generated
3442
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3443 3444 3445
        mysql_bin_log.write(&qinfo);
      }
    }
3446
    select_lex->table_list.first= (byte*) first_table;
3447
    lex->query_tables=all_tables;
unknown's avatar
unknown committed
3448 3449 3450
    break;
  }
  case SQLCOM_UPDATE:
unknown's avatar
VIEW  
unknown committed
3451 3452
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (update_precheck(thd, all_tables))
unknown's avatar
unknown committed
3453
      break;
3454 3455
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
3456 3457 3458 3459 3460 3461 3462 3463
    res= (up_result= mysql_update(thd, all_tables,
                                  select_lex->item_list,
                                  lex->value_list,
                                  select_lex->where,
                                  select_lex->order_list.elements,
                                  (ORDER *) select_lex->order_list.first,
                                  unit->select_limit_cnt,
                                  lex->duplicates, lex->ignore));
3464
    /* mysql_update return 2 if we need to switch to multi-update */
3465
    if (up_result != 2)
3466
      break;
3467
    /* Fall through */
3468
  case SQLCOM_UPDATE_MULTI:
unknown's avatar
unknown committed
3469 3470 3471
  {
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    /* if we switched from normal update, rights are checked */
3472
    if (up_result != 2)
3473
    {
unknown's avatar
unknown committed
3474 3475 3476 3477 3478
      if ((res= multi_update_precheck(thd, all_tables)))
        break;
    }
    else
      res= 0;
unknown's avatar
unknown committed
3479

3480
    res= mysql_multi_update_prepare(thd);
unknown's avatar
unknown committed
3481

3482
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3483
    /* Check slave filtering rules */
3484
    if (unlikely(thd->slave_thread))
unknown's avatar
unknown committed
3485
    {
3486 3487
      if (all_tables_not_ok(thd, all_tables))
      {
3488 3489 3490 3491 3492
        if (res!= 0)
        {
          res= 0;             /* don't care of prev failure  */
          thd->clear_error(); /* filters are of highest prior */
        }
3493 3494 3495 3496
        /* we warn the slave SQL thread */
        my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
        break;
      }
3497 3498
      if (res)
        break;
unknown's avatar
unknown committed
3499
    }
3500 3501
    else
    {
3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514
#endif /* HAVE_REPLICATION */
      if (res)
        break;
      if (opt_readonly &&
	  !(thd->security_ctx->master_access & SUPER_ACL) &&
	  some_non_temp_table_to_be_updated(thd, all_tables))
      {
	my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
	break;
      }
#ifdef HAVE_REPLICATION
    }  /* unlikely */
#endif
unknown's avatar
unknown committed
3515

unknown's avatar
unknown committed
3516 3517 3518 3519 3520 3521
    res= mysql_multi_update(thd, all_tables,
                            &select_lex->item_list,
                            &lex->value_list,
                            select_lex->where,
                            select_lex->options,
                            lex->duplicates, lex->ignore, unit, select_lex);
unknown's avatar
unknown committed
3522
    break;
unknown's avatar
unknown committed
3523
  }
unknown's avatar
unknown committed
3524
  case SQLCOM_REPLACE:
3525 3526
  case SQLCOM_INSERT:
  {
unknown's avatar
VIEW  
unknown committed
3527
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3528
    if ((res= insert_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3529
      break;
3530 3531 3532 3533 3534 3535 3536 3537

    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
    {
      res= 1;
      break;
    }

unknown's avatar
VIEW  
unknown committed
3538
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
unknown's avatar
unknown committed
3539
		      lex->update_list, lex->value_list,
3540
                      lex->duplicates, lex->ignore);
3541 3542 3543 3544 3545 3546 3547

    /*
      If we have inserted into a VIEW, and the base table has
      AUTO_INCREMENT column, but this column is not accessible through
      a view, then we should restore LAST_INSERT_ID to the value it
      had before the statement.
    */
unknown's avatar
VIEW  
unknown committed
3548
    if (first_table->view && !first_table->contain_auto_increment)
3549 3550
      thd->last_insert_id= thd->current_insert_id;

unknown's avatar
unknown committed
3551
    break;
3552
  }
unknown's avatar
unknown committed
3553 3554 3555
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
3556
    select_result *sel_result;
unknown's avatar
VIEW  
unknown committed
3557
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3558
    if ((res= insert_precheck(thd, all_tables)))
3559
      break;
unknown's avatar
unknown committed
3560

3561
    /* Fix lock for first table */
unknown's avatar
VIEW  
unknown committed
3562 3563
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
3564

3565 3566
    /* Don't unlock tables until command is written to binary log */
    select_lex->options|= SELECT_NO_UNLOCK;
unknown's avatar
unknown committed
3567

3568
    unit->set_limit(select_lex);
3569 3570 3571 3572 3573 3574 3575 3576

    if (! thd->locked_tables &&
        ! (need_start_waiting= ! wait_if_global_read_lock(thd, 0, 1)))
    {
      res= 1;
      break;
    }

unknown's avatar
VIEW  
unknown committed
3577
    if (!(res= open_and_lock_tables(thd, all_tables)))
3578
    {
3579
      /* Skip first table, which is the table we are inserting in */
unknown's avatar
unknown committed
3580 3581
      TABLE_LIST *second_table= first_table->next_local;
      select_lex->table_list.first= (byte*) second_table;
3582 3583
      select_lex->context.table_list= 
        select_lex->context.first_name_resolution_table= second_table;
3584
      res= mysql_insert_select_prepare(thd);
3585 3586 3587 3588 3589 3590 3591
      if (!res && (sel_result= new select_insert(first_table,
                                                 first_table->table,
                                                 &lex->field_list,
                                                 &lex->update_list,
                                                 &lex->value_list,
                                                 lex->duplicates,
                                                 lex->ignore)))
3592
      {
3593
	res= handle_select(thd, lex, sel_result, OPTION_SETUP_TABLES_DONE);
3594 3595 3596 3597 3598 3599 3600 3601 3602
        /*
          Invalidate the table in the query cache if something changed
          after unlocking when changes become visible.
          TODO: this is workaround. right way will be move invalidating in
          the unlock procedure.
        */
        if (first_table->lock_type ==  TL_WRITE_CONCURRENT_INSERT &&
            thd->lock)
        {
3603 3604 3605
          /* INSERT ... SELECT should invalidate only the very first table */
          TABLE_LIST *save_table= first_table->next_local;
          first_table->next_local= 0;
3606 3607
          mysql_unlock_tables(thd, thd->lock);
          query_cache_invalidate3(thd, first_table, 1);
3608
          first_table->next_local= save_table;
3609 3610
          thd->lock=0;
        }
3611
        delete sel_result;
3612
      }
3613
      /* revert changes for SP */
unknown's avatar
unknown committed
3614
      select_lex->table_list.first= (byte*) first_table;
3615
    }
unknown's avatar
VIEW  
unknown committed
3616

3617 3618 3619 3620 3621 3622
    /*
      If we have inserted into a VIEW, and the base table has
      AUTO_INCREMENT column, but this column is not accessible through
      a view, then we should restore LAST_INSERT_ID to the value it
      had before the statement.
    */
unknown's avatar
VIEW  
unknown committed
3623
    if (first_table->view && !first_table->contain_auto_increment)
3624 3625
      thd->last_insert_id= thd->current_insert_id;

unknown's avatar
unknown committed
3626 3627
    break;
  }
3628
  case SQLCOM_TRUNCATE:
3629 3630 3631 3632 3633
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
VIEW  
unknown committed
3634 3635
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
unknown's avatar
unknown committed
3636
      goto error;
3637 3638 3639 3640
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
3641
    if (thd->locked_tables || thd->active_transaction())
3642
    {
unknown's avatar
unknown committed
3643 3644
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3645 3646
      goto error;
    }
unknown's avatar
VIEW  
unknown committed
3647

unknown's avatar
unknown committed
3648
    res= mysql_truncate(thd, first_table, 0);
3649
    break;
unknown's avatar
unknown committed
3650
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
3651
  {
unknown's avatar
VIEW  
unknown committed
3652 3653
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= delete_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3654
      break;
3655 3656
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
3657 3658 3659 3660 3661 3662 3663 3664

    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
    {
      res= 1;
      break;
    }

unknown's avatar
VIEW  
unknown committed
3665
    res = mysql_delete(thd, all_tables, select_lex->where,
3666
                       &select_lex->order_list,
unknown's avatar
unknown committed
3667 3668
                       unit->select_limit_cnt, select_lex->options,
                       FALSE);
unknown's avatar
unknown committed
3669 3670
    break;
  }
3671
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
3672
  {
unknown's avatar
VIEW  
unknown committed
3673
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3674
    TABLE_LIST *aux_tables=
unknown's avatar
unknown committed
3675
      (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
3676
    multi_delete *del_result;
unknown's avatar
unknown committed
3677

3678 3679 3680 3681 3682 3683 3684
    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
    {
      res= 1;
      break;
    }

3685
    if ((res= multi_delete_precheck(thd, all_tables)))
3686
      break;
unknown's avatar
unknown committed
3687

unknown's avatar
unknown committed
3688
    /* condition will be TRUE on SP re-excuting */
3689 3690
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
unknown's avatar
unknown committed
3691
    if (add_item_to_list(thd, new Item_null()))
unknown's avatar
unknown committed
3692
      goto error;
3693

3694
    thd_proc_info(thd, "init");
unknown's avatar
VIEW  
unknown committed
3695 3696 3697 3698
    if ((res= open_and_lock_tables(thd, all_tables)))
      break;

    if ((res= mysql_multi_delete_prepare(thd)))
unknown's avatar
unknown committed
3699
      goto error;
3700

3701 3702
    if (!thd->is_fatal_error &&
        (del_result= new multi_delete(aux_tables, lex->table_count)))
unknown's avatar
unknown committed
3703
    {
3704 3705 3706
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3707
			select_lex->item_list,
unknown's avatar
unknown committed
3708
			select_lex->where,
3709
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
unknown's avatar
unknown committed
3710 3711
			(ORDER *)NULL,
			select_lex->options | thd->options |
3712 3713
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                        OPTION_SETUP_TABLES_DONE,
3714 3715
			del_result, unit, select_lex);
      delete del_result;
unknown's avatar
unknown committed
3716 3717
    }
    else
3718
      res= TRUE;                                // Error
unknown's avatar
unknown committed
3719 3720
    break;
  }
unknown's avatar
unknown committed
3721
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
3722
  {
unknown's avatar
VIEW  
unknown committed
3723
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3724 3725
    if (!lex->drop_temporary)
    {
unknown's avatar
VIEW  
unknown committed
3726
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
3727 3728
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
unknown's avatar
unknown committed
3729
        goto error;
3730
    }
unknown's avatar
unknown committed
3731
    else
unknown's avatar
unknown committed
3732 3733 3734 3735 3736 3737
    {
      /*
	If this is a slave thread, we may sometimes execute some 
	DROP / * 40005 TEMPORARY * / TABLE
	that come from parts of binlogs (likely if we use RESET SLAVE or CHANGE
	MASTER TO), while the temporary table has already been dropped.
unknown's avatar
unknown committed
3738 3739
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
unknown's avatar
unknown committed
3740 3741 3742
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
3743

unknown's avatar
unknown committed
3744 3745
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
unknown's avatar
unknown committed
3746
    }
3747
    /* DDL and binlog write order protected by LOCK_open */
unknown's avatar
VIEW  
unknown committed
3748 3749
    res= mysql_rm_table(thd, first_table, lex->drop_if_exists,
			lex->drop_temporary);
unknown's avatar
unknown committed
3750 3751
  }
  break;
unknown's avatar
unknown committed
3752
  case SQLCOM_SHOW_PROCESSLIST:
3753 3754
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
3755
      break;
unknown's avatar
unknown committed
3756
    mysqld_list_processes(thd,
3757 3758 3759 3760
			  (thd->security_ctx->master_access & PROCESS_ACL ?
                           NullS :
                           thd->security_ctx->priv_user),
                          lex->verbose);
unknown's avatar
unknown committed
3761
    break;
unknown's avatar
unknown committed
3762 3763
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
unknown's avatar
unknown committed
3764 3765 3766 3767 3768 3769 3770
    break;
  case SQLCOM_SHOW_PRIVILEGES:
    res= mysqld_show_privileges(thd);
    break;
  case SQLCOM_SHOW_COLUMN_TYPES:
    res= mysqld_show_column_types(thd);
    break;
unknown's avatar
unknown committed
3771 3772
  case SQLCOM_SHOW_LOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3773 3774
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
3775
    goto error;
unknown's avatar
unknown committed
3776 3777
#else
    {
3778
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0,0))
unknown's avatar
unknown committed
3779 3780 3781 3782
	goto error;
      res= mysqld_show_logs(thd);
      break;
    }
unknown's avatar
unknown committed
3783 3784
#endif
  case SQLCOM_CHANGE_DB:
3785 3786
    if (!mysql_change_db(thd,select_lex->db,FALSE))
      send_ok(thd);
unknown's avatar
unknown committed
3787
    break;
3788

unknown's avatar
unknown committed
3789 3790
  case SQLCOM_LOAD:
  {
unknown's avatar
VIEW  
unknown committed
3791
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3792
    uint privilege= (lex->duplicates == DUP_REPLACE ?
unknown's avatar
unknown committed
3793 3794
		     INSERT_ACL | DELETE_ACL : INSERT_ACL) |
                    (lex->local_file ? 0 : FILE_ACL);
3795

unknown's avatar
unknown committed
3796
    if (lex->local_file)
unknown's avatar
unknown committed
3797
    {
3798
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
3799
          !opt_local_infile)
3800
      {
unknown's avatar
unknown committed
3801
	my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
3802 3803
	goto error;
      }
unknown's avatar
unknown committed
3804
    }
unknown's avatar
unknown committed
3805 3806 3807 3808

    if (check_one_table_access(thd, privilege, all_tables))
      goto error;

unknown's avatar
VIEW  
unknown committed
3809
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
unknown's avatar
unknown committed
3810
                    lex->update_list, lex->value_list, lex->duplicates,
3811
                    lex->ignore, (bool) lex->local_file);
unknown's avatar
unknown committed
3812 3813
    break;
  }
3814

unknown's avatar
unknown committed
3815
  case SQLCOM_SET_OPTION:
3816 3817
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
3818
    if ((check_table_access(thd, SELECT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
3819 3820
	 open_and_lock_tables(thd, all_tables)))
      goto error;
3821 3822
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
unknown's avatar
unknown committed
3823 3824
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
      goto error;
3825 3826 3827 3828 3829 3830 3831 3832
    }
    if (!(res= sql_set_variables(thd, lex_var_list)))
    {
      /*
        If the previous command was a SET ONE_SHOT, we don't want to forget
        about the ONE_SHOT property of that SET. So we use a |= instead of = .
      */
      thd->one_shot_set|= lex->one_shot_set;
3833
      send_ok(thd);
3834
    }
unknown's avatar
unknown committed
3835
    break;
3836
  }
unknown's avatar
unknown committed
3837

unknown's avatar
unknown committed
3838
  case SQLCOM_UNLOCK_TABLES:
3839 3840 3841 3842 3843 3844
    /*
      It is critical for mysqldump --single-transaction --master-data that
      UNLOCK TABLES does not implicitely commit a connection which has only
      done FLUSH TABLES WITH READ LOCK + BEGIN. If this assumption becomes
      false, mysqldump will not work.
    */
unknown's avatar
unknown committed
3845
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
3846 3847
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
3848
      end_active_trans(thd);
3849
      thd->options&= ~(OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3850 3851
    }
    if (thd->global_read_lock)
3852
      unlock_global_read_lock(thd);
3853
    send_ok(thd);
unknown's avatar
unknown committed
3854 3855
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
3856
    unlock_locked_tables(thd);
unknown's avatar
VIEW  
unknown committed
3857
    if (check_db_used(thd, all_tables) || end_active_trans(thd))
unknown's avatar
unknown committed
3858
      goto error;
unknown's avatar
VIEW  
unknown committed
3859
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3860
      goto error;
unknown's avatar
unknown committed
3861
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
3862
    thd->options|= OPTION_TABLE_LOCK;
unknown's avatar
VIEW  
unknown committed
3863

3864
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
3865
    {
3866 3867
#ifdef HAVE_QUERY_CACHE
      if (thd->variables.query_cache_wlock_invalidate)
unknown's avatar
VIEW  
unknown committed
3868
	query_cache.invalidate_locked_for_write(first_table);
3869
#endif /*HAVE_QUERY_CACHE*/
unknown's avatar
unknown committed
3870 3871
      thd->locked_tables=thd->lock;
      thd->lock=0;
3872
      send_ok(thd);
unknown's avatar
unknown committed
3873
    }
unknown's avatar
unknown committed
3874
    else
3875
      thd->options&= ~(OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3876 3877 3878
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3879
  {
unknown's avatar
unknown committed
3880 3881 3882 3883 3884 3885
    /*
      As mysql_create_db() may modify HA_CREATE_INFO structure passed to
      it, we need to use a copy of LEX::create_info to make execution
      prepared statement- safe.
    */
    HA_CREATE_INFO create_info(lex->create_info);
3886 3887 3888 3889 3890
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
unknown committed
3891
    char *alias;
unknown's avatar
unknown committed
3892
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3893
    {
3894
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3895 3896
      break;
    }
3897 3898 3899
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
3900
      For that reason, db_ok() in sql/slave.cc did not check the
3901 3902 3903
      do_db/ignore_db. And as this query involves no tables, tables_ok()
      above was not called. So we have to check rules again here.
    */
3904
#ifdef HAVE_REPLICATION
3905
    if (thd->slave_thread &&
3906 3907
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3908
    {
unknown's avatar
unknown committed
3909
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3910
      break;
unknown's avatar
unknown committed
3911
    }
3912
#endif
3913

3914
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3915
      break;
unknown's avatar
unknown committed
3916
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
unknown's avatar
unknown committed
3917
			 &create_info, 0);
3918 3919
    break;
  }
unknown's avatar
unknown committed
3920
  case SQLCOM_DROP_DB:
3921
  {
3922 3923 3924 3925 3926
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3927
    if (check_db_name(lex->name))
unknown's avatar
unknown committed
3928
    {
3929
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3930 3931
      break;
    }
3932 3933 3934 3935 3936 3937 3938
    /*
      If in a slave thread :
      DROP DATABASE DB may not be preceded by USE DB.
      For that reason, maybe db_ok() in sql/slave.cc did not check the 
      do_db/ignore_db. And as this query involves no tables, tables_ok()
      above was not called. So we have to check rules again here.
    */
3939
#ifdef HAVE_REPLICATION
3940 3941 3942
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3943
    {
unknown's avatar
unknown committed
3944
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3945
      break;
unknown's avatar
unknown committed
3946
    }
3947
#endif
3948
    if (check_access(thd,DROP_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3949
      break;
3950 3951
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
3952 3953
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3954 3955
      goto error;
    }
3956
    res= mysql_rm_db(thd, lex->name, lex->drop_if_exists, 0);
3957 3958
    break;
  }
3959 3960
  case SQLCOM_ALTER_DB:
  {
unknown's avatar
unknown committed
3961 3962
    char *db= lex->name;
    DBUG_ASSERT(db); /* Must be set in the parser */
3963
    if (!strip_sp(db) || check_db_name(db))
3964
    {
3965
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
3966 3967
      break;
    }
unknown's avatar
unknown committed
3968 3969 3970
    /*
      If in a slave thread :
      ALTER DATABASE DB may not be preceded by USE DB.
3971
      For that reason, maybe db_ok() in sql/slave.cc did not check the
unknown's avatar
unknown committed
3972 3973 3974 3975
      do_db/ignore_db. And as this query involves no tables, tables_ok()
      above was not called. So we have to check rules again here.
    */
#ifdef HAVE_REPLICATION
3976
    if (thd->slave_thread &&
3977 3978
	(!db_ok(db, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(db)))
unknown's avatar
unknown committed
3979
    {
unknown's avatar
unknown committed
3980
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
unknown's avatar
unknown committed
3981 3982 3983
      break;
    }
#endif
3984
    if (check_access(thd, ALTER_ACL, db, 0, 1, 0, is_schema_db(db)))
3985 3986 3987
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
3988 3989
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3990 3991
      goto error;
    }
3992
    res= mysql_alter_db(thd, db, &lex->create_info);
3993 3994
    break;
  }
unknown's avatar
unknown committed
3995 3996 3997 3998
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3999
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
4000 4001
      break;
    }
4002
    if (check_access(thd,SELECT_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
unknown's avatar
unknown committed
4003
      break;
unknown's avatar
unknown committed
4004
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
unknown's avatar
unknown committed
4005 4006
    break;
  }
unknown's avatar
unknown committed
4007
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
unknown's avatar
unknown committed
4008
  {
4009
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0))
unknown's avatar
unknown committed
4010
      break;
unknown's avatar
unknown committed
4011
#ifdef HAVE_DLOPEN
4012 4013
    if (sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                        &thd->sp_func_cache, FALSE))
unknown's avatar
unknown committed
4014
    {
4015
      my_error(ER_UDF_EXISTS, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4016 4017
      goto error;
    }
4018
    if (!(res = mysql_create_function(thd, &lex->udf)))
unknown's avatar
unknown committed
4019
      send_ok(thd);
unknown's avatar
unknown committed
4020
#else
unknown's avatar
unknown committed
4021
    my_error(ER_CANT_OPEN_LIBRARY, MYF(0), lex->udf.dl, 0, "feature disabled");
unknown's avatar
unknown committed
4022
    res= TRUE;
unknown's avatar
unknown committed
4023 4024
#endif
    break;
unknown's avatar
unknown committed
4025
  }
unknown's avatar
unknown committed
4026
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4027 4028
  case SQLCOM_CREATE_USER:
  {
4029
    if (check_access(thd, INSERT_ACL, "mysql", 0, 1, 1, 0) &&
4030
        check_global_access(thd,CREATE_USER_ACL))
4031
      break;
4032 4033
    if (end_active_trans(thd))
      goto error;
4034
    /* Conditionally writes to binlog */
4035 4036 4037 4038
    if (!(res= mysql_create_user(thd, lex->users_list)))
      send_ok(thd);
    break;
  }
4039 4040
  case SQLCOM_DROP_USER:
  {
4041
    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 1, 0) &&
4042
        check_global_access(thd,CREATE_USER_ACL))
4043
      break;
4044 4045
    if (end_active_trans(thd))
      goto error;
4046
    /* Conditionally writes to binlog */
4047
    if (!(res= mysql_drop_user(thd, lex->users_list)))
4048 4049 4050 4051 4052
      send_ok(thd);
    break;
  }
  case SQLCOM_RENAME_USER:
  {
4053
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
4054
        check_global_access(thd,CREATE_USER_ACL))
4055
      break;
4056 4057
    if (end_active_trans(thd))
      goto error;
4058
    /* Conditionally writes to binlog */
4059
    if (!(res= mysql_rename_user(thd, lex->users_list)))
4060 4061 4062 4063 4064
      send_ok(thd);
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
4065
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
4066
        check_global_access(thd,CREATE_USER_ACL))
4067
      break;
4068
    /* Conditionally writes to binlog */
4069 4070 4071 4072
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
      send_ok(thd);
    break;
  }
4073 4074 4075 4076
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
unknown's avatar
unknown committed
4077
		     first_table ?  first_table->db : select_lex->db,
unknown's avatar
VIEW  
unknown committed
4078
		     first_table ? &first_table->grant.privilege : 0,
4079 4080 4081
		     first_table ? 0 : 1, 0,
                     first_table ? (bool) first_table->schema_table :
                     select_lex->db ? is_schema_db(select_lex->db) : 0))
4082 4083
      goto error;

4084
    if (thd->security_ctx->user)              // If not replication
unknown's avatar
unknown committed
4085
    {
4086
      LEX_USER *user, *tmp_user;
4087

unknown's avatar
unknown committed
4088
      List_iterator <LEX_USER> user_list(lex->users_list);
4089
      while ((tmp_user= user_list++))
unknown's avatar
unknown committed
4090
      {
4091 4092
        if (!(user= get_current_user(thd, tmp_user)))
          goto error;
4093 4094 4095 4096 4097 4098 4099 4100
        if (specialflag & SPECIAL_NO_RESOLVE &&
            hostname_requires_resolving(user->host.str))
          push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                              ER_WARN_HOSTNAME_WONT_WORK,
                              ER(ER_WARN_HOSTNAME_WONT_WORK),
                              user->host.str);
        // Are we trying to change a password of another user
        DBUG_ASSERT(user->host.str != 0);
4101
        if (strcmp(thd->security_ctx->user, user->user.str) ||
4102
            my_strcasecmp(system_charset_info,
4103
                          user->host.str, thd->security_ctx->host_or_ip))
4104 4105
        {
          // TODO: use check_change_password()
4106 4107
          if (is_acl_user(user->host.str, user->user.str) &&
              user->password.str &&
4108
              check_access(thd, UPDATE_ACL,"mysql",0,1,1,0))
4109 4110 4111 4112 4113 4114
          {
            my_message(ER_PASSWORD_NOT_ALLOWED,
                       ER(ER_PASSWORD_NOT_ALLOWED), MYF(0));
            goto error;
          }
        }
unknown's avatar
SCRUM  
unknown committed
4115 4116
      }
    }
unknown's avatar
VIEW  
unknown committed
4117
    if (first_table)
4118
    {
4119 4120
      if (lex->type == TYPE_ENUM_PROCEDURE ||
          lex->type == TYPE_ENUM_FUNCTION)
4121 4122 4123 4124 4125
      {
        uint grants= lex->all_privileges 
		   ? (PROC_ACLS & ~GRANT_ACL) | (lex->grant & GRANT_ACL)
		   : lex->grant;
        if (grant_option && 
4126 4127
	    check_grant_routine(thd, grants | GRANT_ACL, all_tables,
                                lex->type == TYPE_ENUM_PROCEDURE, 0))
4128
	  goto error;
4129
        /* Conditionally writes to binlog */
4130 4131 4132 4133
        res= mysql_routine_grant(thd, all_tables,
                                 lex->type == TYPE_ENUM_PROCEDURE, 
                                 lex->users_list, grants,
                                 lex->sql_command == SQLCOM_REVOKE, 0);
4134 4135 4136 4137 4138 4139 4140 4141
      }
      else
      {
	if (grant_option && check_grant(thd,
					(lex->grant | lex->grant_tot_col |
					 GRANT_ACL),
					all_tables, 0, UINT_MAX, 0))
	  goto error;
4142
        /* Conditionally writes to binlog */
4143 4144 4145 4146
        res= mysql_table_grant(thd, all_tables, lex->users_list,
			       lex->columns, lex->grant,
			       lex->sql_command == SQLCOM_REVOKE);
      }
4147 4148 4149
    }
    else
    {
4150
      if (lex->columns.elements || lex->type)
4151
      {
unknown's avatar
unknown committed
4152 4153
	my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE),
                   MYF(0));
unknown's avatar
unknown committed
4154
        goto error;
4155 4156
      }
      else
4157
	/* Conditionally writes to binlog */
4158 4159 4160 4161
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
4162
	if (lex->sql_command == SQLCOM_GRANT)
4163
	{
unknown's avatar
unknown committed
4164
	  List_iterator <LEX_USER> str_list(lex->users_list);
4165 4166 4167 4168 4169
	  LEX_USER *user, *tmp_user;
	  while ((tmp_user=str_list++))
          {
            if (!(user= get_current_user(thd, tmp_user)))
              goto error;
unknown's avatar
unknown committed
4170
	    reset_mqh(user);
4171
          }
4172
	}
4173 4174 4175 4176
      }
    }
    break;
  }
unknown's avatar
SCRUM  
unknown committed
4177
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
unknown's avatar
unknown committed
4178
  case SQLCOM_RESET:
4179 4180 4181
    /*
      RESET commands are never written to the binary log, so we have to
      initialize this variable because RESET shares the same code as FLUSH
4182 4183 4184 4185
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
unknown's avatar
unknown committed
4186
    bool write_to_binlog;
4187
    if (check_global_access(thd,RELOAD_ACL))
unknown's avatar
unknown committed
4188
      goto error;
4189

4190 4191 4192 4193
    /*
      reload_acl_and_cache() will tell us if we are allowed to write to the
      binlog or not.
    */
unknown's avatar
unknown committed
4194
    if (!reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
4195 4196 4197 4198 4199
    {
      /*
        We WANT to write and we CAN write.
        ! we write after unlocking the table.
      */
4200
      /* Presumably, RESET and binlog writing doesn't require synchronization */
4201 4202 4203 4204
      if (!lex->no_write_to_binlog && write_to_binlog)
      {
        if (mysql_bin_log.is_open())
        {
4205
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
4206 4207 4208 4209
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
4210 4211
    } 
    
unknown's avatar
unknown committed
4212
    break;
4213
  }
unknown's avatar
unknown committed
4214
  case SQLCOM_KILL:
4215 4216 4217
  {
    Item *it= (Item *)lex->value_list.head();

4218
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) || it->check_cols(1))
4219 4220 4221 4222 4223 4224
    {
      my_message(ER_SET_CONSTANTS_ONLY, ER(ER_SET_CONSTANTS_ONLY),
		 MYF(0));
      goto error;
    }
    kill_one_thread(thd, (ulong)it->val_int(), lex->type & ONLY_KILL_QUERY);
unknown's avatar
unknown committed
4225
    break;
4226
  }
unknown's avatar
unknown committed
4227
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
4228
  case SQLCOM_SHOW_GRANTS:
4229 4230 4231 4232
  {
    LEX_USER *grant_user= get_current_user(thd, lex->grant_user);
    if (!grant_user)
      goto error;
4233
    if ((thd->security_ctx->priv_user &&
4234
	 !strcmp(thd->security_ctx->priv_user, grant_user->user.str)) ||
4235
	!check_access(thd, SELECT_ACL, "mysql",0,1,0,0))
unknown's avatar
unknown committed
4236
    {
4237
      res = mysql_show_grants(thd, grant_user);
unknown's avatar
unknown committed
4238 4239
    }
    break;
4240
  }
unknown's avatar
unknown committed
4241
#endif
4242
  case SQLCOM_HA_OPEN:
unknown's avatar
VIEW  
unknown committed
4243 4244 4245
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL, all_tables, 0))
4246
      goto error;
unknown's avatar
unknown committed
4247
    res= mysql_ha_open(thd, first_table, 0);
4248 4249
    break;
  case SQLCOM_HA_CLOSE:
unknown's avatar
VIEW  
unknown committed
4250 4251
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables))
4252
      goto error;
unknown's avatar
VIEW  
unknown committed
4253
    res= mysql_ha_close(thd, first_table);
4254 4255
    break;
  case SQLCOM_HA_READ:
unknown's avatar
VIEW  
unknown committed
4256
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
4257 4258 4259 4260 4261
    /*
      There is no need to check for table permissions here, because
      if a user has no permissions to read a table, he won't be
      able to open it (with SQLCOM_HA_OPEN) in the first place.
    */
unknown's avatar
VIEW  
unknown committed
4262
    if (check_db_used(thd, all_tables))
4263
      goto error;
4264
    unit->set_limit(select_lex);
4265
    res= mysql_ha_read(thd, first_table, lex->ha_read_mode, lex->ident.str,
unknown's avatar
VIEW  
unknown committed
4266
                       lex->insert_list, lex->ha_rkey_mode, select_lex->where,
4267
                       unit->select_limit_cnt, unit->offset_limit_cnt);
4268 4269
    break;

unknown's avatar
unknown committed
4270
  case SQLCOM_BEGIN:
4271 4272 4273 4274 4275 4276
    if (thd->transaction.xid_state.xa_state != XA_NOTR)
    {
      my_error(ER_XAER_RMFAIL, MYF(0),
               xa_state_names[thd->transaction.xid_state.xa_state]);
      break;
    }
unknown's avatar
unknown committed
4277
    if (begin_trans(thd))
unknown's avatar
unknown committed
4278
      goto error;
unknown's avatar
unknown committed
4279
    send_ok(thd);
unknown's avatar
unknown committed
4280 4281
    break;
  case SQLCOM_COMMIT:
4282
    if (end_trans(thd, lex->tx_release ? COMMIT_RELEASE :
unknown's avatar
unknown committed
4283
                              lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
unknown's avatar
unknown committed
4284
      goto error;
4285
    send_ok(thd);
unknown's avatar
unknown committed
4286 4287
    break;
  case SQLCOM_ROLLBACK:
4288
    if (end_trans(thd, lex->tx_release ? ROLLBACK_RELEASE :
unknown's avatar
unknown committed
4289
                              lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
unknown's avatar
unknown committed
4290
      goto error;
4291
    send_ok(thd);
unknown's avatar
unknown committed
4292
    break;
unknown's avatar
unknown committed
4293
  case SQLCOM_RELEASE_SAVEPOINT:
unknown's avatar
unknown committed
4294
  {
4295 4296
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
unknown's avatar
unknown committed
4297 4298 4299
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4300
                       (uchar *)sv->name, sv->length) == 0)
unknown's avatar
unknown committed
4301 4302
        break;
    }
4303
    if (sv)
unknown's avatar
unknown committed
4304
    {
4305
      if (ha_release_savepoint(thd, sv))
unknown's avatar
unknown committed
4306
        res= TRUE; // cannot happen
unknown's avatar
unknown committed
4307 4308
      else
        send_ok(thd);
4309
      thd->transaction.savepoints=sv->prev;
unknown's avatar
unknown committed
4310
    }
4311
    else
unknown's avatar
unknown committed
4312
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
4313
    break;
unknown's avatar
unknown committed
4314
  }
unknown's avatar
unknown committed
4315
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
unknown's avatar
unknown committed
4316
  {
4317 4318
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
4319 4320 4321
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4322
                       (uchar *)sv->name, sv->length) == 0)
4323 4324
        break;
    }
4325
    if (sv)
4326
    {
4327
      if (ha_rollback_to_savepoint(thd, sv))
4328 4329
        res= TRUE; // cannot happen
      else
unknown's avatar
unknown committed
4330 4331 4332 4333 4334 4335 4336 4337
      {
        if ((thd->options & OPTION_STATUS_NO_TRANS_UPDATE) &&
            !thd->slave_thread)
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                       ER_WARNING_NOT_COMPLETE_ROLLBACK,
                       ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
        send_ok(thd);
      }
4338
      thd->transaction.savepoints=sv;
unknown's avatar
unknown committed
4339 4340
    }
    else
4341
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
4342
    break;
4343
  }
4344
  case SQLCOM_SAVEPOINT:
4345 4346
    if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN) ||
          thd->in_sub_stmt) || !opt_using_transactions)
unknown's avatar
unknown committed
4347
      send_ok(thd);
unknown's avatar
unknown committed
4348
    else
4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386
    {
      SAVEPOINT **sv, *newsv;
      for (sv=&thd->transaction.savepoints; *sv; sv=&(*sv)->prev)
      {
        if (my_strnncoll(system_charset_info,
                         (uchar *)lex->ident.str, lex->ident.length,
                         (uchar *)(*sv)->name, (*sv)->length) == 0)
          break;
      }
      if (*sv) /* old savepoint of the same name exists */
      {
        newsv=*sv;
        ha_release_savepoint(thd, *sv); // it cannot fail
        *sv=(*sv)->prev;
      }
      else if ((newsv=(SAVEPOINT *) alloc_root(&thd->transaction.mem_root,
                                               savepoint_alloc_size)) == 0)
      {
        my_error(ER_OUT_OF_RESOURCES, MYF(0));
        break;
      }
      newsv->name=strmake_root(&thd->transaction.mem_root,
                               lex->ident.str, lex->ident.length);
      newsv->length=lex->ident.length;
      /*
        if we'll get an error here, don't add new savepoint to the list.
        we'll lose a little bit of memory in transaction mem_root, but it'll
        be free'd when transaction ends anyway
      */
      if (ha_savepoint(thd, newsv))
        res= TRUE;
      else
      {
        newsv->prev=thd->transaction.savepoints;
        thd->transaction.savepoints=newsv;
        send_ok(thd);
      }
    }
unknown's avatar
unknown committed
4387
    break;
4388 4389
  case SQLCOM_CREATE_PROCEDURE:
  case SQLCOM_CREATE_SPFUNCTION:
unknown's avatar
unknown committed
4390
  {
4391
    uint namelen;
unknown's avatar
unknown committed
4392
    char *name;
4393
    int sp_result= SP_INTERNAL_ERROR;
4394

4395
    DBUG_ASSERT(lex->sphead != 0);
unknown's avatar
unknown committed
4396
    DBUG_ASSERT(lex->sphead->m_db.str); /* Must be initialized in the parser */
4397 4398 4399 4400 4401 4402 4403
    /*
      Verify that the database name is allowed, optionally
      lowercase it.
    */
    if (check_db_name(lex->sphead->m_db.str))
    {
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->sphead->m_db.str);
4404
      goto create_sp_error;
4405 4406 4407
    }

    /*
4408 4409 4410
      Check that a database directory with this name
      exists. Design note: This won't work on virtual databases
      like information_schema.
4411 4412 4413 4414
    */
    if (check_db_dir_existence(lex->sphead->m_db.str))
    {
      my_error(ER_BAD_DB_ERROR, MYF(0), lex->sphead->m_db.str);
4415
      goto create_sp_error;
4416 4417
    }

4418 4419
    if (check_access(thd, CREATE_PROC_ACL, lex->sphead->m_db.str, 0, 0, 0,
                     is_schema_db(lex->sphead->m_db.str)))
4420
      goto create_sp_error;
4421

4422 4423
    if (end_active_trans(thd))
      goto create_sp_error;
4424 4425

    name= lex->sphead->name(&namelen);
4426
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
4427 4428 4429
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
4430

unknown's avatar
unknown committed
4431
      if (udf)
4432
      {
4433 4434
        my_error(ER_UDF_EXISTS, MYF(0), name);
        goto create_sp_error;
4435
      }
unknown's avatar
unknown committed
4436 4437 4438
    }
#endif

4439 4440 4441
    /*
      If the definer is not specified, this means that CREATE-statement missed
      DEFINER-clause. DEFINER-clause can be missed in two cases:
4442

4443 4444 4445 4446 4447 4448 4449 4450
        - The user submitted a statement w/o the clause. This is a normal
          case, we should assign CURRENT_USER as definer.

        - Our slave received an updated from the master, that does not
          replicate definer for stored rountines. We should also assign
          CURRENT_USER as definer here, but also we should mark this routine
          as NON-SUID. This is essential for the sake of backward
          compatibility.
4451

4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465
          The problem is the slave thread is running under "special" user (@),
          that actually does not exist. In the older versions we do not fail
          execution of a stored routine if its definer does not exist and
          continue the execution under the authorization of the invoker
          (BUG#13198). And now if we try to switch to slave-current-user (@),
          we will fail.

          Actually, this leads to the inconsistent state of master and
          slave (different definers, different SUID behaviour), but it seems,
          this is the best we can do.
    */

    if (!lex->definer)
    {
4466
      bool local_res= FALSE;
4467 4468 4469 4470
      Query_arena original_arena;
      Query_arena *ps_arena = thd->activate_stmt_arena_if_needed(&original_arena);

      if (!(lex->definer= create_default_definer(thd)))
4471
        local_res= TRUE;
4472 4473 4474 4475

      if (ps_arena)
        thd->restore_active_arena(ps_arena, &original_arena);

4476
      /* Error has been already reported. */
4477
      if (local_res)
4478
        goto create_sp_error;
4479 4480 4481 4482 4483 4484 4485 4486 4487 4488

      if (thd->slave_thread)
        lex->sphead->m_chistics->suid= SP_IS_NOT_SUID;
    }

    /*
      If the specified definer differs from the current user, we should check
      that the current user has SUPER privilege (in order to create a stored
      routine under another user one must have SUPER privilege).
    */
4489

4490 4491 4492 4493 4494 4495 4496 4497
    else if (strcmp(lex->definer->user.str, thd->security_ctx->priv_user) ||
        my_strcasecmp(system_charset_info,
                      lex->definer->host.str,
                      thd->security_ctx->priv_host))
    {
      if (check_global_access(thd, SUPER_ACL))
      {
        my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), "SUPER");
4498
        goto create_sp_error;
4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516
      }
    }

    /* Check that the specified definer exists. Emit a warning if not. */

#ifndef NO_EMBEDDED_ACCESS_CHECKS
    if (!is_acl_user(lex->definer->host.str,
                     lex->definer->user.str))
    {
      push_warning_printf(thd,
                          MYSQL_ERROR::WARN_LEVEL_NOTE,
                          ER_NO_SUCH_USER,
                          ER(ER_NO_SUCH_USER),
                          lex->definer->user.str,
                          lex->definer->host.str);
    }
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

4517
    res= (sp_result= lex->sphead->create(thd));
4518
    switch (sp_result) {
4519
    case SP_OK:
unknown's avatar
unknown committed
4520
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4521
      /* only add privileges if really neccessary */
4522
      if (sp_automatic_privileges && !opt_noacl &&
4523
          check_routine_access(thd, DEFAULT_CREATE_PROC_ACLS,
4524
                               lex->sphead->m_db.str, name,
4525
                               lex->sql_command == SQLCOM_CREATE_PROCEDURE, 1))
4526
      {
unknown's avatar
unknown committed
4527
        if (sp_grant_privileges(thd, lex->sphead->m_db.str, name,
4528
                                lex->sql_command == SQLCOM_CREATE_PROCEDURE))
4529 4530 4531 4532
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                       ER_PROC_AUTO_GRANT_FAIL,
                       ER(ER_PROC_AUTO_GRANT_FAIL));
        close_thread_tables(thd);
4533
      }
unknown's avatar
unknown committed
4534
#endif
unknown's avatar
unknown committed
4535
    break;
4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554
    case SP_WRITE_ROW_FAILED:
      my_error(ER_SP_ALREADY_EXISTS, MYF(0), SP_TYPE_STRING(lex), name);
    break;
    case SP_BAD_IDENTIFIER:
      my_error(ER_TOO_LONG_IDENT, MYF(0), name);
    break;
    case SP_BODY_TOO_LONG:
      my_error(ER_TOO_LONG_BODY, MYF(0), name);
    break;
    default:
      my_error(ER_SP_STORE_FAILED, MYF(0), SP_TYPE_STRING(lex), name);
    break;
    } /* end switch */

    /*
      Capture all errors within this CASE and
      clean up the environment.
    */
create_sp_error:
4555
    if (sp_result != SP_OK )
4556 4557 4558 4559
      goto error;
    send_ok(thd);
    break; /* break super switch */
  } /* end case group bracket */
4560 4561 4562 4563
  case SQLCOM_CALL:
    {
      sp_head *sp;

4564 4565 4566 4567 4568 4569 4570 4571 4572
      /*
        This will cache all SP and SF and open and lock all tables
        required for execution.
      */
      if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
	  open_and_lock_tables(thd, all_tables))
       goto error;

      /*
4573 4574
        By this moment all needed SPs should be in cache so no need to look 
        into DB. 
4575
      */
4576 4577
      if (!(sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                                &thd->sp_proc_cache, TRUE)))
4578
      {
4579
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PROCEDURE",
unknown's avatar
unknown committed
4580
                 lex->spname->m_qname.str);
4581
	goto error;
4582 4583 4584
      }
      else
      {
unknown's avatar
unknown committed
4585
	ha_rows select_limit;
unknown's avatar
unknown committed
4586 4587
        /* bits that should be cleared in thd->server_status */
	uint bits_to_be_cleared= 0;
4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599
        /*
          Check that the stored procedure doesn't contain Dynamic SQL
          and doesn't return result sets: such stored procedures can't
          be called from a function or trigger.
        */
        if (thd->in_sub_stmt)
        {
          const char *where= (thd->in_sub_stmt & SUB_STMT_TRIGGER ?
                              "trigger" : "function");
          if (sp->is_not_allowed_in_function(where))
            goto error;
        }
4600

4601
	my_bool save_no_send_ok= thd->net.no_send_ok;
4602
	thd->net.no_send_ok= TRUE;
4603
	if (sp->m_flags & sp_head::MULTI_RESULTS)
4604
	{
4605
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
4606
	  {
4607 4608 4609 4610
            /*
              The client does not support multiple result sets being sent
              back
            */
4611
	    my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str);
4612
	    thd->net.no_send_ok= save_no_send_ok;
4613 4614
	    goto error;
	  }
unknown's avatar
unknown committed
4615 4616 4617 4618 4619 4620 4621
          /*
            If SERVER_MORE_RESULTS_EXISTS is not set,
            then remember that it should be cleared
          */
	  bits_to_be_cleared= (~thd->server_status &
                               SERVER_MORE_RESULTS_EXISTS);
	  thd->server_status|= SERVER_MORE_RESULTS_EXISTS;
4622 4623
	}

4624
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4625
	if (check_routine_access(thd, EXECUTE_ACL,
4626
				 sp->m_db.str, sp->m_name.str, TRUE, FALSE))
4627
	{
4628
	  thd->net.no_send_ok= save_no_send_ok;
4629 4630
	  goto error;
	}
4631
#endif
unknown's avatar
unknown committed
4632 4633
	select_limit= thd->variables.select_limit;
	thd->variables.select_limit= HA_POS_ERROR;
4634

4635
        /* 
4636
          We never write CALL statements into binlog:
4637 4638 4639 4640 4641
           - If the mode is non-prelocked, each statement will be logged
             separately.
           - If the mode is prelocked, the invoking statement will care
             about writing into binlog.
          So just execute the statement.
4642
        */
4643
	res= sp->execute_procedure(thd, &lex->value_list);
4644 4645 4646
	/*
          If warnings have been cleared, we have to clear total_warn_count
          too, otherwise the clients get confused.
4647 4648 4649 4650
	 */
	if (thd->warn_list.is_empty())
	  thd->total_warn_count= 0;

unknown's avatar
unknown committed
4651
	thd->variables.select_limit= select_limit;
4652

4653
	thd->net.no_send_ok= save_no_send_ok;
unknown's avatar
unknown committed
4654
        thd->server_status&= ~bits_to_be_cleared;
4655

unknown's avatar
unknown committed
4656
	if (!res)
unknown's avatar
unknown committed
4657 4658
	  send_ok(thd, (ulong) (thd->row_count_func < 0 ? 0 :
                                thd->row_count_func));
4659 4660
	else
	  goto error;		// Substatement should already have sent error
4661
      }
4662
      break;
4663 4664
    }
  case SQLCOM_ALTER_PROCEDURE:
4665
  case SQLCOM_ALTER_FUNCTION:
4666
    {
4667
      int sp_result;
4668 4669 4670 4671
      sp_head *sp;
      st_sp_chistics chistics;

      memcpy(&chistics, &lex->sp_chistics, sizeof(chistics));
unknown's avatar
unknown committed
4672
      if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4673 4674
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
4675
      else
4676 4677
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
unknown's avatar
unknown committed
4678
      mysql_reset_errors(thd, 0);
4679
      if (! sp)
4680 4681
      {
	if (lex->spname->m_db.str)
4682
	  sp_result= SP_KEY_NOT_FOUND;
4683 4684 4685 4686 4687 4688
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
      }
4689 4690
      else
      {
4691 4692 4693
        if (check_routine_access(thd, ALTER_PROC_ACL, sp->m_db.str, 
				 sp->m_name.str,
                                 lex->sql_command == SQLCOM_ALTER_PROCEDURE, 0))
4694
	  goto error;
4695 4696 4697

        if (end_active_trans(thd)) 
          goto error;
4698
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
4699 4700
        if ((sp->m_type == TYPE_ENUM_FUNCTION) &&
            !trust_function_creators &&  mysql_bin_log.is_open() &&
4701 4702 4703 4704 4705 4706
            !sp->m_chistics->detistic &&
            (chistics.daccess == SP_CONTAINS_SQL ||
             chistics.daccess == SP_MODIFIES_SQL_DATA))
        {
          my_message(ER_BINLOG_UNSAFE_ROUTINE,
		     ER(ER_BINLOG_UNSAFE_ROUTINE), MYF(0));
4707
          sp_result= SP_INTERNAL_ERROR;
4708 4709 4710
        }
        else
        {
4711 4712 4713 4714 4715 4716
          /*
            Note that if you implement the capability of ALTER FUNCTION to
            alter the body of the function, this command should be made to
            follow the restrictions that log-bin-trust-function-creators=0
            already puts on CREATE FUNCTION.
          */
4717
          /* Conditionally writes to binlog */
4718
          if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4719 4720
            sp_result= sp_update_procedure(thd, lex->spname,
                                           &lex->sp_chistics);
4721
          else
4722
            sp_result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
4723
        }
4724
      }
4725
      switch (sp_result)
4726
      {
unknown's avatar
unknown committed
4727
      case SP_OK:
4728
	send_ok(thd);
unknown's avatar
unknown committed
4729 4730
	break;
      case SP_KEY_NOT_FOUND:
4731 4732
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4733 4734
	goto error;
      default:
4735 4736
	my_error(ER_SP_CANT_ALTER, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4737
	goto error;
4738
      }
4739
      break;
4740 4741
    }
  case SQLCOM_DROP_PROCEDURE:
4742
  case SQLCOM_DROP_FUNCTION:
4743
    {
4744
      int sp_result;
4745 4746
      int type= (lex->sql_command == SQLCOM_DROP_PROCEDURE ?
                 TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION);
4747

4748
      sp_result= sp_routine_exists_in_table(thd, type, lex->spname);
unknown's avatar
unknown committed
4749
      mysql_reset_errors(thd, 0);
4750
      if (sp_result == SP_OK)
4751
      {
4752 4753 4754
        char *db= lex->spname->m_db.str;
	char *name= lex->spname->m_name.str;

4755 4756
	if (check_routine_access(thd, ALTER_PROC_ACL, db, name,
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE, 0))
unknown's avatar
merge  
unknown committed
4757
          goto error;
4758 4759 4760

        if (end_active_trans(thd)) 
          goto error;
unknown's avatar
unknown committed
4761
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4762
	if (sp_automatic_privileges && !opt_noacl &&
4763 4764
	    sp_revoke_privileges(thd, db, name, 
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE))
4765 4766 4767 4768 4769
	{
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
		       ER_PROC_AUTO_REVOKE_FAIL,
		       ER(ER_PROC_AUTO_REVOKE_FAIL));
	}
unknown's avatar
unknown committed
4770
#endif
4771
          /* Conditionally writes to binlog */
4772 4773
	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
	  sp_result= sp_drop_procedure(thd, lex->spname);
4774
	else
4775
	  sp_result= sp_drop_function(thd, lex->spname);
4776 4777 4778
      }
      else
      {
4779
#ifdef HAVE_DLOPEN
4780 4781 4782 4783 4784 4785
	if (lex->sql_command == SQLCOM_DROP_FUNCTION)
	{
          udf_func *udf = find_udf(lex->spname->m_name.str,
                                   lex->spname->m_name.length);
          if (udf)
          {
4786
	    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 0, 0))
4787
	      goto error;
4788 4789

	    /* Does NOT write to binlog */
4790
	    if (!(res = mysql_drop_function(thd, &lex->spname->m_name)))
4791
	    {
4792 4793
	      send_ok(thd);
	      break;
4794 4795
	    }
	  }
4796
	}
4797
#endif
4798
	if (lex->spname->m_db.str)
4799
	  sp_result= SP_KEY_NOT_FOUND;
4800 4801 4802 4803 4804
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
4805
      }
4806 4807
      res= sp_result;
      switch (sp_result) {
4808
      case SP_OK:
4809
	send_ok(thd);
4810 4811
	break;
      case SP_KEY_NOT_FOUND:
4812 4813
	if (lex->drop_if_exists)
	{
4814
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
4815
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
4816
			      SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4817
	  res= FALSE;
4818 4819 4820
	  send_ok(thd);
	  break;
	}
4821 4822
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4823 4824
	goto error;
      default:
4825 4826
	my_error(ER_SP_DROP_FAILED, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4827
	goto error;
4828
      }
4829
      break;
4830
    }
unknown's avatar
unknown committed
4831 4832
  case SQLCOM_SHOW_CREATE_PROC:
    {
4833
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4834
      {
4835
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4836 4837
	goto error;
      }
unknown's avatar
unknown committed
4838
      if (sp_show_create_procedure(thd, lex->spname) != SP_OK)
4839
      {			/* We don't distinguish between errors for now */
4840 4841
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4842 4843 4844 4845 4846 4847
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
4848
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4849
      {
4850
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4851 4852
	goto error;
      }
unknown's avatar
unknown committed
4853
      if (sp_show_create_function(thd, lex->spname) != SP_OK)
4854
      {			/* We don't distinguish between errors for now */
4855 4856
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4857 4858 4859 4860 4861 4862
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
4863
      res= sp_show_status_procedure(thd, (lex->wild ?
unknown's avatar
unknown committed
4864 4865 4866 4867 4868
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
4869
      res= sp_show_status_function(thd, (lex->wild ? 
unknown's avatar
unknown committed
4870 4871 4872
					 lex->wild->ptr() : NullS));
      break;
    }
unknown's avatar
unknown committed
4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884
#ifndef DBUG_OFF
  case SQLCOM_SHOW_PROC_CODE:
  case SQLCOM_SHOW_FUNC_CODE:
    {
      sp_head *sp;

      if (lex->spname->m_name.length > NAME_LEN)
      {
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
	goto error;
      }
      if (lex->sql_command == SQLCOM_SHOW_PROC_CODE)
unknown's avatar
unknown committed
4885 4886
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
unknown's avatar
unknown committed
4887
      else
unknown's avatar
unknown committed
4888 4889
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
4890
      if (!sp || sp->show_routine_code(thd))
4891 4892
      {
        /* We don't distinguish between errors for now */
unknown's avatar
unknown committed
4893 4894 4895 4896 4897 4898 4899
        my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
        goto error;
      }
      break;
    }
#endif // ifndef DBUG_OFF
unknown's avatar
VIEW  
unknown committed
4900 4901
  case SQLCOM_CREATE_VIEW:
    {
4902 4903 4904
      if (end_active_trans(thd))
        goto error;

4905
      res= mysql_create_view(thd, first_table, thd->lex->create_view_mode);
unknown's avatar
VIEW  
unknown committed
4906 4907 4908 4909
      break;
    }
  case SQLCOM_DROP_VIEW:
    {
unknown's avatar
unknown committed
4910 4911 4912
      if (check_table_access(thd, DROP_ACL, all_tables, 0) ||
          end_active_trans(thd))
        goto error;
4913 4914
      /* Conditionally writes to binlog. */
      res= mysql_drop_view(thd, first_table, thd->lex->drop_mode);
unknown's avatar
VIEW  
unknown committed
4915 4916
      break;
    }
4917 4918
  case SQLCOM_CREATE_TRIGGER:
  {
4919 4920 4921
    if (end_active_trans(thd))
      goto error;

4922
    /* Conditionally writes to binlog. */
4923 4924
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

4925 4926 4927 4928
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
4929 4930 4931
    if (end_active_trans(thd))
      goto error;

4932
    /* Conditionally writes to binlog. */
4933 4934 4935
    res= mysql_create_or_drop_trigger(thd, all_tables, 0);
    break;
  }
4936
  case SQLCOM_XA_START:
4937 4938
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
        thd->lex->xa_opt == XA_RESUME)
4939
    {
4940
      if (! thd->transaction.xid_state.xid.eq(thd->lex->xid))
4941 4942 4943 4944
      {
        my_error(ER_XAER_NOTA, MYF(0));
        break;
      }
4945
      thd->transaction.xid_state.xa_state=XA_ACTIVE;
4946 4947 4948
      send_ok(thd);
      break;
    }
unknown's avatar
unknown committed
4949
    if (thd->lex->xa_opt != XA_NONE)
4950 4951 4952 4953
    { // JOIN is not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
4954
    if (thd->transaction.xid_state.xa_state != XA_NOTR)
4955
    {
unknown's avatar
unknown committed
4956
      my_error(ER_XAER_RMFAIL, MYF(0),
4957
               xa_state_names[thd->transaction.xid_state.xa_state]);
4958 4959 4960 4961 4962 4963 4964
      break;
    }
    if (thd->active_transaction() || thd->locked_tables)
    {
      my_error(ER_XAER_OUTSIDE, MYF(0));
      break;
    }
4965 4966 4967 4968 4969 4970 4971 4972 4973
    if (xid_cache_search(thd->lex->xid))
    {
      my_error(ER_XAER_DUPID, MYF(0));
      break;
    }
    DBUG_ASSERT(thd->transaction.xid_state.xid.is_null());
    thd->transaction.xid_state.xa_state=XA_ACTIVE;
    thd->transaction.xid_state.xid.set(thd->lex->xid);
    xid_cache_insert(&thd->transaction.xid_state);
4974
    thd->options= ((thd->options & ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985
                   OPTION_BEGIN);
    thd->server_status|= SERVER_STATUS_IN_TRANS;
    send_ok(thd);
    break;
  case SQLCOM_XA_END:
    /* fake it */
    if (thd->lex->xa_opt != XA_NONE)
    { // SUSPEND and FOR MIGRATE are not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
4986
    if (thd->transaction.xid_state.xa_state != XA_ACTIVE)
4987
    {
unknown's avatar
unknown committed
4988
      my_error(ER_XAER_RMFAIL, MYF(0),
4989
               xa_state_names[thd->transaction.xid_state.xa_state]);
4990 4991
      break;
    }
4992
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4993 4994 4995 4996
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
4997
    thd->transaction.xid_state.xa_state=XA_IDLE;
4998 4999 5000
    send_ok(thd);
    break;
  case SQLCOM_XA_PREPARE:
5001
    if (thd->transaction.xid_state.xa_state != XA_IDLE)
5002
    {
unknown's avatar
unknown committed
5003
      my_error(ER_XAER_RMFAIL, MYF(0),
5004
               xa_state_names[thd->transaction.xid_state.xa_state]);
5005 5006
      break;
    }
5007
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
5008 5009 5010 5011 5012 5013 5014
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
    if (ha_prepare(thd))
    {
      my_error(ER_XA_RBROLLBACK, MYF(0));
5015 5016
      xid_cache_delete(&thd->transaction.xid_state);
      thd->transaction.xid_state.xa_state=XA_NOTR;
5017 5018
      break;
    }
5019
    thd->transaction.xid_state.xa_state=XA_PREPARED;
5020 5021 5022
    send_ok(thd);
    break;
  case SQLCOM_XA_COMMIT:
5023
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
5024
    {
5025 5026
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
5027
        my_error(ER_XAER_NOTA, MYF(0));
unknown's avatar
unknown committed
5028
      else
5029 5030 5031
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 1);
        xid_cache_delete(xs);
unknown's avatar
unknown committed
5032
        send_ok(thd);
5033
      }
5034 5035
      break;
    }
5036
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
unknown's avatar
unknown committed
5037
        thd->lex->xa_opt == XA_ONE_PHASE)
5038
    {
unknown's avatar
unknown committed
5039 5040 5041
      int r;
      if ((r= ha_commit(thd)))
        my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0));
5042 5043 5044
      else
        send_ok(thd);
    }
5045
    else if (thd->transaction.xid_state.xa_state == XA_PREPARED &&
unknown's avatar
unknown committed
5046
             thd->lex->xa_opt == XA_NONE)
5047
    {
5048 5049 5050
      if (wait_if_global_read_lock(thd, 0, 0))
      {
        ha_rollback(thd);
5051
        my_error(ER_XAER_RMERR, MYF(0));
5052
      }
5053
      else
5054 5055 5056 5057 5058 5059 5060
      {
        if (ha_commit_one_phase(thd, 1))
          my_error(ER_XAER_RMERR, MYF(0));
        else
          send_ok(thd);
        start_waiting_global_read_lock(thd);
      }
5061 5062 5063
    }
    else
    {
unknown's avatar
unknown committed
5064
      my_error(ER_XAER_RMFAIL, MYF(0),
5065
               xa_state_names[thd->transaction.xid_state.xa_state]);
5066 5067
      break;
    }
5068
    thd->options&= ~(OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
5069
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
5070 5071
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
5072 5073
    break;
  case SQLCOM_XA_ROLLBACK:
5074
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
5075
    {
5076 5077
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
5078
        my_error(ER_XAER_NOTA, MYF(0));
unknown's avatar
unknown committed
5079
      else
5080 5081 5082
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 0);
        xid_cache_delete(xs);
unknown's avatar
unknown committed
5083
        send_ok(thd);
5084
      }
5085 5086
      break;
    }
5087 5088
    if (thd->transaction.xid_state.xa_state != XA_IDLE &&
        thd->transaction.xid_state.xa_state != XA_PREPARED)
5089
    {
unknown's avatar
unknown committed
5090
      my_error(ER_XAER_RMFAIL, MYF(0),
5091
               xa_state_names[thd->transaction.xid_state.xa_state]);
5092 5093 5094 5095 5096 5097
      break;
    }
    if (ha_rollback(thd))
      my_error(ER_XAER_RMERR, MYF(0));
    else
      send_ok(thd);
5098
    thd->options&= ~(OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
5099
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
5100 5101
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
5102 5103
    break;
  case SQLCOM_XA_RECOVER:
5104
    res= mysql_xa_recover(thd);
5105 5106
    break;
  default:
5107
#ifndef EMBEDDED_LIBRARY
5108
    DBUG_ASSERT(0);                             /* Impossible */
5109
#endif
5110
    send_ok(thd);
unknown's avatar
unknown committed
5111 5112
    break;
  }
5113
  thd_proc_info(thd, "query end");
5114
  /* Two binlog-related cleanups: */
5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127

  /*
    Reset system variables temporarily modified by SET ONE SHOT.

    Exception: If this is a SET, do nothing. This is to allow
    mysqlbinlog to print many SET commands (in this case we want the
    charset temp setting to live until the real query). This is also
    needed so that SET CHARACTER_SET_CLIENT... does not cancel itself
    immediately.
  */
  if (thd->one_shot_set && lex->sql_command != SQLCOM_SET_OPTION)
    reset_one_shot_variables(thd);

5128
  /*
5129 5130 5131 5132 5133 5134
    The return value for ROW_COUNT() is "implementation dependent" if the
    statement is not DELETE, INSERT or UPDATE, but -1 is what JDBC and ODBC
    wants.

    We do not change the value for a CALL or EXECUTE statement, so the value
    generated by the last called (or executed) statement is preserved.
5135
   */
5136 5137
  if (lex->sql_command != SQLCOM_CALL && lex->sql_command != SQLCOM_EXECUTE &&
      uc_update_queries[lex->sql_command]<2)
5138
    thd->row_count_func= -1;
5139 5140

  goto end;
unknown's avatar
unknown committed
5141 5142

error:
5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154
  res= TRUE;

end:
  if (need_start_waiting)
  {
    /*
      Release the protection against the global read lock and wake
      everyone, who might want to set a global read lock.
    */
    start_waiting_global_read_lock(thd);
  }
  DBUG_RETURN(res || thd->net.report_error);
unknown's avatar
unknown committed
5155 5156 5157
}


unknown's avatar
unknown committed
5158
/*
5159
  Check grants for commands which work only with one table.
unknown's avatar
unknown committed
5160

5161
  SYNOPSIS
5162
    check_single_table_access()
unknown's avatar
unknown committed
5163
    thd			Thread handler
5164
    privilege		requested privilege
unknown's avatar
VIEW  
unknown committed
5165
    all_tables		global table list of query
unknown's avatar
unknown committed
5166 5167 5168

  RETURN
    0 - OK
unknown's avatar
unknown committed
5169
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
5170 5171
*/

5172 5173
bool check_single_table_access(THD *thd, ulong privilege, 
                               TABLE_LIST *all_tables)
unknown's avatar
unknown committed
5174
{
5175 5176 5177 5178 5179 5180
  Security_context * backup_ctx= thd->security_ctx;

  /* we need to switch to the saved context (if any) */
  if (all_tables->security_ctx)
    thd->security_ctx= all_tables->security_ctx;

5181 5182 5183 5184 5185 5186 5187 5188
  const char *db_name;
  if ((all_tables->view || all_tables->field_translation) &&
      !all_tables->schema_table)
    db_name= all_tables->view_db.str;
  else
    db_name= all_tables->db;

  if (check_access(thd, privilege, db_name,
5189 5190
		   &all_tables->grant.privilege, 0, 0,
                   test(all_tables->schema_table)))
5191
    goto deny;
unknown's avatar
unknown committed
5192

unknown's avatar
unknown committed
5193
  /* Show only 1 table for check_grant */
unknown's avatar
VIEW  
unknown committed
5194
  if (grant_option && check_grant(thd, privilege, all_tables, 0, 1, 0))
5195 5196 5197
    goto deny;

  thd->security_ctx= backup_ctx;
5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223
  return 0;

deny:
  thd->security_ctx= backup_ctx;
  return 1;
}

/*
  Check grants for commands which work only with one table and all other
  tables belonging to subselects or implicitly opened tables.

  SYNOPSIS
    check_one_table_access()
    thd			Thread handler
    privilege		requested privilege
    all_tables		global table list of query

  RETURN
    0 - OK
    1 - access denied, error is sent to client
*/

bool check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *all_tables)
{
  if (check_single_table_access (thd,privilege,all_tables))
    return 1;
unknown's avatar
unknown committed
5224

5225
  /* Check rights on tables of subselects and implictly opened tables */
unknown's avatar
unknown committed
5226
  TABLE_LIST *subselects_tables, *view= all_tables->view ? all_tables : 0;
unknown's avatar
VIEW  
unknown committed
5227
  if ((subselects_tables= all_tables->next_global))
unknown's avatar
unknown committed
5228
  {
unknown's avatar
unknown committed
5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240
    /*
      Access rights asked for the first table of a view should be the same
      as for the view
    */
    if (view && subselects_tables->belong_to_view == view)
    {
      if (check_single_table_access (thd, privilege, subselects_tables))
        return 1;
      subselects_tables= subselects_tables->next_global;
    }
    if (subselects_tables &&
        (check_table_access(thd, SELECT_ACL, subselects_tables, 0)))
5241
      return 1;
unknown's avatar
unknown committed
5242 5243
  }
  return 0;
unknown's avatar
unknown committed
5244 5245 5246
}


unknown's avatar
unknown committed
5247
/****************************************************************************
unknown's avatar
unknown committed
5248
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261

  NOTES
    The idea of EXTRA_ACL is that one will be granted access to the table if
    one has the asked privilege on any column combination of the table; For
    example to be able to check a table one needs to have SELECT privilege on
    any column of the table.

  RETURN
    0  ok
    1  If we can't get the privileges and we don't use table/column grants.

    save_priv	In this we store global and db level grants for the table
		Note that we don't store db level grants if the global grants
unknown's avatar
unknown committed
5262 5263
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
5264 5265 5266
****************************************************************************/

bool
unknown's avatar
unknown committed
5267
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
5268
	     bool dont_check_global_grants, bool no_errors, bool schema_db)
unknown's avatar
unknown committed
5269
{
5270
  Security_context *sctx= thd->security_ctx;
unknown's avatar
unknown committed
5271 5272
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
unknown's avatar
unknown committed
5273
  bool  db_is_pattern= test(want_access & GRANT_ACL);
unknown's avatar
unknown committed
5274 5275
#endif
  ulong dummy;
5276 5277
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
5278
                      db ? db : "", want_access, sctx->master_access));
unknown's avatar
unknown committed
5279 5280 5281 5282 5283
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

5284
  thd_proc_info(thd, "checking permissions");
5285
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
5286
  {
5287
    DBUG_PRINT("error",("No database"));
5288
    if (!no_errors)
unknown's avatar
unknown committed
5289 5290
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                 MYF(0));                       /* purecov: tested */
unknown's avatar
unknown committed
5291
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5292 5293
  }

5294 5295 5296 5297 5298
  if (schema_db)
  {
    if (want_access & ~(SELECT_ACL | EXTRA_ACL))
    {
      if (!no_errors)
5299 5300
      {
        const char *db_name= db ? db : thd->db;
5301
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5302 5303
                 sctx->priv_user, sctx->priv_host, db_name);
      }
5304 5305 5306 5307 5308 5309 5310 5311 5312
      DBUG_RETURN(TRUE);
    }
    else
    {
      *save_priv= SELECT_ACL;
      DBUG_RETURN(FALSE);
    }
  }

unknown's avatar
unknown committed
5313 5314 5315
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
5316
  if ((sctx->master_access & want_access) == want_access)
unknown's avatar
unknown committed
5317
  {
5318 5319 5320 5321 5322
    /*
      If we don't have a global SELECT privilege, we have to get the database
      specific access rights to be able to handle queries of type
      UPDATE t1 SET a=1 WHERE b > 0
    */
5323 5324
    db_access= sctx->db_access;
    if (!(sctx->master_access & SELECT_ACL) &&
unknown's avatar
unknown committed
5325
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
5326 5327 5328
      db_access=acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                        db_is_pattern);
    *save_priv=sctx->master_access | db_access;
unknown's avatar
unknown committed
5329
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
5330
  }
5331
  if (((want_access & ~sctx->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
5332
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
5333
  {						// We can never grant this
5334
    DBUG_PRINT("error",("No possible access"));
5335
    if (!no_errors)
5336
      my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
5337 5338
               sctx->priv_user,
               sctx->priv_host,
5339 5340 5341
               (thd->password ?
                ER(ER_YES) :
                ER(ER_NO)));                    /* purecov: tested */
unknown's avatar
unknown committed
5342
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5343 5344 5345
  }

  if (db == any_db)
unknown's avatar
unknown committed
5346
    DBUG_RETURN(FALSE);				// Allow select on anything
unknown's avatar
unknown committed
5347

unknown's avatar
unknown committed
5348
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
5349 5350
    db_access= acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                       db_is_pattern);
unknown's avatar
unknown committed
5351
  else
5352
    db_access= sctx->db_access;
5353
  DBUG_PRINT("info",("db_access: %lu", db_access));
unknown's avatar
unknown committed
5354
  /* Remove SHOW attribute and access rights we already have */
5355
  want_access &= ~(sctx->master_access | EXTRA_ACL);
5356 5357
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
5358
  db_access= ((*save_priv=(db_access | sctx->master_access)) & want_access);
5359 5360

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
5361
  if (db_access == want_access ||
5362
      (grant_option && !dont_check_global_grants &&
5363
       !(want_access & ~(db_access | TABLE_ACLS | PROC_ACLS))))
unknown's avatar
unknown committed
5364
    DBUG_RETURN(FALSE);				/* Ok */
5365 5366

  DBUG_PRINT("error",("Access denied"));
5367
  if (!no_errors)
5368
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5369
             sctx->priv_user, sctx->priv_host,
5370 5371 5372
             (db ? db : (thd->db ?
                         thd->db :
                         "unknown")));          /* purecov: tested */
unknown's avatar
unknown committed
5373
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5374
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
5375 5376 5377
}


5378 5379 5380 5381 5382 5383 5384 5385 5386
/*
  check for global access and give descriptive error message if it fails

  SYNOPSIS
    check_global_access()
    thd			Thread handler
    want_access		Use should have any of these global rights

  WARNING
5387
    One gets access right if one has ANY of the rights in want_access
5388 5389 5390 5391 5392 5393 5394 5395
    This is useful as one in most cases only need one global right,
    but in some case we want to check if the user has SUPER or
    REPL_CLIENT_ACL rights.

  RETURN
    0	ok
    1	Access denied.  In this case an error is sent to the client
*/
unknown's avatar
unknown committed
5396 5397

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
5398
{
unknown's avatar
unknown committed
5399 5400 5401
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
5402
  char command[128];
5403
  if ((thd->security_ctx->master_access & want_access))
unknown's avatar
unknown committed
5404 5405
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
5406
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
unknown's avatar
unknown committed
5407
  return 1;
unknown's avatar
unknown committed
5408
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
5409 5410 5411
}


unknown's avatar
unknown committed
5412
/*
5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432
  Check the privilege for all used tables.

  SYNOPSYS
    check_table_access()
      thd          Thread context
      want_access  Privileges requested
      tables       List of tables to be checked
      no_errors    FALSE/TRUE - report/don't report error to
                   the client (using my_error() call).

  NOTES
    Table privileges are cached in the table list for GRANT checking.
    This functions assumes that table list used and
    thd->lex->query_tables_own_last value correspond to each other
    (the latter should be either 0 or point to next_global member
    of one of elements of this table list).

  RETURN VALUE
    FALSE - OK
    TRUE  - Access denied
unknown's avatar
unknown committed
5433 5434
*/

5435
bool
unknown's avatar
unknown committed
5436
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
5437
		   bool no_errors)
unknown's avatar
unknown committed
5438
{
unknown's avatar
unknown committed
5439 5440
  uint found=0;
  ulong found_access=0;
5441
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5442
  TABLE_LIST *org_tables= tables;
5443
#endif
5444
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
5445
  Security_context *sctx= thd->security_ctx, *backup_ctx= thd->security_ctx;
5446
  /*
unknown's avatar
unknown committed
5447 5448 5449
    The check that first_not_own_table is not reached is for the case when
    the given table list refers to the list for prelocking (contains tables
    of other queries). For simple queries first_not_own_table is 0.
5450
  */
unknown's avatar
unknown committed
5451
  for (; tables != first_not_own_table; tables= tables->next_global)
unknown's avatar
unknown committed
5452
  {
5453 5454 5455 5456 5457
    if (tables->security_ctx)
      sctx= tables->security_ctx;
    else
      sctx= backup_ctx;

5458
    if (tables->schema_table && 
5459
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5460 5461 5462
    {
      if (!no_errors)
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5463
                 sctx->priv_user, sctx->priv_host,
5464 5465 5466
                 information_schema_name.str);
      return TRUE;
    }
5467 5468 5469 5470 5471
    /*
       Register access for view underlying table.
       Remove SHOW_VIEW_ACL, because it will be checked during making view
     */
    tables->grant.orig_want_privilege= (want_access & ~SHOW_VIEW_ACL);
5472
    if (tables->derived || tables->schema_table ||
5473
        (tables->table && (int)tables->table->s->tmp_table) ||
5474 5475
        my_tz_check_n_skip_implicit_tables(&tables,
                                           thd->lex->time_zone_tables_used))
unknown's avatar
unknown committed
5476
      continue;
5477 5478
    thd->security_ctx= sctx;
    if ((sctx->master_access & want_access) ==
5479
        (want_access & ~EXTRA_ACL) &&
unknown's avatar
unknown committed
5480
	thd->db)
unknown's avatar
unknown committed
5481
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
5482
    else if (tables->db && thd->db && strcmp(tables->db, thd->db) == 0)
unknown's avatar
unknown committed
5483 5484 5485 5486 5487
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
5488
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5489
			 0, no_errors, test(tables->schema_table)))
5490
	  goto deny;                            // Access denied
unknown's avatar
unknown committed
5491
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
5492
	found=1;
unknown's avatar
unknown committed
5493 5494
      }
    }
5495
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5496
			  0, no_errors, test(tables->schema_table)))
5497
      goto deny;
unknown's avatar
unknown committed
5498
  }
5499
  thd->security_ctx= backup_ctx;
unknown's avatar
unknown committed
5500
  if (grant_option)
5501
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
unknown's avatar
unknown committed
5502
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
unknown's avatar
unknown committed
5503
  return FALSE;
5504 5505 5506
deny:
  thd->security_ctx= backup_ctx;
  return TRUE;
unknown's avatar
unknown committed
5507 5508
}

5509

5510
bool
5511 5512
check_routine_access(THD *thd, ulong want_access,char *db, char *name,
		     bool is_proc, bool no_errors)
5513 5514 5515 5516 5517
{
  TABLE_LIST tables[1];
  
  bzero((char *)tables, sizeof(TABLE_LIST));
  tables->db= db;
5518
  tables->table_name= tables->alias= name;
5519
  
unknown's avatar
unknown committed
5520 5521 5522 5523 5524 5525 5526
  /*
    The following test is just a shortcut for check_access() (to avoid
    calculating db_access) under the assumption that it's common to
    give persons global right to execute all stored SP (but not
    necessary to create them).
  */
  if ((thd->security_ctx->master_access & want_access) == want_access)
5527 5528
    tables->grant.privilege= want_access;
  else if (check_access(thd,want_access,db,&tables->grant.privilege,
unknown's avatar
unknown committed
5529
			0, no_errors, 0))
5530 5531
    return TRUE;
  
unknown's avatar
unknown committed
5532
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5533
  if (grant_option)
5534
    return check_grant_routine(thd, want_access, tables, is_proc, no_errors);
unknown's avatar
unknown committed
5535
#endif
5536 5537 5538 5539

  return FALSE;
}

5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554

/*
  Check if the routine has any of the routine privileges

  SYNOPSIS
    check_some_routine_access()
    thd		 Thread handler
    db           Database name
    name         Routine name

  RETURN
    0            ok
    1            error
*/

5555 5556
bool check_some_routine_access(THD *thd, const char *db, const char *name,
                               bool is_proc)
5557 5558
{
  ulong save_priv;
5559
  if (thd->security_ctx->master_access & SHOW_PROC_ACLS)
5560
    return FALSE;
5561 5562 5563 5564 5565
  /*
    There are no routines in information_schema db. So we can safely
    pass zero to last paramter of check_access function
  */
  if (!check_access(thd, SHOW_PROC_ACLS, db, &save_priv, 0, 1, 0) ||
5566 5567
      (save_priv & SHOW_PROC_ACLS))
    return FALSE;
5568
  return check_routine_level_acl(thd, db, name, is_proc);
5569 5570 5571
}


5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596
/*
  Check if the given table has any of the asked privileges

  SYNOPSIS
    check_some_access()
    thd		 Thread handler
    want_access	 Bitmap of possible privileges to check for

  RETURN
    0  ok
    1  error
*/


bool check_some_access(THD *thd, ulong want_access, TABLE_LIST *table)
{
  ulong access;
  DBUG_ENTER("check_some_access");

  /* This loop will work as long as we have less than 32 privileges */
  for (access= 1; access < want_access ; access<<= 1)
  {
    if (access & want_access)
    {
      if (!check_access(thd, access, table->db,
5597 5598
                        &table->grant.privilege, 0, 1,
                        test(table->schema_table)) &&
5599 5600 5601 5602 5603 5604 5605 5606 5607
          !grant_option || !check_grant(thd, access, table, 0, 1, 1))
        DBUG_RETURN(0);
    }
  }
  DBUG_PRINT("exit",("no matching access rights"));
  DBUG_RETURN(1);
}


5608 5609
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
5610 5611 5612 5613
{
  int error=0;
  if (table_list)
  {
5614
    /* Check that all tables use the current database */
5615
    TABLE_LIST *tmp;
unknown's avatar
VIEW  
unknown committed
5616
    for (tmp= table_list; tmp; tmp= tmp->next_local)
5617 5618 5619 5620
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
5621
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
unknown's avatar
unknown committed
5622
			     table_list,0);
5623 5624 5625 5626
  }
  return error;
}

unknown's avatar
unknown committed
5627 5628 5629

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
unknown's avatar
unknown committed
5630
  char *current_db= NULL;
unknown's avatar
VIEW  
unknown committed
5631
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
5632
  {
unknown's avatar
unknown committed
5633
    if (tables->db == NULL)
unknown's avatar
unknown committed
5634
    {
unknown's avatar
unknown committed
5635 5636 5637 5638 5639 5640 5641 5642 5643
      /*
        This code never works and should be removed in 5.1.  All tables
        that are added to the list of tables should already have its
        database field initialized properly (see st_lex::add_table_to_list).
      */
      DBUG_ASSERT(0);
      if (thd->copy_db_to(&current_db, 0))
        return TRUE;
      tables->db= current_db;
unknown's avatar
unknown committed
5644 5645 5646 5647
    }
  }
  return FALSE;
}
5648

unknown's avatar
unknown committed
5649 5650 5651 5652 5653 5654 5655 5656 5657 5658
/****************************************************************************
	Check stack size; Send error if there isn't enough stack to continue
****************************************************************************/

#if STACK_DIRECTION < 0
#define used_stack(A,B) (long) (A - B)
#else
#define used_stack(A,B) (long) (B - A)
#endif

unknown's avatar
unknown committed
5659 5660 5661 5662
#ifndef DBUG_OFF
long max_stack_used;
#endif

5663
#ifndef EMBEDDED_LIBRARY
5664 5665 5666 5667 5668 5669 5670 5671
/*
  Note: The 'buf' parameter is necessary, even if it is unused here.
  - fix_fields functions has a "dummy" buffer large enough for the
    corresponding exec. (Thus we only have to check in fix_fields.)
  - Passing to check_stack_overrun() prevents the compiler from removing it.
 */
bool check_stack_overrun(THD *thd, long margin,
			 char *buf __attribute__((unused)))
unknown's avatar
unknown committed
5672 5673
{
  long stack_used;
5674
  DBUG_ASSERT(thd == current_thd);
unknown's avatar
unknown committed
5675
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
unknown's avatar
unknown committed
5676
      (long) (thread_stack - margin))
unknown's avatar
unknown committed
5677
  {
5678 5679 5680
    sprintf(errbuff[0],ER(ER_STACK_OVERRUN_NEED_MORE),
            stack_used,thread_stack,margin);
    my_message(ER_STACK_OVERRUN_NEED_MORE,errbuff[0],MYF(0));
5681
    thd->fatal_error();
unknown's avatar
unknown committed
5682 5683
    return 1;
  }
unknown's avatar
unknown committed
5684 5685 5686
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
unknown's avatar
unknown committed
5687 5688
  return 0;
}
5689
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
5690 5691 5692 5693

#define MY_YACC_INIT 1000			// Start with big alloc
#define MY_YACC_MAX  32000			// Because of 'short'

5694
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
unknown's avatar
unknown committed
5695
{
5696
  LEX	*lex= current_thd->lex;
5697
  ulong old_info=0;
unknown's avatar
unknown committed
5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723
  if ((uint) *yystacksize >= MY_YACC_MAX)
    return 1;
  if (!lex->yacc_yyvs)
    old_info= *yystacksize;
  *yystacksize= set_zone((*yystacksize)*2,MY_YACC_INIT,MY_YACC_MAX);
  if (!(lex->yacc_yyvs= (char*)
	my_realloc((gptr) lex->yacc_yyvs,
		   *yystacksize*sizeof(**yyvs),
		   MYF(MY_ALLOW_ZERO_PTR | MY_FREE_ON_ERROR))) ||
      !(lex->yacc_yyss= (char*)
	my_realloc((gptr) lex->yacc_yyss,
		   *yystacksize*sizeof(**yyss),
		   MYF(MY_ALLOW_ZERO_PTR | MY_FREE_ON_ERROR))))
    return 1;
  if (old_info)
  {						// Copy old info from stack
    memcpy(lex->yacc_yyss, (gptr) *yyss, old_info*sizeof(**yyss));
    memcpy(lex->yacc_yyvs, (gptr) *yyvs, old_info*sizeof(**yyvs));
  }
  *yyss=(short*) lex->yacc_yyss;
  *yyvs=(YYSTYPE*) lex->yacc_yyvs;
  return 0;
}


/****************************************************************************
5724
  Initialize global thd variables needed for query
unknown's avatar
unknown committed
5725 5726
****************************************************************************/

5727
void
unknown's avatar
unknown committed
5728
mysql_init_query(THD *thd, uchar *buf, uint length)
unknown's avatar
unknown committed
5729 5730
{
  DBUG_ENTER("mysql_init_query");
unknown's avatar
unknown committed
5731
  lex_start(thd, buf, length);
5732
  mysql_reset_thd_for_next_command(thd);
5733 5734 5735
#ifdef ENABLED_PROFILING
  thd->profiling.reset();
#endif
5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755
  DBUG_VOID_RETURN;
}


/*
 Reset THD part responsible for command processing state.

 DESCRIPTION
   This needs to be called before execution of every statement
   (prepared or conventional).

 TODO
   Make it a method of THD and align its name with the rest of
   reset/end/start/init methods.
   Call it after we use THD for queries, not before.
*/

void mysql_reset_thd_for_next_command(THD *thd)
{
  DBUG_ENTER("mysql_reset_thd_for_next_command");
5756
  thd->free_list= 0;
5757
  thd->select_number= 1;
5758
  thd->query_start_used= thd->insert_id_used=0;
5759
  thd->last_insert_id_used_bin_log= FALSE;
5760
  thd->is_fatal_error= thd->time_zone_used= 0;
unknown's avatar
unknown committed
5761
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
unknown's avatar
unknown committed
5762 5763
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
5764
  DBUG_ASSERT(thd->security_ctx== &thd->main_security_ctx);
unknown's avatar
unknown committed
5765
  thd->tmp_table_used= 0;
5766 5767
  if (!thd->in_sub_stmt)
  {
5768
    if (opt_bin_log)
5769
    {
5770
      reset_dynamic(&thd->user_var_events);
5771 5772
      thd->user_var_events_alloc= thd->mem_root;
    }
5773
    thd->clear_error();
5774 5775 5776
    thd->total_warn_count=0;			// Warnings for this query
    thd->rand_used= 0;
    thd->sent_row_count= thd->examined_row_count= 0;
5777
#ifdef ENABLED_PROFILING
unknown's avatar
unknown committed
5778
    thd->profiling.reset();
5779
#endif
5780
  }
unknown's avatar
unknown committed
5781 5782 5783
  DBUG_VOID_RETURN;
}

5784

5785 5786 5787
void
mysql_init_select(LEX *lex)
{
unknown's avatar
unknown committed
5788
  SELECT_LEX *select_lex= lex->current_select;
unknown's avatar
unknown committed
5789
  select_lex->init_select();
5790
  lex->wild= 0;
5791 5792
  if (select_lex == &lex->select_lex)
  {
5793
    DBUG_ASSERT(lex->result == 0);
5794 5795
    lex->exchange= 0;
  }
5796 5797
}

5798

unknown's avatar
unknown committed
5799
bool
unknown's avatar
unknown committed
5800
mysql_new_select(LEX *lex, bool move_down)
5801
{
unknown's avatar
unknown committed
5802
  SELECT_LEX *select_lex;
5803
  THD *thd= lex->thd;
unknown's avatar
unknown committed
5804 5805
  DBUG_ENTER("mysql_new_select");

5806
  if (!(select_lex= new (thd->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
5807
    DBUG_RETURN(1);
5808
  select_lex->select_number= ++thd->select_number;
unknown's avatar
unknown committed
5809
  select_lex->parent_lex= lex; /* Used in init_query. */
unknown's avatar
unknown committed
5810 5811
  select_lex->init_query();
  select_lex->init_select();
unknown's avatar
unknown committed
5812 5813
  lex->nest_level++;
  select_lex->nest_level= lex->nest_level;
5814 5815 5816 5817 5818
  /*
    Don't evaluate this subquery during statement prepare even if
    it's a constant one. The flag is switched off in the end of
    mysql_stmt_prepare.
  */
unknown's avatar
unknown committed
5819
  if (thd->stmt_arena->is_stmt_prepare())
5820
    select_lex->uncacheable|= UNCACHEABLE_PREPARE;
unknown's avatar
unknown committed
5821 5822
  if (move_down)
  {
unknown's avatar
unknown committed
5823
    SELECT_LEX_UNIT *unit;
5824
    lex->subqueries= TRUE;
unknown's avatar
unknown committed
5825
    /* first select_lex of subselect or derived table */
5826
    if (!(unit= new (thd->mem_root) SELECT_LEX_UNIT()))
unknown's avatar
unknown committed
5827
      DBUG_RETURN(1);
unknown's avatar
unknown committed
5828

unknown's avatar
unknown committed
5829 5830
    unit->init_query();
    unit->init_select();
5831
    unit->thd= thd;
unknown's avatar
unknown committed
5832
    unit->include_down(lex->current_select);
unknown's avatar
unknown committed
5833 5834
    unit->link_next= 0;
    unit->link_prev= 0;
5835
    unit->return_to= lex->current_select;
unknown's avatar
unknown committed
5836
    select_lex->include_down(unit);
5837 5838 5839 5840 5841
    /*
      By default we assume that it is usual subselect and we have outer name
      resolution context, if no we will assign it to 0 later
    */
    select_lex->context.outer_context= &select_lex->outer_select()->context;
unknown's avatar
unknown committed
5842 5843
  }
  else
unknown's avatar
unknown committed
5844
  {
unknown's avatar
VIEW  
unknown committed
5845 5846
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
unknown's avatar
unknown committed
5847
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
unknown's avatar
unknown committed
5848
      DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
5849
    }
5850
    select_lex->include_neighbour(lex->current_select);
5851 5852 5853 5854 5855
    SELECT_LEX_UNIT *unit= select_lex->master_unit();                              
    if (!unit->fake_select_lex && unit->add_fake_select_lex(lex->thd))
      DBUG_RETURN(1);
    select_lex->context.outer_context= 
                unit->first_select()->context.outer_context;
unknown's avatar
unknown committed
5856
  }
unknown's avatar
unknown committed
5857

5858
  select_lex->master_unit()->global_parameters= select_lex;
5859
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
5860
  lex->current_select= select_lex;
5861 5862 5863 5864 5865
  /*
    in subquery is SELECT query and we allow resolution of names in SELECT
    list
  */
  select_lex->context.resolve_in_select_list= TRUE;
unknown's avatar
unknown committed
5866
  DBUG_RETURN(0);
5867
}
unknown's avatar
unknown committed
5868

5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883
/*
  Create a select to return the same output as 'SELECT @@var_name'.

  SYNOPSIS
    create_select_for_variable()
    var_name		Variable name

  DESCRIPTION
    Used for SHOW COUNT(*) [ WARNINGS | ERROR]

    This will crash with a core dump if the variable doesn't exists
*/

void create_select_for_variable(const char *var_name)
{
5884
  THD *thd;
5885
  LEX *lex;
5886
  LEX_STRING tmp, null_lex_string;
5887 5888
  Item *var;
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
5889
  DBUG_ENTER("create_select_for_variable");
5890 5891

  thd= current_thd;
unknown's avatar
unknown committed
5892
  lex= thd->lex;
5893 5894 5895 5896
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
5897
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
5898 5899 5900 5901
  /*
    We set the name of Item to @@session.var_name because that then is used
    as the column name in the output.
  */
unknown's avatar
unknown committed
5902 5903 5904 5905 5906 5907
  if ((var= get_system_var(thd, OPT_SESSION, tmp, null_lex_string)))
  {
    end= strxmov(buff, "@@session.", var_name, NullS);
    var->set_name(buff, end-buff, system_charset_info);
    add_item_to_list(thd, var);
  }
5908 5909 5910
  DBUG_VOID_RETURN;
}

5911

unknown's avatar
unknown committed
5912 5913
void mysql_init_multi_delete(LEX *lex)
{
unknown's avatar
unknown committed
5914
  lex->sql_command=  SQLCOM_DELETE_MULTI;
unknown's avatar
unknown committed
5915
  mysql_init_select(lex);
5916 5917
  lex->select_lex.select_limit= 0;
  lex->unit.select_limit_cnt= HA_POS_ERROR;
unknown's avatar
unknown committed
5918
  lex->select_lex.table_list.save_and_clear(&lex->auxiliary_table_list);
5919
  lex->lock_option= using_update_log ? TL_READ_NO_INSERT : TL_READ;
unknown's avatar
VIEW  
unknown committed
5920 5921
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
unknown's avatar
unknown committed
5922
}
unknown's avatar
unknown committed
5923

5924 5925 5926 5927
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
5928

5929
void mysql_parse(THD *thd, char *inBuf, uint length)
unknown's avatar
unknown committed
5930 5931
{
  DBUG_ENTER("mysql_parse");
5932 5933 5934

  DBUG_EXECUTE_IF("parser_debug", turn_parser_debug_on(););

unknown's avatar
unknown committed
5935
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
5936
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
unknown's avatar
unknown committed
5937
  {
unknown's avatar
unknown committed
5938
    LEX *lex= thd->lex;
5939
    
5940 5941
    sp_cache_flush_obsolete(&thd->sp_proc_cache);
    sp_cache_flush_obsolete(&thd->sp_func_cache);
5942
    
5943
    if (!MYSQLparse((void *)thd) && ! thd->is_fatal_error)
unknown's avatar
unknown committed
5944
    {
unknown's avatar
unknown committed
5945
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5946
      if (mqh_used && thd->user_connect &&
5947
	  check_mqh(thd, lex->sql_command))
5948 5949 5950 5951
      {
	thd->net.error = 0;
      }
      else
unknown's avatar
unknown committed
5952
#endif
5953
      {
5954
	if (! thd->net.report_error)
unknown's avatar
unknown committed
5955
	{
5956 5957 5958 5959 5960 5961 5962 5963 5964 5965
          /*
            Binlog logs a string starting from thd->query and having length
            thd->query_length; so we set thd->query_length correctly (to not
            log several statements in one event, when we executed only first).
            We set it to not see the ';' (otherwise it would get into binlog
            and Query_log_event::print() would give ';;' output).
            This also helps display only the current query in SHOW
            PROCESSLIST.
            Note that we don't need LOCK_thread_count to modify query_length.
          */
unknown's avatar
unknown committed
5966 5967
          if (lex->found_semicolon &&
              (thd->query_length= (ulong)(lex->found_semicolon - thd->query)))
5968 5969
            thd->query_length--;
          /* Actually execute the query */
unknown's avatar
unknown committed
5970
	  mysql_execute_command(thd);
unknown's avatar
SCRUM  
unknown committed
5971
	  query_cache_end_of_result(thd);
unknown's avatar
unknown committed
5972
	}
5973
      }
unknown's avatar
unknown committed
5974 5975
    }
    else
5976
    {
5977
      DBUG_ASSERT(thd->net.report_error);
5978
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
5979
			 thd->is_fatal_error));
5980 5981

      query_cache_abort(&thd->net);
5982
    }
5983 5984 5985 5986 5987 5988
    if (thd->lex->sphead)
    {
      delete thd->lex->sphead;
      thd->lex->sphead= 0;
    }
    lex->unit.cleanup();
5989
    thd_proc_info(thd, "freeing items");
5990
    thd->end_statement();
5991
    thd->cleanup_after_query();
5992
    DBUG_ASSERT(thd->change_list.is_empty());
unknown's avatar
unknown committed
5993
  }
unknown's avatar
unknown committed
5994 5995 5996 5997
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
5998
#ifdef HAVE_REPLICATION
5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009
/*
  Usable by the replication SQL thread only: just parse a query to know if it
  can be ignored because of replicate-*-table rules.

  RETURN VALUES
    0	cannot be ignored
    1	can be ignored
*/

bool mysql_test_parse_for_slave(THD *thd, char *inBuf, uint length)
{
unknown's avatar
unknown committed
6010
  LEX *lex= thd->lex;
6011
  bool error= 0;
unknown's avatar
unknown committed
6012
  DBUG_ENTER("mysql_test_parse_for_slave");
6013

unknown's avatar
unknown committed
6014
  mysql_init_query(thd, (uchar*) inBuf, length);
6015
  if (!MYSQLparse((void*) thd) && ! thd->is_fatal_error &&
6016
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
unknown's avatar
unknown committed
6017
    error= 1;                  /* Ignore question */
6018
  thd->end_statement();
6019
  thd->cleanup_after_query();
unknown's avatar
unknown committed
6020
  DBUG_RETURN(error);
6021
}
unknown's avatar
unknown committed
6022
#endif
unknown's avatar
unknown committed
6023

6024

unknown's avatar
unknown committed
6025

unknown's avatar
unknown committed
6026 6027 6028 6029 6030
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

unknown's avatar
unknown committed
6031
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
unknown's avatar
unknown committed
6032
		       char *length, char *decimals,
6033
		       uint type_modifier,
6034 6035
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
6036 6037
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
unknown's avatar
unknown committed
6038
		       uint uint_geom_type)
unknown's avatar
unknown committed
6039 6040
{
  register create_field *new_field;
unknown's avatar
unknown committed
6041
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
6042 6043 6044 6045
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
6046
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
unknown's avatar
unknown committed
6047 6048 6049 6050 6051
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
unknown's avatar
unknown committed
6052 6053 6054
    lex->alter_info.key_list.push_back(new Key(Key::PRIMARY, NullS,
                                               HA_KEY_ALG_UNDEF, 0,
                                               lex->col_list));
unknown's avatar
unknown committed
6055 6056 6057 6058 6059
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
unknown's avatar
unknown committed
6060 6061 6062
    lex->alter_info.key_list.push_back(new Key(Key::UNIQUE, NullS,
                                               HA_KEY_ALG_UNDEF, 0,
                                               lex->col_list));
unknown's avatar
unknown committed
6063 6064 6065
    lex->col_list.empty();
  }

6066
  if (default_value)
unknown's avatar
unknown committed
6067
  {
6068
    /* 
unknown's avatar
unknown committed
6069 6070
      Default value should be literal => basic constants =>
      no need fix_fields()
6071 6072 6073
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
6074
    */
6075 6076 6077
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
6078
    {
6079
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
6080 6081 6082
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
unknown's avatar
unknown committed
6083
    {
6084
      default_value= 0;
6085 6086 6087
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
6088
	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
6089 6090 6091 6092 6093
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
6094
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
unknown's avatar
unknown committed
6095 6096 6097
      DBUG_RETURN(1);
    }
  }
6098 6099 6100

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
6101
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
6102 6103
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
6104

6105 6106 6107 6108 6109 6110
  if (type == FIELD_TYPE_TIMESTAMP && length)
  {
    /* Display widths are no longer supported for TIMSTAMP as of MySQL 4.1.
       In other words, for declarations such as TIMESTAMP(2), TIMESTAMP(4),
       and so on, the display width is ignored.
    */
unknown's avatar
unknown committed
6111
    char buf[32];
6112
    my_snprintf(buf, sizeof(buf), "TIMESTAMP(%s)", length);
6113 6114 6115
    push_warning_printf(thd,MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_WARN_DEPRECATED_SYNTAX,
                        ER(ER_WARN_DEPRECATED_SYNTAX),
unknown's avatar
unknown committed
6116
                        buf, "TIMESTAMP");
6117 6118
  }

6119 6120 6121 6122
  if (!(new_field= new create_field()) ||
      new_field->init(thd, field_name, type, length, decimals, type_modifier,
                      default_value, on_update_value, comment, change,
                      interval_list, cs, uint_geom_type))
unknown's avatar
unknown committed
6123
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6124

unknown's avatar
unknown committed
6125
  lex->alter_info.create_list.push_back(new_field);
unknown's avatar
unknown committed
6126 6127 6128 6129
  lex->last_field=new_field;
  DBUG_RETURN(0);
}

6130

unknown's avatar
unknown committed
6131 6132 6133 6134
/* Store position for column in ALTER TABLE .. ADD column */

void store_position_for_column(const char *name)
{
6135
  current_thd->lex->last_field->after=my_const_cast(char*) (name);
unknown's avatar
unknown committed
6136 6137 6138
}

bool
unknown's avatar
unknown committed
6139
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
6140 6141 6142 6143
{
  ORDER *order;
  Item	**item_ptr;

unknown's avatar
unknown committed
6144
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
unknown's avatar
unknown committed
6145 6146 6147 6148 6149
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
unknown's avatar
unknown committed
6150
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
6151 6152 6153 6154 6155 6156 6157 6158
  return 0;
}


/* Fix escaping of _, % and \ in database and table names (for ODBC) */

static void remove_escape(char *name)
{
6159 6160
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
6161 6162
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
6163
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
6164 6165 6166 6167 6168
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
6169 6170
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
unknown's avatar
unknown committed
6171 6172 6173 6174 6175 6176 6177 6178
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
6179
      name++;					// Skip '\\'
unknown's avatar
unknown committed
6180 6181 6182 6183 6184 6185 6186 6187 6188 6189
    *to++= *name;
  }
  *to=0;
}

/****************************************************************************
** save order by and tables in own lists
****************************************************************************/


unknown's avatar
unknown committed
6190
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
unknown's avatar
unknown committed
6191 6192 6193
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
unknown's avatar
unknown committed
6194
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
unknown's avatar
unknown committed
6195
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6196 6197
  order->item_ptr= item;
  order->item= &order->item_ptr;
unknown's avatar
unknown committed
6198 6199 6200
  order->asc = asc;
  order->free_me=0;
  order->used=0;
6201
  order->counter_used= 0;
unknown's avatar
unknown committed
6202
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
6203 6204 6205 6206
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
6207 6208 6209 6210 6211 6212 6213 6214 6215 6216
/*
  Add a table to list of used tables

  SYNOPSIS
    add_table_to_list()
    table		Table to add
    alias		alias for table (or null if no alias)
    table_options	A set of the following bits:
			TL_OPTION_UPDATING	Table will be updated
			TL_OPTION_FORCE_INDEX	Force usage of index
6217
			TL_OPTION_ALIAS	        an alias in multi table DELETE
unknown's avatar
unknown committed
6218 6219 6220 6221 6222 6223 6224 6225 6226
    lock_type		How table should be locked
    use_index		List of indexed used in USE INDEX
    ignore_index	List of indexed used in IGNORE INDEX

    RETURN
      0		Error
      #		Pointer to TABLE_LIST element added to the total table list
*/

unknown's avatar
unknown committed
6227 6228
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
6229
					     LEX_STRING *alias,
unknown's avatar
unknown committed
6230 6231
					     ulong table_options,
					     thr_lock_type lock_type,
6232 6233
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
unknown's avatar
unknown committed
6234
                                             LEX_STRING *option)
unknown's avatar
unknown committed
6235 6236
{
  register TABLE_LIST *ptr;
unknown's avatar
unknown committed
6237
  TABLE_LIST *previous_table_ref; /* The table preceding the current one. */
unknown's avatar
unknown committed
6238
  char *alias_str;
6239
  LEX *lex= thd->lex;
unknown's avatar
unknown committed
6240
  DBUG_ENTER("add_table_to_list");
6241
  LINT_INIT(previous_table_ref);
unknown's avatar
unknown committed
6242 6243 6244 6245

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
6246 6247
  if (!test(table_options & TL_OPTION_ALIAS) && 
      check_table_name(table->table.str, table->table.length))
unknown's avatar
unknown committed
6248
  {
6249
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
unknown's avatar
unknown committed
6250 6251 6252 6253
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
6254 6255 6256
  {
    if (table->sel)
    {
unknown's avatar
unknown committed
6257 6258
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
6259 6260
      DBUG_RETURN(0);
    }
6261
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
6262
      DBUG_RETURN(0);
6263
  }
unknown's avatar
unknown committed
6264
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
6265
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
6266
  if (table->db.str)
6267
  {
6268 6269 6270 6271 6272
    if (table->is_derived_table() == FALSE && check_db_name(table->db.str))
    {
      my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
      DBUG_RETURN(0);
    }
6273 6274 6275
    ptr->db= table->db.str;
    ptr->db_length= table->db.length;
  }
unknown's avatar
unknown committed
6276 6277
  else if (thd->copy_db_to(&ptr->db, &ptr->db_length))
    DBUG_RETURN(0);
unknown's avatar
unknown committed
6278

6279
  ptr->alias= alias_str;
6280
  if (lower_case_table_names && table->table.length)
6281
    table->table.length= my_casedn_str(files_charset_info, table->table.str);
6282 6283
  ptr->table_name=table->table.str;
  ptr->table_name_length=table->table.length;
6284
  ptr->lock_type=   lock_type;
unknown's avatar
unknown committed
6285 6286
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
6287
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
6288
  ptr->derived=	    table->sel;
6289 6290
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
                                      information_schema_name.str))
6291
  {
6292
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
6293 6294 6295
    if (!schema_table ||
        (schema_table->hidden && 
         lex->orig_sql_command == SQLCOM_END))  // not a 'show' command
6296
    {
unknown's avatar
unknown committed
6297
      my_error(ER_UNKNOWN_TABLE, MYF(0),
6298
               ptr->table_name, information_schema_name.str);
6299 6300
      DBUG_RETURN(0);
    }
6301
    ptr->schema_table_name= ptr->table_name;
6302 6303
    ptr->schema_table= schema_table;
  }
6304
  ptr->select_lex=  lex->current_select;
unknown's avatar
unknown committed
6305
  ptr->cacheable_table= 1;
6306 6307 6308 6309 6310 6311
  if (use_index_arg)
    ptr->use_index=(List<String> *) thd->memdup((gptr) use_index_arg,
						sizeof(*use_index_arg));
  if (ignore_index_arg)
    ptr->ignore_index=(List<String> *) thd->memdup((gptr) ignore_index_arg,
						   sizeof(*ignore_index_arg));
unknown's avatar
unknown committed
6312
  ptr->option= option ? option->str : 0;
unknown's avatar
unknown committed
6313
  /* check that used name is unique */
6314
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
6315
  {
unknown's avatar
unknown committed
6316 6317 6318 6319
    TABLE_LIST *first_table= (TABLE_LIST*) table_list.first;
    if (lex->sql_command == SQLCOM_CREATE_VIEW)
      first_table= first_table ? first_table->next_local : NULL;
    for (TABLE_LIST *tables= first_table ;
unknown's avatar
unknown committed
6320
	 tables ;
unknown's avatar
VIEW  
unknown committed
6321
	 tables=tables->next_local)
unknown's avatar
unknown committed
6322
    {
6323 6324
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
6325
      {
6326
	my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
unknown's avatar
unknown committed
6327 6328
	DBUG_RETURN(0);				/* purecov: tested */
      }
unknown's avatar
unknown committed
6329 6330
    }
  }
unknown's avatar
unknown committed
6331 6332 6333
  /* Store the table reference preceding the current one. */
  if (table_list.elements > 0)
  {
6334 6335 6336
    /*
      table_list.next points to the last inserted TABLE_LIST->next_local'
      element
6337
      We don't use the offsetof() macro here to avoid warnings from gcc
6338
    */
6339 6340 6341
    previous_table_ref= (TABLE_LIST*) ((char*) table_list.next -
                                       ((char*) &(ptr->next_local) -
                                        (char*) ptr));
6342 6343 6344 6345 6346 6347 6348 6349
    /*
      Set next_name_resolution_table of the previous table reference to point
      to the current table reference. In effect the list
      TABLE_LIST::next_name_resolution_table coincides with
      TABLE_LIST::next_local. Later this may be changed in
      store_top_level_join_columns() for NATURAL/USING joins.
    */
    previous_table_ref->next_name_resolution_table= ptr;
unknown's avatar
unknown committed
6350
  }
6351

unknown's avatar
unknown committed
6352 6353 6354 6355 6356 6357
  /*
    Link the current table reference in a local list (list for current select).
    Notice that as a side effect here we set the next_local field of the
    previous table reference to 'ptr'. Here we also add one element to the
    list 'table_list'.
  */
unknown's avatar
VIEW  
unknown committed
6358
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
unknown's avatar
unknown committed
6359
  ptr->next_name_resolution_table= NULL;
6360
  /* Link table in global list (all used tables) */
6361
  lex->add_to_query_tables(ptr);
unknown's avatar
unknown committed
6362 6363 6364
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
6365

6366 6367 6368 6369
/*
  Initialize a new table list for a nested join

  SYNOPSIS
unknown's avatar
unknown committed
6370
    init_nested_join()
6371
    thd         current thread
6372

6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391
  DESCRIPTION
    The function initializes a structure of the TABLE_LIST type
    for a nested join. It sets up its nested join list as empty.
    The created structure is added to the front of the current
    join list in the st_select_lex object. Then the function
    changes the current nest level for joins to refer to the newly
    created empty list after having saved the info on the old level
    in the initialized structure.

  RETURN VALUE
    0,  if success
    1,  otherwise
*/

bool st_select_lex::init_nested_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
  DBUG_ENTER("init_nested_join");
6392

6393 6394
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6395
    DBUG_RETURN(1);
6396 6397 6398
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418
  join_list->push_front(ptr);
  ptr->embedding= embedding;
  ptr->join_list= join_list;
  embedding= ptr;
  join_list= &nested_join->join_list;
  join_list->empty();
  DBUG_RETURN(0);
}


/*
  End a nested join table list

  SYNOPSIS
    end_nested_join()
    thd         current thread

  DESCRIPTION
    The function returns to the previous join nest level.
    If the current level contains only one member, the function
6419
    moves it one level up, eliminating the nest.
6420 6421 6422 6423 6424 6425 6426 6427 6428

  RETURN VALUE
    Pointer to TABLE_LIST element added to the total table list, if success
    0, otherwise
*/

TABLE_LIST *st_select_lex::end_nested_join(THD *thd)
{
  TABLE_LIST *ptr;
6429
  NESTED_JOIN *nested_join;
6430
  DBUG_ENTER("end_nested_join");
6431

unknown's avatar
unknown committed
6432
  DBUG_ASSERT(embedding);
6433 6434 6435
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
6436
  nested_join= ptr->nested_join;
6437 6438 6439 6440 6441 6442 6443 6444 6445
  if (nested_join->join_list.elements == 1)
  {
    TABLE_LIST *embedded= nested_join->join_list.head();
    join_list->pop();
    embedded->join_list= join_list;
    embedded->embedding= embedding;
    join_list->push_front(embedded);
    ptr= embedded;
  }
6446
  else if (nested_join->join_list.elements == 0)
unknown's avatar
unknown committed
6447 6448
  {
    join_list->pop();
6449
    ptr= 0;                                     // return value
unknown's avatar
unknown committed
6450
  }
6451 6452 6453 6454 6455 6456 6457 6458
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
6459
    nest_last_join()
6460 6461 6462 6463 6464 6465
    thd         current thread

  DESCRIPTION
    The function nest last join operation as if it was enclosed in braces.

  RETURN VALUE
6466 6467 6468
    0  Error
    #  Pointer to TABLE_LIST element created for the new nested join

6469 6470 6471 6472 6473 6474
*/

TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
6475
  List<TABLE_LIST> *embedded_list;
6476
  DBUG_ENTER("nest_last_join");
6477

6478 6479
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6480
    DBUG_RETURN(0);
6481 6482 6483
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6484 6485
  ptr->embedding= embedding;
  ptr->join_list= join_list;
6486
  embedded_list= &nested_join->join_list;
6487
  embedded_list->empty();
6488 6489

  for (uint i=0; i < 2; i++)
6490 6491 6492 6493 6494
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
unknown's avatar
unknown committed
6495 6496 6497 6498 6499 6500 6501
    if (table->natural_join)
    {
      ptr->is_natural_join= TRUE;
      /*
        If this is a JOIN ... USING, move the list of joined fields to the
        table reference that describes the join.
      */
6502 6503
      if (prev_join_using)
        ptr->join_using_fields= prev_join_using;
unknown's avatar
unknown committed
6504
    }
6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544
  }
  join_list->push_front(ptr);
  nested_join->used_tables= nested_join->not_null_tables= (table_map) 0;
  DBUG_RETURN(ptr);
}


/*
  Add a table to the current join list

  SYNOPSIS
    add_joined_table()
    table       the table to add

  DESCRIPTION
    The function puts a table in front of the current join list
    of st_select_lex object.
    Thus, joined tables are put into this list in the reverse order
    (the most outer join operation follows first).

  RETURN VALUE
    None
*/

void st_select_lex::add_joined_table(TABLE_LIST *table)
{
  DBUG_ENTER("add_joined_table");
  join_list->push_front(table);
  table->join_list= join_list;
  table->embedding= embedding;
  DBUG_VOID_RETURN;
}


/*
  Convert a right join into equivalent left join

  SYNOPSIS
    convert_right_join()
    thd         current thread
6545 6546 6547

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570
    effectively converts it into the list t[1],t[0] ...
    Although the outer_join flag for the new nested table contains
    JOIN_TYPE_RIGHT, it will be handled as the inner table of a left join
    operation.

  EXAMPLES
    SELECT * FROM t1 RIGHT JOIN t2 ON on_expr =>
      SELECT * FROM t2 LEFT JOIN t1 ON on_expr

    SELECT * FROM t1,t2 RIGHT JOIN t3 ON on_expr =>
      SELECT * FROM t1,t3 LEFT JOIN t2 ON on_expr

    SELECT * FROM t1,t2 RIGHT JOIN (t3,t4) ON on_expr =>
      SELECT * FROM t1,(t3,t4) LEFT JOIN t2 ON on_expr

    SELECT * FROM t1 LEFT JOIN t2 ON on_expr1 RIGHT JOIN t3  ON on_expr2 =>
      SELECT * FROM t3 LEFT JOIN (t1 LEFT JOIN t2 ON on_expr2) ON on_expr1

  RETURN
    Pointer to the table representing the inner table, if success
    0, otherwise
*/

6571
TABLE_LIST *st_select_lex::convert_right_join()
6572 6573
{
  TABLE_LIST *tab2= join_list->pop();
6574
  TABLE_LIST *tab1= join_list->pop();
6575 6576 6577 6578 6579 6580 6581 6582 6583
  DBUG_ENTER("convert_right_join");

  join_list->push_front(tab2);
  join_list->push_front(tab1);
  tab1->outer_join|= JOIN_TYPE_RIGHT;

  DBUG_RETURN(tab1);
}

unknown's avatar
unknown committed
6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596
/*
  Set lock for all tables in current select level

  SYNOPSIS:
    set_lock_for_tables()
    lock_type			Lock to set for tables

  NOTE:
    If lock is a write lock, then tables->updating is set 1
    This is to get tables_ok to know that the table is updated by the
    query
*/

unknown's avatar
unknown committed
6597
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
unknown's avatar
unknown committed
6598 6599 6600 6601 6602 6603
{
  bool for_update= lock_type >= TL_READ_NO_INSERT;
  DBUG_ENTER("set_lock_for_tables");
  DBUG_PRINT("enter", ("lock_type: %d  for_update: %d", lock_type,
		       for_update));

unknown's avatar
VIEW  
unknown committed
6604 6605 6606
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
unknown's avatar
unknown committed
6607 6608 6609 6610 6611 6612 6613
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
6614

unknown's avatar
unknown committed
6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638
/*
  Create a fake SELECT_LEX for a unit

  SYNOPSIS:
    add_fake_select_lex()
    thd			   thread handle

  DESCRIPTION
    The method create a fake SELECT_LEX object for a unit.
    This object is created for any union construct containing a union
    operation and also for any single select union construct of the form
    (SELECT ... ORDER BY order_list [LIMIT n]) ORDER BY ... 
    or of the form
    (SELECT ... ORDER BY LIMIT n) ORDER BY ...
  
  NOTES
    The object is used to retrieve rows from the temporary table
    where the result on the union is obtained.

  RETURN VALUES
    1     on failure to create the object
    0     on success
*/

6639
bool st_select_lex_unit::add_fake_select_lex(THD *thd_arg)
unknown's avatar
unknown committed
6640 6641 6642 6643
{
  SELECT_LEX *first_sl= first_select();
  DBUG_ENTER("add_fake_select_lex");
  DBUG_ASSERT(!fake_select_lex);
unknown's avatar
unknown committed
6644

6645
  if (!(fake_select_lex= new (thd_arg->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
6646 6647 6648 6649
      DBUG_RETURN(1);
  fake_select_lex->include_standalone(this, 
                                      (SELECT_LEX_NODE**)&fake_select_lex);
  fake_select_lex->select_number= INT_MAX;
6650
  fake_select_lex->parent_lex= thd_arg->lex; /* Used in init_query. */
unknown's avatar
unknown committed
6651 6652
  fake_select_lex->make_empty_select();
  fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
6653 6654
  fake_select_lex->select_limit= 0;

unknown's avatar
unknown committed
6655
  fake_select_lex->context.outer_context=first_sl->context.outer_context;
6656 6657 6658
  /* allow item list resolving in fake select for ORDER BY */
  fake_select_lex->context.resolve_in_select_list= TRUE;
  fake_select_lex->context.select_lex= fake_select_lex;
unknown's avatar
unknown committed
6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669

  if (!first_sl->next_select())
  {
    /* 
      This works only for 
      (SELECT ... ORDER BY list [LIMIT n]) ORDER BY order_list [LIMIT m],
      (SELECT ... LIMIT n) ORDER BY order_list [LIMIT m]
      just before the parser starts processing order_list
    */ 
    global_parameters= fake_select_lex;
    fake_select_lex->no_table_names_allowed= 1;
6670
    thd_arg->lex->current_select= fake_select_lex;
unknown's avatar
unknown committed
6671
  }
6672
  thd_arg->lex->pop_context();
unknown's avatar
unknown committed
6673 6674 6675
  DBUG_RETURN(0);
}

6676

unknown's avatar
unknown committed
6677
/*
6678 6679
  Push a new name resolution context for a JOIN ... ON clause to the
  context stack of a query block.
unknown's avatar
unknown committed
6680 6681

  SYNOPSIS
6682
    push_new_name_resolution_context()
unknown's avatar
unknown committed
6683
    thd       pointer to current thread
unknown's avatar
unknown committed
6684
    left_op   left  operand of the JOIN
unknown's avatar
unknown committed
6685 6686 6687 6688
    right_op  rigth operand of the JOIN

  DESCRIPTION
    Create a new name resolution context for a JOIN ... ON clause,
6689 6690 6691
    set the first and last leaves of the list of table references
    to be used for name resolution, and push the newly created
    context to the stack of contexts of the query.
unknown's avatar
unknown committed
6692 6693

  RETURN
6694 6695
    FALSE  if all is OK
    TRUE   if a memory allocation error occured
unknown's avatar
unknown committed
6696 6697
*/

6698 6699 6700
bool
push_new_name_resolution_context(THD *thd,
                                 TABLE_LIST *left_op, TABLE_LIST *right_op)
unknown's avatar
unknown committed
6701 6702
{
  Name_resolution_context *on_context;
6703
  if (!(on_context= new (thd->mem_root) Name_resolution_context))
6704
    return TRUE;
unknown's avatar
unknown committed
6705 6706 6707 6708 6709
  on_context->init();
  on_context->first_name_resolution_table=
    left_op->first_leaf_for_name_resolution();
  on_context->last_name_resolution_table=
    right_op->last_leaf_for_name_resolution();
6710
  return thd->lex->push_context(on_context);
unknown's avatar
unknown committed
6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730
}


/*
  Add an ON condition to the second operand of a JOIN ... ON.

  SYNOPSIS
    add_join_on
    b     the second operand of a JOIN ... ON
    expr  the condition to be added to the ON clause

  DESCRIPTION
    Add an ON condition to the right operand of a JOIN ... ON clause.

  RETURN
    FALSE  if there was some error
    TRUE   if all is OK
*/

void add_join_on(TABLE_LIST *b, Item *expr)
unknown's avatar
unknown committed
6731
{
6732
  if (expr)
6733
  {
6734
    if (!b->on_expr)
unknown's avatar
unknown committed
6735
      b->on_expr= expr;
6736 6737
    else
    {
unknown's avatar
unknown committed
6738 6739 6740 6741 6742 6743
      /*
        If called from the parser, this happens if you have both a
        right and left join. If called later, it happens if we add more
        than one condition to the ON clause.
      */
      b->on_expr= new Item_cond_and(b->on_expr,expr);
6744 6745
    }
    b->on_expr->top_level_item();
6746
  }
unknown's avatar
unknown committed
6747 6748 6749
}


6750
/*
unknown's avatar
unknown committed
6751 6752
  Mark that there is a NATURAL JOIN or JOIN ... USING between two
  tables.
6753 6754 6755

  SYNOPSIS
    add_join_natural()
unknown's avatar
unknown committed
6756 6757 6758
    a			Left join argument
    b			Right join argument
    using_fields        Field names from USING clause
6759
    lex                 The current st_select_lex
unknown's avatar
unknown committed
6760
  
6761
  IMPLEMENTATION
unknown's avatar
unknown committed
6762 6763 6764 6765 6766 6767 6768 6769 6770 6771
    This function marks that table b should be joined with a either via
    a NATURAL JOIN or via JOIN ... USING. Both join types are special
    cases of each other, so we treat them together. The function
    setup_conds() creates a list of equal condition between all fields
    of the same name for NATURAL JOIN or the fields in 'using_fields'
    for JOIN ... USING. The list of equality conditions is stored
    either in b->on_expr, or in JOIN::conds, depending on whether there
    was an outer join.

  EXAMPLE
6772 6773 6774
    SELECT * FROM t1 NATURAL LEFT JOIN t2
     <=>
    SELECT * FROM t1 LEFT JOIN t2 ON (t1.i=t2.i and t1.j=t2.j ... )
unknown's avatar
unknown committed
6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785

    SELECT * FROM t1 NATURAL JOIN t2 WHERE <some_cond>
     <=>
    SELECT * FROM t1, t2 WHERE (t1.i=t2.i and t1.j=t2.j and <some_cond>)

    SELECT * FROM t1 JOIN t2 USING(j) WHERE <some_cond>
     <=>
    SELECT * FROM t1, t2 WHERE (t1.j=t2.j and <some_cond>)

  RETURN
    None
6786 6787
*/

6788 6789
void add_join_natural(TABLE_LIST *a, TABLE_LIST *b, List<String> *using_fields,
                      SELECT_LEX *lex)
unknown's avatar
unknown committed
6790
{
unknown's avatar
unknown committed
6791
  b->natural_join= a;
6792
  lex->prev_join_using= using_fields;
unknown's avatar
unknown committed
6793 6794
}

unknown's avatar
unknown committed
6795

6796
/*
6797 6798 6799 6800
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
6801
    thd			Thread handler (can be NULL!)
6802 6803 6804 6805 6806
    options             What should be reset/reloaded (tables, privileges,
    slave...)
    tables              Tables to flush (if any)
    write_to_binlog     Depending on 'options', it may be very bad to write the
                        query to the binlog (e.g. FLUSH SLAVE); this is a
unknown's avatar
unknown committed
6807 6808 6809
                        pointer where reload_acl_and_cache() will put 0 if
                        it thinks we really should not write to the binlog.
                        Otherwise it will put 1.
6810 6811 6812

  RETURN
    0	 ok
unknown's avatar
unknown committed
6813
    !=0  error.  thd->killed or thd->net.report_error is set
6814 6815
*/

6816 6817
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
unknown's avatar
unknown committed
6818 6819 6820
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
6821
  bool tmp_write_to_binlog= 1;
6822

6823
  DBUG_ASSERT(!thd || !thd->in_sub_stmt);
6824

unknown's avatar
SCRUM  
unknown committed
6825
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
6826 6827
  if (options & REFRESH_GRANT)
  {
6828 6829 6830 6831 6832 6833
    THD *tmp_thd= 0;
    /*
      If reload_acl_and_cache() is called from SIGHUP handler we have to
      allocate temporary THD for execution of acl_reload()/grant_reload().
    */
    if (!thd && (thd= (tmp_thd= new THD)))
6834 6835
    {
      thd->thread_stack= (char*) &tmp_thd;
6836
      thd->store_globals();
6837
    }
6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849
    if (thd)
    {
      (void)acl_reload(thd);
      (void)grant_reload(thd);
    }
    if (tmp_thd)
    {
      delete tmp_thd;
      /* Remember that we don't have a THD */
      my_pthread_setspecific_ptr(THR_THD,  0);
      thd= 0;
    }
6850
    reset_mqh((LEX_USER *)NULL, TRUE);
unknown's avatar
unknown committed
6851
  }
unknown's avatar
SCRUM  
unknown committed
6852
#endif
unknown's avatar
unknown committed
6853 6854
  if (options & REFRESH_LOG)
  {
6855
    /*
unknown's avatar
unknown committed
6856 6857
      Flush the normal query log, the update log, the binary log,
      the slow query log, and the relay log (if it exists).
6858
    */
unknown's avatar
unknown committed
6859

6860
    /*
unknown's avatar
unknown committed
6861 6862 6863 6864
      Writing this command to the binlog may result in infinite loops
      when doing mysqlbinlog|mysql, and anyway it does not really make
      sense to log it automatically (would cause more trouble to users
      than it would help them)
6865 6866
    */
    tmp_write_to_binlog= 0;
unknown's avatar
unknown committed
6867 6868
    mysql_log.new_file(1);
    mysql_slow_log.new_file(1);
6869 6870 6871 6872
    if( mysql_bin_log.is_open() )
    {
      mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
    }
unknown's avatar
unknown committed
6873
#ifdef HAVE_REPLICATION
6874
    pthread_mutex_lock(&LOCK_active_mi);
6875
    rotate_relay_log(active_mi);
6876
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
6877
#endif
unknown's avatar
unknown committed
6878 6879
    if (ha_flush_logs())
      result=1;
unknown's avatar
unknown committed
6880 6881
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
6882
  }
unknown's avatar
unknown committed
6883
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
6884 6885
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
6886
    query_cache.pack();				// FLUSH QUERY CACHE
6887
    options &= ~REFRESH_QUERY_CACHE;    // Don't flush cache, just free memory
unknown's avatar
unknown committed
6888 6889 6890
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
6891
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
6892
  }
unknown's avatar
unknown committed
6893
#endif /*HAVE_QUERY_CACHE*/
6894 6895 6896 6897 6898
  /*
    Note that if REFRESH_READ_LOCK bit is set then REFRESH_TABLES is set too
    (see sql_yacc.yy)
  */
  if (options & (REFRESH_TABLES | REFRESH_READ_LOCK)) 
unknown's avatar
unknown committed
6899
  {
6900
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
6901
    {
6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912
      /*
        We must not try to aspire a global read lock if we have a write
        locked table. This would lead to a deadlock when trying to
        reopen (and re-lock) the table after the flush.
      */
      if (thd->locked_tables)
      {
        THR_LOCK_DATA **lock_p= thd->locked_tables->locks;
        THR_LOCK_DATA **end_p= lock_p + thd->locked_tables->lock_count;

        for (; lock_p < end_p; lock_p++)
unknown's avatar
unknown committed
6913
        {
6914 6915 6916 6917 6918
          if ((*lock_p)->type == TL_WRITE)
          {
            my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
            return 1;
          }
unknown's avatar
unknown committed
6919
        }
6920
      }
unknown's avatar
unknown committed
6921 6922 6923 6924
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
6925
      tmp_write_to_binlog= 0;
6926
      if (lock_global_read_lock(thd))
unknown's avatar
unknown committed
6927
	return 1;                               // Killed
6928 6929
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
unknown's avatar
unknown committed
6930
      if (make_global_read_lock_block_commit(thd)) // Killed
6931 6932 6933 6934 6935
      {
        /* Don't leave things in a half-locked state */
        unlock_global_read_lock(thd);
        return 1;
      }
unknown's avatar
unknown committed
6936
    }
6937 6938
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
6939
    my_dbopt_cleanup();
unknown's avatar
unknown committed
6940 6941 6942
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
unknown's avatar
unknown committed
6943
  if (thd && (options & REFRESH_STATUS))
unknown's avatar
unknown committed
6944
    refresh_status(thd);
unknown's avatar
unknown committed
6945 6946
  if (options & REFRESH_THREADS)
    flush_thread_cache();
unknown's avatar
unknown committed
6947
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
6948
  if (options & REFRESH_MASTER)
6949
  {
6950
    DBUG_ASSERT(thd);
6951
    tmp_write_to_binlog= 0;
6952
    if (reset_master(thd))
unknown's avatar
unknown committed
6953
    {
6954
      result=1;
unknown's avatar
unknown committed
6955 6956
      thd->fatal_error();                       // Ensure client get error
    }
6957
  }
6958
#endif
unknown's avatar
unknown committed
6959
#ifdef OPENSSL
6960 6961 6962 6963 6964 6965
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
unknown's avatar
unknown committed
6966
#ifdef HAVE_REPLICATION
6967 6968
 if (options & REFRESH_SLAVE)
 {
6969
   tmp_write_to_binlog= 0;
6970
   pthread_mutex_lock(&LOCK_active_mi);
6971
   if (reset_slave(thd, active_mi))
6972
     result=1;
6973
   pthread_mutex_unlock(&LOCK_active_mi);
6974
 }
6975
#endif
6976
 if (options & REFRESH_USER_RESOURCES)
unknown's avatar
unknown committed
6977
   reset_mqh((LEX_USER *) NULL);
unknown's avatar
unknown committed
6978
 *write_to_binlog= tmp_write_to_binlog;
6979
 return result;
unknown's avatar
unknown committed
6980 6981
}

6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993
/*
  kill on thread

  SYNOPSIS
    kill_one_thread()
    thd			Thread class
    id			Thread id

  NOTES
    This is written such that we have a short lock on LOCK_thread_count
*/

unknown's avatar
SCRUM  
unknown committed
6994
void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
unknown's avatar
unknown committed
6995 6996 6997
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
6998 6999
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
7000 7001 7002 7003
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
7004 7005
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
7006 7007 7008
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
7009 7010
  if (tmp)
  {
7011 7012
    if ((thd->security_ctx->master_access & SUPER_ACL) ||
	!strcmp(thd->security_ctx->user, tmp->security_ctx->user))
7013
    {
unknown's avatar
SCRUM  
unknown committed
7014
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
7015 7016 7017 7018 7019 7020 7021
      error=0;
    }
    else
      error=ER_KILL_DENIED_ERROR;
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }

unknown's avatar
unknown committed
7022
  if (!error)
7023
    send_ok(thd);
unknown's avatar
unknown committed
7024
  else
unknown's avatar
unknown committed
7025
    my_error(error, MYF(0), id);
unknown's avatar
unknown committed
7026 7027
}

unknown's avatar
unknown committed
7028

7029 7030
	/* If pointer is not a null pointer, append filename to it */

unknown's avatar
unknown committed
7031 7032
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name)
7033
{
7034
  char buff[FN_REFLEN],*ptr, *end;
7035 7036 7037 7038 7039 7040 7041
  if (!*filename_ptr)
    return 0;					// nothing to do

  /* Check that the filename is not too long and it's a hard path */
  if (strlen(*filename_ptr)+strlen(table_name) >= FN_REFLEN-1 ||
      !test_if_hard_path(*filename_ptr))
  {
7042
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
7043 7044 7045 7046
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
7047
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
7048
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
7049 7050
    return 1;					// End of memory
  *filename_ptr=ptr;
7051
  strxmov(ptr,buff,table_name,NullS);
7052 7053
  return 0;
}
7054

7055

7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069
/*
  Check if the select is a simple select (not an union)

  SYNOPSIS
    check_simple_select()

  RETURN VALUES
    0	ok
    1	error	; In this case the error messege is sent to the client
*/

bool check_simple_select()
{
  THD *thd= current_thd;
7070 7071
  LEX *lex= thd->lex;
  if (lex->current_select != &lex->select_lex)
7072 7073
  {
    char command[80];
7074 7075
    strmake(command, lex->yylval->symbol.str,
	    min(lex->yylval->symbol.length, sizeof(command)-1));
7076
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
7077 7078 7079 7080
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
7081

unknown's avatar
unknown committed
7082

unknown's avatar
unknown committed
7083
Comp_creator *comp_eq_creator(bool invert)
unknown's avatar
unknown committed
7084
{
unknown's avatar
unknown committed
7085
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
unknown's avatar
unknown committed
7086 7087
}

unknown's avatar
unknown committed
7088

unknown's avatar
unknown committed
7089
Comp_creator *comp_ge_creator(bool invert)
unknown's avatar
unknown committed
7090
{
unknown's avatar
unknown committed
7091
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
unknown's avatar
unknown committed
7092 7093
}

unknown's avatar
unknown committed
7094

unknown's avatar
unknown committed
7095
Comp_creator *comp_gt_creator(bool invert)
unknown's avatar
unknown committed
7096
{
unknown's avatar
unknown committed
7097
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
unknown's avatar
unknown committed
7098 7099
}

unknown's avatar
unknown committed
7100

unknown's avatar
unknown committed
7101
Comp_creator *comp_le_creator(bool invert)
unknown's avatar
unknown committed
7102
{
unknown's avatar
unknown committed
7103
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
unknown's avatar
unknown committed
7104 7105
}

unknown's avatar
unknown committed
7106

unknown's avatar
unknown committed
7107
Comp_creator *comp_lt_creator(bool invert)
unknown's avatar
unknown committed
7108
{
unknown's avatar
unknown committed
7109
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
unknown's avatar
unknown committed
7110 7111
}

unknown's avatar
unknown committed
7112

unknown's avatar
unknown committed
7113
Comp_creator *comp_ne_creator(bool invert)
unknown's avatar
unknown committed
7114
{
unknown's avatar
unknown committed
7115
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
unknown's avatar
unknown committed
7116
}
unknown's avatar
unknown committed
7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136


/*
  Construct ALL/ANY/SOME subquery Item

  SYNOPSIS
    all_any_subquery_creator()
    left_expr - pointer to left expression
    cmp - compare function creator
    all - true if we create ALL subquery
    select_lex - pointer on parsed subquery structure

  RETURN VALUE
    constructed Item (or 0 if out of memory)
*/
Item * all_any_subquery_creator(Item *left_expr,
				chooser_compare_func_creator cmp,
				bool all,
				SELECT_LEX *select_lex)
{
unknown's avatar
unknown committed
7137
  if ((cmp == &comp_eq_creator) && !all)       //  = ANY <=> IN
unknown's avatar
unknown committed
7138
    return new Item_in_subselect(left_expr, select_lex);
unknown's avatar
unknown committed
7139 7140

  if ((cmp == &comp_ne_creator) && all)        // <> ALL <=> NOT IN
unknown's avatar
unknown committed
7141 7142 7143
    return new Item_func_not(new Item_in_subselect(left_expr, select_lex));

  Item_allany_subselect *it=
7144
    new Item_allany_subselect(left_expr, cmp, select_lex, all);
unknown's avatar
unknown committed
7145
  if (all)
7146
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
unknown's avatar
unknown committed
7147

7148
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
unknown's avatar
unknown committed
7149
}
7150 7151 7152 7153 7154 7155 7156


/*
  Multi update query pre-check

  SYNOPSIS
    multi_update_precheck()
unknown's avatar
unknown committed
7157
    thd		Thread handler
unknown's avatar
VIEW  
unknown committed
7158
    tables	Global/local table list (have to be the same)
7159

unknown's avatar
unknown committed
7160
  RETURN VALUE
unknown's avatar
unknown committed
7161 7162
    FALSE OK
    TRUE  Error
7163
*/
unknown's avatar
unknown committed
7164

unknown's avatar
unknown committed
7165
bool multi_update_precheck(THD *thd, TABLE_LIST *tables)
7166 7167 7168 7169 7170
{
  const char *msg= 0;
  TABLE_LIST *table;
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
7171
  DBUG_ENTER("multi_update_precheck");
7172 7173 7174

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
7175
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7176
    DBUG_RETURN(TRUE);
7177 7178 7179 7180 7181
  }
  /*
    Ensure that we have UPDATE or SELECT privilege for each table
    The exact privilege is checked in mysql_multi_update()
  */
unknown's avatar
VIEW  
unknown committed
7182
  for (table= tables; table; table= table->next_local)
7183
  {
7184 7185 7186
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
7187 7188
                           &table->grant.privilege, 0, 1,
                           test(table->schema_table)) ||
7189 7190
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
unknown's avatar
unknown committed
7191
             (check_access(thd, SELECT_ACL, table->db,
7192 7193
                           &table->grant.privilege, 0, 0,
                           test(table->schema_table)) ||
unknown's avatar
unknown committed
7194
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
unknown's avatar
unknown committed
7195
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7196

unknown's avatar
VIEW  
unknown committed
7197
    table->table_in_first_from_clause= 1;
7198
  }
unknown's avatar
unknown committed
7199 7200 7201
  /*
    Is there tables of subqueries?
  */
7202
  if (&lex->select_lex != lex->all_selects_list || lex->time_zone_tables_used)
7203
  {
7204
    DBUG_PRINT("info",("Checking sub query list"));
unknown's avatar
VIEW  
unknown committed
7205
    for (table= tables; table; table= table->next_global)
7206
    {
unknown's avatar
unknown committed
7207 7208 7209
      if (!my_tz_check_n_skip_implicit_tables(&table,
                                              lex->time_zone_tables_used) &&
          !table->table_in_first_from_clause)
7210 7211
      {
	if (check_access(thd, SELECT_ACL, table->db,
7212 7213
			 &table->grant.privilege, 0, 0,
                         test(table->schema_table)) ||
unknown's avatar
unknown committed
7214
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
unknown's avatar
unknown committed
7215
	  DBUG_RETURN(TRUE);
7216 7217 7218 7219 7220 7221
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
7222
  else if (select_lex->select_limit)
7223 7224 7225 7226
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
unknown's avatar
unknown committed
7227
    DBUG_RETURN(TRUE);
7228
  }
unknown's avatar
unknown committed
7229
  DBUG_RETURN(FALSE);
7230 7231 7232 7233 7234 7235 7236
}

/*
  Multi delete query pre-check

  SYNOPSIS
    multi_delete_precheck()
unknown's avatar
unknown committed
7237
    thd			Thread handler
unknown's avatar
VIEW  
unknown committed
7238
    tables		Global/local table list
7239

unknown's avatar
unknown committed
7240
  RETURN VALUE
unknown's avatar
unknown committed
7241 7242
    FALSE OK
    TRUE  error
7243
*/
unknown's avatar
unknown committed
7244

7245
bool multi_delete_precheck(THD *thd, TABLE_LIST *tables)
7246 7247 7248
{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  TABLE_LIST *aux_tables=
unknown's avatar
unknown committed
7249
    (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
7250
  TABLE_LIST **save_query_tables_own_last= thd->lex->query_tables_own_last;
unknown's avatar
VIEW  
unknown committed
7251
  DBUG_ENTER("multi_delete_precheck");
unknown's avatar
unknown committed
7252

7253 7254 7255
  /* sql_yacc guarantees that tables and aux_tables are not zero */
  DBUG_ASSERT(aux_tables != 0);
  if (check_db_used(thd, tables) || check_db_used(thd,aux_tables) ||
7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266 7267
      check_table_access(thd, SELECT_ACL, tables, 0))
    DBUG_RETURN(TRUE);

  /*
    Since aux_tables list is not part of LEX::query_tables list we
    have to juggle with LEX::query_tables_own_last value to be able
    call check_table_access() safely.
  */
  thd->lex->query_tables_own_last= 0;
  if (check_table_access(thd, DELETE_ACL, aux_tables, 0))
  {
    thd->lex->query_tables_own_last= save_query_tables_own_last;
unknown's avatar
unknown committed
7268
    DBUG_RETURN(TRUE);
7269 7270 7271
  }
  thd->lex->query_tables_own_last= save_query_tables_own_last;

7272 7273
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
unknown's avatar
unknown committed
7274 7275
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
unknown's avatar
unknown committed
7276
    DBUG_RETURN(TRUE);
7277
  }
7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302
  DBUG_RETURN(FALSE);
}


/*
  Link tables in auxilary table list of multi-delete with corresponding
  elements in main table list, and set proper locks for them.

  SYNOPSIS
    multi_delete_set_locks_and_link_aux_tables()
      lex - pointer to LEX representing multi-delete

  RETURN VALUE
    FALSE - success
    TRUE  - error
*/

bool multi_delete_set_locks_and_link_aux_tables(LEX *lex)
{
  TABLE_LIST *tables= (TABLE_LIST*)lex->select_lex.table_list.first;
  TABLE_LIST *target_tbl;
  DBUG_ENTER("multi_delete_set_locks_and_link_aux_tables");

  lex->table_count= 0;

unknown's avatar
unknown committed
7303
  for (target_tbl= (TABLE_LIST *)lex->auxiliary_table_list.first;
7304
       target_tbl; target_tbl= target_tbl->next_local)
7305
  {
7306
    lex->table_count++;
7307 7308
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
unknown's avatar
VIEW  
unknown committed
7309
    for (walk= tables; walk; walk= walk->next_local)
7310
    {
unknown's avatar
unknown committed
7311 7312 7313
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
7314 7315 7316 7317
	break;
    }
    if (!walk)
    {
7318
      my_error(ER_UNKNOWN_TABLE, MYF(0),
7319
               target_tbl->table_name, "MULTI DELETE");
unknown's avatar
unknown committed
7320
      DBUG_RETURN(TRUE);
7321
    }
unknown's avatar
unknown committed
7322 7323 7324 7325 7326
    if (!walk->derived)
    {
      target_tbl->table_name= walk->table_name;
      target_tbl->table_name_length= walk->table_name_length;
    }
unknown's avatar
unknown committed
7327
    walk->updating= target_tbl->updating;
unknown's avatar
unknown committed
7328
    walk->lock_type= target_tbl->lock_type;
unknown's avatar
VIEW  
unknown committed
7329
    target_tbl->correspondent_table= walk;	// Remember corresponding table
7330
  }
unknown's avatar
unknown committed
7331
  DBUG_RETURN(FALSE);
7332 7333 7334
}


unknown's avatar
unknown committed
7335 7336 7337 7338 7339
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
unknown's avatar
unknown committed
7340 7341
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7342 7343

  RETURN VALUE
unknown's avatar
unknown committed
7344 7345
    FALSE OK
    TRUE  Error
unknown's avatar
unknown committed
7346
*/
unknown's avatar
unknown committed
7347

unknown's avatar
unknown committed
7348
bool update_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7349 7350 7351 7352
{
  DBUG_ENTER("update_precheck");
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
  {
unknown's avatar
unknown committed
7353
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7354
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7355
  }
unknown's avatar
unknown committed
7356 7357
  DBUG_RETURN(check_db_used(thd, tables) ||
	       check_one_table_access(thd, UPDATE_ACL, tables));
unknown's avatar
unknown committed
7358 7359 7360 7361 7362 7363 7364 7365
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
unknown's avatar
unknown committed
7366 7367
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7368 7369

  RETURN VALUE
unknown's avatar
unknown committed
7370 7371
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
7372
*/
unknown's avatar
unknown committed
7373

unknown's avatar
unknown committed
7374
bool delete_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7375 7376 7377
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
unknown's avatar
unknown committed
7378
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7379
  /* Set privilege for the WHERE clause */
unknown's avatar
unknown committed
7380
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
unknown's avatar
unknown committed
7381
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
7382 7383 7384 7385 7386 7387 7388 7389
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
unknown's avatar
unknown committed
7390 7391
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7392 7393

  RETURN VALUE
unknown's avatar
unknown committed
7394 7395
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
7396
*/
unknown's avatar
unknown committed
7397

unknown's avatar
merge  
unknown committed
7398
bool insert_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7399 7400 7401 7402
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

unknown's avatar
unknown committed
7403 7404 7405 7406
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
unknown's avatar
unknown committed
7407 7408 7409
  ulong privilege= (INSERT_ACL |
                    (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                    (lex->value_list.elements ? UPDATE_ACL : 0));
unknown's avatar
unknown committed
7410 7411

  if (check_one_table_access(thd, privilege, tables))
unknown's avatar
unknown committed
7412
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7413

unknown's avatar
unknown committed
7414
  if (lex->update_list.elements != lex->value_list.elements)
unknown's avatar
unknown committed
7415
  {
unknown's avatar
unknown committed
7416
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7417
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7418
  }
unknown's avatar
unknown committed
7419 7420
  if (check_db_used(thd, tables))
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7421
  DBUG_RETURN(FALSE);
7422
}
unknown's avatar
unknown committed
7423 7424 7425 7426 7427 7428 7429


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
unknown's avatar
unknown committed
7430 7431 7432
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
unknown's avatar
unknown committed
7433 7434

  RETURN VALUE
unknown's avatar
unknown committed
7435 7436
    FALSE   OK
    TRUE   Error
unknown's avatar
unknown committed
7437
*/
unknown's avatar
unknown committed
7438

unknown's avatar
unknown committed
7439 7440
bool create_table_precheck(THD *thd, TABLE_LIST *tables,
                           TABLE_LIST *create_table)
unknown's avatar
unknown committed
7441 7442
{
  LEX *lex= thd->lex;
7443 7444
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
unknown's avatar
merge  
unknown committed
7445
  bool error= TRUE;                                 // Error message is given
unknown's avatar
unknown committed
7446
  DBUG_ENTER("create_table_precheck");
7447 7448 7449

  want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
              CREATE_TMP_ACL : CREATE_ACL);
unknown's avatar
unknown committed
7450
  if (check_access(thd, want_priv, create_table->db,
7451 7452
		   &create_table->grant.privilege, 0, 0,
                   test(create_table->schema_table)) ||
unknown's avatar
unknown committed
7453 7454 7455
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
7456 7457
    goto err;
  if (grant_option && want_priv != CREATE_TMP_ACL &&
7458
      check_grant(thd, want_priv, create_table, 0, 1, 0))
7459 7460 7461 7462 7463 7464
    goto err;

  if (select_lex->item_list.elements)
  {
    /* Check permissions for used tables in CREATE TABLE ... SELECT */

7465 7466
#ifdef NOT_NECESSARY_TO_CHECK_CREATE_TABLE_EXIST_WHEN_PREPARING_STATEMENT
    /* This code throws an ill error for CREATE TABLE t1 SELECT * FROM t1 */
7467
    /*
unknown's avatar
unknown committed
7468 7469 7470
      Only do the check for PS, becasue we on execute we have to check that
      against the opened tables to ensure we don't use a table that is part
      of the view (which can only be done after the table has been opened).
7471
    */
unknown's avatar
unknown committed
7472
    if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
7473
    {
unknown's avatar
unknown committed
7474 7475 7476 7477
      /*
        For temporary tables we don't have to check if the created table exists
      */
      if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
unknown's avatar
unknown committed
7478
          find_table_in_global_list(tables, create_table->db,
7479
                                    create_table->table_name))
unknown's avatar
unknown committed
7480
      {
7481
	error= FALSE;
unknown's avatar
unknown committed
7482 7483 7484
        goto err;
      }
    }
7485
#endif
7486 7487 7488
    if (tables && check_table_access(thd, SELECT_ACL, tables,0))
      goto err;
  }
unknown's avatar
merge  
unknown committed
7489
  error= FALSE;
7490 7491 7492

err:
  DBUG_RETURN(error);
unknown's avatar
unknown committed
7493
}
unknown's avatar
unknown committed
7494 7495 7496 7497 7498 7499 7500


/*
  negate given expression

  SYNOPSIS
    negate_expression()
7501
    thd  thread handler
unknown's avatar
unknown committed
7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529
    expr expression for negation

  RETURN
    negated expression
*/

Item *negate_expression(THD *thd, Item *expr)
{
  Item *negated;
  if (expr->type() == Item::FUNC_ITEM &&
      ((Item_func *) expr)->functype() == Item_func::NOT_FUNC)
  {
    /* it is NOT(NOT( ... )) */
    Item *arg= ((Item_func *) expr)->arguments()[0];
    enum_parsing_place place= thd->lex->current_select->parsing_place;
    if (arg->is_bool_func() || place == IN_WHERE || place == IN_HAVING)
      return arg;
    /*
      if it is not boolean function then we have to emulate value of
      not(not(a)), it will be a != 0
    */
    return new Item_func_ne(arg, new Item_int((char*) "0", 0, 1));
  }

  if ((negated= expr->neg_transformer(thd)) != 0)
    return negated;
  return new Item_func_not(expr);
}
7530

7531 7532
/*
  Set the specified definer to the default value, which is the current user in
7533
  the thread.
7534 7535 7536 7537 7538 7539 7540
 
  SYNOPSIS
    get_default_definer()
    thd       [in] thread handler
    definer   [out] definer
*/
 
7541
void get_default_definer(THD *thd, LEX_USER *definer)
7542 7543 7544 7545 7546 7547 7548 7549 7550 7551
{
  const Security_context *sctx= thd->security_ctx;

  definer->user.str= (char *) sctx->priv_user;
  definer->user.length= strlen(definer->user.str);

  definer->host.str= (char *) sctx->priv_host;
  definer->host.length= strlen(definer->host.str);
}

7552

7553
/*
7554
  Create default definer for the specified THD.
7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572

  SYNOPSIS
    create_default_definer()
    thd         [in] thread handler

  RETURN
    On success, return a valid pointer to the created and initialized
    LEX_USER, which contains definer information.
    On error, return 0.
*/

LEX_USER *create_default_definer(THD *thd)
{
  LEX_USER *definer;

  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
    return 0;

7573
  get_default_definer(thd, definer);
7574 7575 7576 7577 7578

  return definer;
}


7579
/*
7580
  Create definer with the given user and host names.
7581 7582

  SYNOPSIS
7583 7584 7585 7586
    create_definer()
    thd         [in] thread handler
    user_name   [in] user name
    host_name   [in] host name
7587 7588

  RETURN
7589
    On success, return a valid pointer to the created and initialized
7590
    LEX_USER, which contains definer information.
7591
    On error, return 0.
7592 7593
*/

7594
LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name)
7595
{
7596 7597 7598 7599
  LEX_USER *definer;

  /* Create and initialize. */

unknown's avatar
unknown committed
7600
  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
7601 7602 7603 7604 7605 7606
    return 0;

  definer->user= *user_name;
  definer->host= *host_name;

  return definer;
7607
}
7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626


/*
  Retuns information about user or current user.

  SYNOPSIS
    get_current_user()
    thd         [in] thread handler
    user        [in] user

  RETURN
    On success, return a valid pointer to initialized
    LEX_USER, which contains user information.
    On error, return 0.
*/

LEX_USER *get_current_user(THD *thd, LEX_USER *user)
{
  if (!user->user.str)  // current_user
7627 7628
    return create_default_definer(thd);

7629 7630
  return user;
}
7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646


/*
  Check that length of a string does not exceed some limit.

  SYNOPSIS
    check_string_length()
      str         string to be checked
      err_msg     error message to be displayed if the string is too long
      max_length  max length

  RETURN
    FALSE   the passed string is not longer than max_length
    TRUE    the passed string is longer than max_length
*/

unknown's avatar
unknown committed
7647 7648
bool check_string_length(LEX_STRING *str, const char *err_msg,
                         uint max_length)
7649
{
unknown's avatar
unknown committed
7650 7651
  if (str->length <= max_length)
    return FALSE;
7652 7653

  my_error(ER_WRONG_STRING_LENGTH, MYF(0), str->str, err_msg, max_length);
unknown's avatar
unknown committed
7654

7655 7656
  return TRUE;
}