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

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

unknown's avatar
unknown committed
8 9 10 11
   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.
12

unknown's avatar
unknown committed
13 14 15 16
   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 */

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

26
#include "sp_head.h"
27
#include "sp.h"
28
#include "sp_cache.h"
29
#include "event.h"
30

unknown's avatar
unknown committed
31 32 33 34 35 36 37 38 39 40 41
#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
42 43 44
#define SSL_HANDSHAKE_SIZE      2
#define NORMAL_HANDSHAKE_SIZE   6
#define MIN_HANDSHAKE_SIZE      2
unknown's avatar
unknown committed
45
#else
unknown's avatar
unknown committed
46
#define MIN_HANDSHAKE_SIZE      6
unknown's avatar
unknown committed
47
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
48

49 50 51 52 53 54
/* 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 || \
55
   (LP)->sql_command == SQLCOM_SHOW_CREATE_FUNC || \
56 57 58
   (LP)->sql_command == SQLCOM_DROP_FUNCTION ? \
   "FUNCTION" : "PROCEDURE")

59 60 61
#ifdef SOLARIS
extern "C" int gethostname(char *name, int namelen);
#endif
unknown's avatar
unknown committed
62

63
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
unknown's avatar
unknown committed
64
#ifndef NO_EMBEDDED_ACCESS_CHECKS
65
static int check_for_max_user_connections(THD *thd, USER_CONN *uc);
unknown's avatar
unknown committed
66
#endif
67
static void decrease_user_connections(USER_CONN *uc);
unknown's avatar
unknown committed
68
static bool check_db_used(THD *thd,TABLE_LIST *tables);
unknown's avatar
unknown committed
69
static bool check_multi_update_lock(THD *thd);
unknown's avatar
unknown committed
70
static void remove_escape(char *name);
unknown's avatar
unknown committed
71
static void refresh_status(THD *thd);
unknown's avatar
unknown committed
72

73
const char *any_db="*any*";	// Special symbol for check_access
unknown's avatar
unknown committed
74

75
LEX_STRING command_name[]={
unknown's avatar
unknown committed
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
  (char *)STRING_WITH_LEN("Sleep"),
  (char *)STRING_WITH_LEN("Quit"),
  (char *)STRING_WITH_LEN("Init DB"),
  (char *)STRING_WITH_LEN("Query"),
  (char *)STRING_WITH_LEN("Field List"),
  (char *)STRING_WITH_LEN("Create DB"),
  (char *)STRING_WITH_LEN("Drop DB"),
  (char *)STRING_WITH_LEN("Refresh"),
  (char *)STRING_WITH_LEN("Shutdown"),
  (char *)STRING_WITH_LEN("Statistics"),
  (char *)STRING_WITH_LEN("Processlist"),
  (char *)STRING_WITH_LEN("Connect"),
  (char *)STRING_WITH_LEN("Kill"),
  (char *)STRING_WITH_LEN("Debug"),
  (char *)STRING_WITH_LEN("Ping"),
  (char *)STRING_WITH_LEN("Time"),
  (char *)STRING_WITH_LEN("Delayed insert"),
  (char *)STRING_WITH_LEN("Change user"),
  (char *)STRING_WITH_LEN("Binlog Dump"),
  (char *)STRING_WITH_LEN("Table Dump"),
  (char *)STRING_WITH_LEN("Connect Out"),
  (char *)STRING_WITH_LEN("Register Slave"),
  (char *)STRING_WITH_LEN("Prepare"),
  (char *)STRING_WITH_LEN("Execute"),
  (char *)STRING_WITH_LEN("Long Data"),
  (char *)STRING_WITH_LEN("Close stmt"),
  (char *)STRING_WITH_LEN("Reset stmt"),
  (char *)STRING_WITH_LEN("Set option"),
  (char *)STRING_WITH_LEN("Fetch"),
  (char *)STRING_WITH_LEN("Daemon"),
  (char *)STRING_WITH_LEN("Error")  // Last command number
unknown's avatar
unknown committed
107 108
};

unknown's avatar
unknown committed
109 110 111 112
const char *xa_state_names[]={
  "NON-EXISTING", "ACTIVE", "IDLE", "PREPARED"
};

113
static char empty_c_string[1]= {0};		// Used for not defined 'db'
unknown's avatar
unknown committed
114 115 116 117

#ifdef __WIN__
static void  test_signal(int sig_ptr)
{
unknown's avatar
unknown committed
118
#if !defined( DBUG_OFF)
unknown's avatar
unknown committed
119 120
  MessageBox(NULL,"Test signal","DBUG",MB_OK);
#endif
unknown's avatar
unknown committed
121
#if defined(OS2)
122 123
  fprintf(stderr, "Test signal %d\n", sig_ptr);
  fflush(stderr);
unknown's avatar
unknown committed
124
#endif
unknown's avatar
unknown committed
125 126 127 128
}
static void init_signals(void)
{
  int signals[7] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGBREAK,SIGABRT } ;
129
  for (int i=0 ; i < 7 ; i++)
unknown's avatar
unknown committed
130 131 132 133
    signal( signals[i], test_signal) ;
}
#endif

unknown's avatar
unknown committed
134 135 136 137 138
static void unlock_locked_tables(THD *thd)
{
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
139
    thd->locked_tables=0;			// Will be automatically closed
unknown's avatar
unknown committed
140 141 142 143
    close_thread_tables(thd);			// Free tables
  }
}

144

unknown's avatar
unknown committed
145
static bool end_active_trans(THD *thd)
146
{
unknown's avatar
unknown committed
147
  int error=0;
148
  DBUG_ENTER("end_active_trans");
149
  if (unlikely(thd->in_sub_stmt))
150 151 152 153
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
154 155 156 157 158 159
  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
160
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
unknown's avatar
unknown committed
161
		      OPTION_TABLE_LOCK))
162
  {
163 164 165 166
    DBUG_PRINT("info",("options: 0x%lx", (ulong) thd->options));
    /* Safety if one did "drop table" on locked tables */
    if (!thd->locked_tables)
      thd->options&= ~OPTION_TABLE_LOCK;
167
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
168
    if (ha_commit(thd))
unknown's avatar
unknown committed
169
      error=1;
170
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
171
  }
172
  DBUG_RETURN(error);
173 174
}

unknown's avatar
unknown committed
175
bool begin_trans(THD *thd)
unknown's avatar
unknown committed
176 177
{
  int error=0;
178
  if (unlikely(thd->in_sub_stmt))
179 180 181 182
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    return 1;
  }
unknown's avatar
unknown committed
183 184 185 186 187 188 189 190 191 192
  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
  {
193
    LEX *lex= thd->lex;
unknown's avatar
unknown committed
194 195 196 197
    thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
		   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
198
      error= ha_start_consistent_snapshot(thd);
unknown's avatar
unknown committed
199 200 201
  }
  return error;
}
202

unknown's avatar
unknown committed
203
#ifdef HAVE_REPLICATION
204 205 206
/*
  Returns true if all tables should be ignored
*/
207 208
inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables)
{
209
  return rpl_filter->is_on() && tables && !thd->spcont &&
unknown's avatar
Merge  
unknown committed
210
         !rpl_filter->tables_ok(thd->db, tables);
211
}
unknown's avatar
unknown committed
212
#endif
213 214


215 216 217 218 219 220 221 222 223 224 225 226
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;
}

227 228
static HASH hash_user_connections;

unknown's avatar
unknown committed
229 230
static int get_or_create_user_conn(THD *thd, const char *user,
				   const char *host,
unknown's avatar
unknown committed
231
				   USER_RESOURCES *mqh)
232
{
233
  int return_val= 0;
unknown's avatar
unknown committed
234
  uint temp_len, user_len;
235
  char temp_user[USER_HOST_BUFF_SIZE];
236 237 238 239 240
  struct  user_conn *uc;

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

241
  user_len= strlen(user);
242
  temp_len= (strmov(strmov(temp_user, user)+1, host) - temp_user)+1;
243
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
244 245
  if (!(uc = (struct  user_conn *) hash_search(&hash_user_connections,
					       (byte*) temp_user, temp_len)))
246
  {
unknown's avatar
unknown committed
247 248 249
    /* 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
250 251
			 MYF(MY_WME)))))
    {
252
      net_send_error(thd, 0, NullS);		// Out of memory
253
      return_val= 1;
254
      goto end;
unknown's avatar
unknown committed
255
    }
256 257
    uc->user=(char*) (uc+1);
    memcpy(uc->user,temp_user,temp_len+1);
258
    uc->host= uc->user + user_len +  1;
259
    uc->len= temp_len;
260
    uc->connections= uc->questions= uc->updates= uc->conn_per_hour= 0;
261 262
    uc->user_resources= *mqh;
    uc->intime= thd->thr_create_time;
unknown's avatar
SCRUM  
unknown committed
263
    if (my_hash_insert(&hash_user_connections, (byte*) uc))
264 265
    {
      my_free((char*) uc,0);
266
      net_send_error(thd, 0, NullS);		// Out of memory
267
      return_val= 1;
268 269 270 271
      goto end;
    }
  }
  thd->user_connect=uc;
272
  uc->connections++;
273 274 275
end:
  (void) pthread_mutex_unlock(&LOCK_user_conn);
  return return_val;
unknown's avatar
unknown committed
276

277
}
278 279 280


/*
281 282
  Check if user exist and password supplied is correct. 

283 284
  SYNOPSIS
    check_user()
285
    thd          thread handle, thd->security_ctx->{host,user,ip} are used
286 287 288
    command      originator of the check: now check_user is called
                 during connect and change user procedures; used for 
                 logging.
289
    passwd       scrambled password received from client
290 291 292 293
    passwd_len   length of scrambled password
    db           database name to connect to, may be NULL
    check_count  dont know exactly

294
    Note, that host, user and passwd may point to communication buffer.
295
    Current implementation does not depend on that, but future changes
296 297 298
    should be done with this in mind; 'thd' is INOUT, all other params
    are 'IN'.

299
  RETURN VALUE
300 301
    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
302 303
   -1  access denied or handshake error; error is sent to client;
   >0  error, not sent to client
unknown's avatar
unknown committed
304 305
*/

unknown's avatar
unknown committed
306 307 308
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
309
{
310
  DBUG_ENTER("check_user");
unknown's avatar
unknown committed
311
  
unknown's avatar
unknown committed
312
#ifdef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
313
  thd->main_security_ctx.master_access= GLOBAL_ACLS;       // Full rights
314
  /* Change database if necessary */
315 316
  if (db && db[0])
  {
317 318 319 320
    /*
      thd->db is saved in caller and needs to be freed by caller if this
      function returns 0
    */
321 322
    thd->db= 0;
    thd->db_length= 0;
323
    if (mysql_change_db(thd, db, FALSE))
324
    {
325 326
      /* Send the error to the client */
      net_send_error(thd);
327 328 329 330 331
      if (thd->user_connect)
	decrease_user_connections(thd->user_connect);
      DBUG_RETURN(-1);
    }
  }
332
  send_ok(thd);
333
  DBUG_RETURN(0);
unknown's avatar
unknown committed
334 335
#else

336 337 338 339 340
  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);
  
341
  /*
342 343
    If the server is running in secure auth mode, short scrambles are 
    forbidden.
344
  */
345
  if (opt_secure_auth_local && passwd_len == SCRAMBLE_LENGTH_323)
unknown's avatar
unknown committed
346
  {
347
    net_printf_error(thd, ER_NOT_SUPPORTED_AUTH_MODE);
348
    general_log_print(thd, COM_CONNECT, ER(ER_NOT_SUPPORTED_AUTH_MODE));
349
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
350
  }
unknown's avatar
unknown committed
351 352 353 354
  if (passwd_len != 0 &&
      passwd_len != SCRAMBLE_LENGTH &&
      passwd_len != SCRAMBLE_LENGTH_323)
    DBUG_RETURN(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
355

356
  /*
357
    Clear thd->db as it points to something, that will be freed when 
358
    connection is closed. We don't want to accidentally free a wrong pointer
359 360
    if connect failed. Also in case of 'CHANGE USER' failure, current
    database will be switched to 'no database selected'.
361
  */
362 363
  thd->db= 0;
  thd->db_length= 0;
unknown's avatar
unknown committed
364
  
365
  USER_RESOURCES ur;
366
  int res= acl_getroot(thd, &ur, passwd, passwd_len);
unknown's avatar
unknown committed
367
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
368
  if (res == -1)
unknown's avatar
unknown committed
369
  {
unknown's avatar
unknown committed
370 371 372 373 374 375
    /*
      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.
    */
376
    NET *net= &thd->net;
377
    if (opt_secure_auth_local)
378
    {
379
      net_printf_error(thd, ER_SERVER_IS_IN_SECURE_AUTH_MODE,
380 381
                       thd->main_security_ctx.user,
                       thd->main_security_ctx.host_or_ip);
382 383 384
      general_log_print(thd, COM_CONNECT, ER(ER_SERVER_IS_IN_SECURE_AUTH_MODE),
                        thd->main_security_ctx.user,
                        thd->main_security_ctx.host_or_ip);
385 386
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
387
    /* We have to read very specific packet size */
388
    if (send_old_password_request(thd) ||
unknown's avatar
unknown committed
389
        my_net_read(net) != SCRAMBLE_LENGTH_323 + 1)
390
    {
unknown's avatar
unknown committed
391 392 393 394 395
      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 */
396
    res= acl_getroot(thd, &ur, (char *) net->read_pos, SCRAMBLE_LENGTH_323);
unknown's avatar
unknown committed
397
  }
unknown's avatar
unknown committed
398
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
399 400
  /* here res is always >= 0 */
  if (res == 0)
unknown's avatar
unknown committed
401
  {
402 403
    if (!(thd->main_security_ctx.master_access &
          NO_ACCESS)) // authentication is OK
404
    {
unknown's avatar
unknown committed
405 406 407 408
      DBUG_PRINT("info",
                 ("Capabilities: %d  packet_length: %ld  Host: '%s'  "
                  "Login user: '%s' Priv_user: '%s'  Using password: %s "
                  "Access: %u  db: '%s'",
409 410 411 412 413
                  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
414
                  passwd_len ? "yes": "no",
415 416
                  thd->main_security_ctx.master_access,
                  (thd->db ? thd->db : "*none*")));
unknown's avatar
unknown committed
417 418

      if (check_count)
419
      {
unknown's avatar
unknown committed
420
        VOID(pthread_mutex_lock(&LOCK_thread_count));
unknown's avatar
unknown committed
421
        bool count_ok= thread_count <= max_connections + delayed_insert_threads
422
                       || (thd->main_security_ctx.master_access & SUPER_ACL);
unknown's avatar
unknown committed
423 424
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
        if (!count_ok)
unknown's avatar
unknown committed
425
        {                                         // too many connections
426
          net_send_error(thd, ER_CON_COUNT_ERROR);
unknown's avatar
unknown committed
427 428
          DBUG_RETURN(-1);
        }
429
      }
unknown's avatar
unknown committed
430

unknown's avatar
unknown committed
431
      /* Why logging is performed before all checks've passed? */
432 433 434 435 436 437 438 439
      general_log_print(thd, command,
                        (thd->main_security_ctx.priv_user ==
                         thd->main_security_ctx.user ?
                         (char*) "%s@%s on %s" :
                         (char*) "%s@%s as anonymous on %s"),
                        thd->main_security_ctx.user,
                        thd->main_security_ctx.host_or_ip,
                        db ? db : (char*) "");
unknown's avatar
unknown committed
440

441
      /*
442 443 444
        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.
445
      */
446
      thd->main_security_ctx.db_access=0;
unknown's avatar
unknown committed
447 448

      /* Don't allow user to connect if he has done too many queries */
449
      if ((ur.questions || ur.updates || ur.conn_per_hour || ur.user_conn ||
unknown's avatar
unknown committed
450
	   max_user_connections) &&
451
	  get_or_create_user_conn(thd,
452 453 454 455
            (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),
456
            &ur))
unknown's avatar
unknown committed
457 458
	DBUG_RETURN(-1);
      if (thd->user_connect &&
459 460
	  (thd->user_connect->user_resources.conn_per_hour ||
	   thd->user_connect->user_resources.user_conn ||
unknown's avatar
unknown committed
461 462 463
	   max_user_connections) &&
	  check_for_max_user_connections(thd, thd->user_connect))
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
464

465
      /* Change database if necessary */
unknown's avatar
unknown committed
466
      if (db && db[0])
467
      {
468
        if (mysql_change_db(thd, db, FALSE))
unknown's avatar
unknown committed
469
        {
470 471
          /* Send error to the client */
          net_send_error(thd);
unknown's avatar
unknown committed
472 473 474 475
          if (thd->user_connect)
            decrease_user_connections(thd->user_connect);
          DBUG_RETURN(-1);
        }
476
      }
477
      send_ok(thd);
unknown's avatar
unknown committed
478 479 480
      thd->password= test(passwd_len);          // remember for error messages 
      /* Ready to handle queries */
      DBUG_RETURN(0);
unknown's avatar
unknown committed
481 482
    }
  }
unknown's avatar
unknown committed
483
  else if (res == 2) // client gave short hash, server has long hash
unknown's avatar
unknown committed
484
  {
485
    net_printf_error(thd, ER_NOT_SUPPORTED_AUTH_MODE);
486
    general_log_print(thd, COM_CONNECT, ER(ER_NOT_SUPPORTED_AUTH_MODE));
unknown's avatar
unknown committed
487
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
488
  }
489
  net_printf_error(thd, ER_ACCESS_DENIED_ERROR,
490 491
                   thd->main_security_ctx.user,
                   thd->main_security_ctx.host_or_ip,
492
                   passwd_len ? ER(ER_YES) : ER(ER_NO));
493 494 495 496
  general_log_print(thd, COM_CONNECT, ER(ER_ACCESS_DENIED_ERROR),
                    thd->main_security_ctx.user,
                    thd->main_security_ctx.host_or_ip,
                    passwd_len ? ER(ER_YES) : ER(ER_NO));
unknown's avatar
unknown committed
497
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
498
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
499 500
}

unknown's avatar
unknown committed
501
/*
unknown's avatar
unknown committed
502 503
  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
504 505
*/

506 507
extern "C" byte *get_key_conn(user_conn *buff, uint *length,
			      my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
508 509 510 511 512
{
  *length=buff->len;
  return (byte*) buff->user;
}

513
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
514 515 516 517
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
518
void init_max_user_conn(void)
unknown's avatar
unknown committed
519
{
unknown's avatar
unknown committed
520 521
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
522
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
523
		   0);
unknown's avatar
unknown committed
524 525 526
}


unknown's avatar
unknown committed
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
/*
  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
544 545
#ifndef NO_EMBEDDED_ACCESS_CHECKS

546
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
547
{
548
  int error=0;
549
  DBUG_ENTER("check_for_max_user_connections");
unknown's avatar
unknown committed
550

551
  (void) pthread_mutex_lock(&LOCK_user_conn);
552
  if (max_user_connections && !uc->user_resources.user_conn &&
unknown's avatar
unknown committed
553
      max_user_connections < (uint) uc->connections)
unknown's avatar
unknown committed
554
  {
555
    net_printf_error(thd, ER_TOO_MANY_USER_CONNECTIONS, uc->user);
556 557
    error=1;
    goto end;
unknown's avatar
unknown committed
558
  }
559
  time_out_user_resource_limits(thd, uc);
560 561 562 563 564 565 566 567 568 569 570
  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)
571
  {
572
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user,
unknown's avatar
unknown committed
573
                     "max_connections_per_hour",
574
                     (long) uc->user_resources.conn_per_hour);
575 576 577
    error=1;
    goto end;
  }
578
  uc->conn_per_hour++;
unknown's avatar
unknown committed
579 580

  end:
581 582
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
583
  (void) pthread_mutex_unlock(&LOCK_user_conn);
584
  DBUG_RETURN(error);
unknown's avatar
unknown committed
585
}
unknown's avatar
unknown committed
586
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
587

unknown's avatar
unknown committed
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
/*
  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.
*/

606
static void decrease_user_connections(USER_CONN *uc)
unknown's avatar
unknown committed
607
{
608
  DBUG_ENTER("decrease_user_connections");
609 610 611
  (void) pthread_mutex_lock(&LOCK_user_conn);
  DBUG_ASSERT(uc->connections);
  if (!--uc->connections && !mqh_used)
unknown's avatar
unknown committed
612 613
  {
    /* Last connection for user; Delete it */
unknown's avatar
unknown committed
614
    (void) hash_delete(&hash_user_connections,(byte*) uc);
unknown's avatar
unknown committed
615
  }
616
  (void) pthread_mutex_unlock(&LOCK_user_conn);
617
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
618 619
}

620

unknown's avatar
unknown committed
621 622 623 624 625
void free_max_user_conn(void)
{
  hash_free(&hash_user_connections);
}

unknown's avatar
unknown committed
626

627 628 629
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
unknown's avatar
unknown committed
630 631 632

  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
633 634 635 636 637 638

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

unknown's avatar
unknown committed
641
char  uc_update_queries[SQLCOM_END+1];
642 643 644

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

647 648 649
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
650 651 652 653 654 655
  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;
656 657 658 659 660
  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;
661 662
  uc_update_queries[SQLCOM_REPLACE]=2;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=2;
663 664 665 666
  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
667 668
  uc_update_queries[SQLCOM_CREATE_VIEW]=1;
  uc_update_queries[SQLCOM_DROP_VIEW]=1;
669 670 671
  uc_update_queries[SQLCOM_CREATE_EVENT]=1;
  uc_update_queries[SQLCOM_ALTER_EVENT]=1;
  uc_update_queries[SQLCOM_DROP_EVENT]=1;  
672 673
}

unknown's avatar
unknown committed
674 675
bool is_update_query(enum enum_sql_command command)
{
unknown's avatar
unknown committed
676
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
677
  return uc_update_queries[command] != 0;
unknown's avatar
unknown committed
678
}
679

unknown's avatar
unknown committed
680
/*
681 682
  Reset per-hour user resource limits when it has been more than
  an hour since they were last checked
unknown's avatar
unknown committed
683

684 685 686 687
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
unknown's avatar
unknown committed
688

689 690 691 692
  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.
*/
693

694
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
695
{
unknown's avatar
unknown committed
696
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
697
  DBUG_ENTER("time_out_user_resource_limits");
unknown's avatar
unknown committed
698

unknown's avatar
unknown committed
699
  /* If more than a hour since last check, reset resource checking */
700 701 702 703 704 705 706
  if (check_time  - uc->intime >= 3600)
  {
    uc->questions=1;
    uc->updates=0;
    uc->conn_per_hour=0;
    uc->intime=check_time;
  }
707 708 709 710 711 712 713 714 715 716 717 718

  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)
{
719 720
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  bool error= 0;
721 722 723 724 725 726 727 728
  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
729
  /* Check that we have not done too many questions / hour */
730 731 732
  if (uc->user_resources.questions &&
      uc->questions++ >= uc->user_resources.questions)
  {
733 734
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user, "max_questions",
                     (long) uc->user_resources.questions);
735 736 737
    error=1;
    goto end;
  }
738
  if (check_command < (uint) SQLCOM_END)
unknown's avatar
unknown committed
739
  {
unknown's avatar
unknown committed
740 741 742 743
    /* 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)
    {
744 745
      net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user, "max_updates",
                       (long) uc->user_resources.updates);
unknown's avatar
unknown committed
746 747 748
      error=1;
      goto end;
    }
unknown's avatar
unknown committed
749 750
  }
end:
751
  (void) pthread_mutex_unlock(&LOCK_user_conn);
752
  DBUG_RETURN(error);
753 754
#else
  return (0);
unknown's avatar
unknown committed
755
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
756 757
}

unknown's avatar
unknown committed
758

unknown's avatar
unknown committed
759
static void reset_mqh(LEX_USER *lu, bool get_them= 0)
760
{
unknown's avatar
unknown committed
761
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
762
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
763
  if (lu)  // for GRANT
764
  {
765
    USER_CONN *uc;
766
    uint temp_len=lu->user.length+lu->host.length+2;
767
    char temp_user[USER_HOST_BUFF_SIZE];
768

unknown's avatar
unknown committed
769 770
    memcpy(temp_user,lu->user.str,lu->user.length);
    memcpy(temp_user+lu->user.length+1,lu->host.str,lu->host.length);
771
    temp_user[lu->user.length]='\0'; temp_user[temp_len-1]=0;
unknown's avatar
unknown committed
772
    if ((uc = (struct  user_conn *) hash_search(&hash_user_connections,
773
						(byte*) temp_user, temp_len)))
774 775
    {
      uc->questions=0;
776
      get_mqh(temp_user,&temp_user[lu->user.length+1],uc);
777 778
      uc->updates=0;
      uc->conn_per_hour=0;
779 780
    }
  }
unknown's avatar
unknown committed
781
  else
782
  {
unknown's avatar
unknown committed
783
    /* for FLUSH PRIVILEGES and FLUSH USER_RESOURCES */
unknown's avatar
unknown committed
784
    for (uint idx=0;idx < hash_user_connections.records; idx++)
785
    {
unknown's avatar
unknown committed
786 787
      USER_CONN *uc=(struct user_conn *) hash_element(&hash_user_connections,
						      idx);
788 789 790 791 792
      if (get_them)
	get_mqh(uc->user,uc->host,uc);
      uc->questions=0;
      uc->updates=0;
      uc->conn_per_hour=0;
793 794
    }
  }
unknown's avatar
unknown committed
795
  (void) pthread_mutex_unlock(&LOCK_user_conn);
unknown's avatar
unknown committed
796
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
797
}
unknown's avatar
unknown committed
798

unknown's avatar
unknown committed
799
/*
800
    Perform handshake, authorize client and update thd ACL variables.
801
  SYNOPSIS
802
    check_connection()
803
    thd  thread handle
804 805

  RETURN
806
     0  success, OK is sent to user, thd is updated.
807 808
    -1  error, which is sent to user
   > 0  error code (not sent to user)
unknown's avatar
unknown committed
809 810
*/

unknown's avatar
unknown committed
811 812
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
unknown's avatar
unknown committed
813
{
814
  uint connect_errors= 0;
unknown's avatar
unknown committed
815
  NET *net= &thd->net;
unknown's avatar
unknown committed
816 817
  ulong pkt_len= 0;
  char *end;
818

819 820
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));
unknown's avatar
unknown committed
821
#ifdef SIGNAL_WITH_VIO_CLOSE
822
  thd->set_active_vio(net->vio);
unknown's avatar
unknown committed
823
#endif
824

825
  if (!thd->main_security_ctx.host)         // If TCP/IP connection
unknown's avatar
unknown committed
826
  {
827
    char ip[30];
828

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

874 875 876 877 878
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
879 880
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
881
      client_flags |= CLIENT_SSL;       /* Wow, SSL is available! */
unknown's avatar
unknown committed
882
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
883

884 885 886 887 888 889 890 891 892 893 894
    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
895
      tail: that's why first part of the scramble is placed here, and second
896 897
      part at the end of packet.
    */
898
    end= strmake(end, thd->scramble, SCRAMBLE_LENGTH_323) + 1;
899 900 901
   
    int2store(end, client_flags);
    /* write server characteristics: up to 16 bytes allowed */
902
    end[2]=(char) default_charset_info->number;
903 904 905 906 907 908 909 910 911
    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
912
			  (uint) (end-buff)) ||
913
	(pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
914 915 916 917 918 919 920 921 922 923 924
	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
925
  if (thd->packet.alloc(thd->variables.net_buffer_length))
unknown's avatar
unknown committed
926 927 928
    return(ER_OUT_OF_RESOURCES);

  thd->client_capabilities=uint2korr(net->read_pos);
929 930 931 932
  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
933 934 935
    DBUG_PRINT("info", ("client_character_set: %d", (uint) net->read_pos[8]));
    /*
      Use server character set and collation if
936
      - opt_character_set_client_handshake is not set
unknown's avatar
unknown committed
937 938 939 940
      - client has not specified a character set
      - client character set is the same as the servers
      - client character set doesn't exists in server
    */
941
    if (!opt_character_set_client_handshake ||
942
        !(thd->variables.character_set_client=
unknown's avatar
unknown committed
943 944 945 946
	  get_charset((uint) net->read_pos[8], MYF(0))) ||
	!my_strcasecmp(&my_charset_latin1,
		       global_system_variables.character_set_client->name,
		       thd->variables.character_set_client->name))
947
    {
948 949
      thd->variables.character_set_client=
	global_system_variables.character_set_client;
950 951
      thd->variables.collation_connection=
	global_system_variables.collation_connection;
952 953
      thd->variables.character_set_results=
	global_system_variables.character_set_results;
954 955 956
    }
    else
    {
957
      thd->variables.character_set_results=
958 959 960
      thd->variables.collation_connection= 
	thd->variables.character_set_client;
    }
unknown's avatar
unknown committed
961
    thd->update_charset();
962
    end= (char*) net->read_pos+32;
963 964 965 966 967 968 969
  }
  else
  {
    thd->max_client_packet_length= uint3korr(net->read_pos+2);
    end= (char*) net->read_pos+5;
  }

970
  if (thd->client_capabilities & CLIENT_IGNORE_SPACE)
971
    thd->variables.sql_mode|= MODE_IGNORE_SPACE;
unknown's avatar
unknown committed
972
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
973
  DBUG_PRINT("info", ("client capabilities: %d", thd->client_capabilities));
unknown's avatar
unknown committed
974 975 976
  if (thd->client_capabilities & CLIENT_SSL)
  {
    /* Do the SSL layering. */
977 978 979 980 981
    if (!ssl_acceptor_fd)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
unknown's avatar
unknown committed
982
    DBUG_PRINT("info", ("IO layer change in progress..."));
unknown's avatar
unknown committed
983 984
    if (sslaccept(ssl_acceptor_fd, net->vio, thd->variables.net_wait_timeout))
    {
985
      DBUG_PRINT("error", ("Failed to accept new SSL connection"));
unknown's avatar
unknown committed
986
      inc_host_errors(&thd->remote.sin_addr);
unknown's avatar
unknown committed
987
      return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
988
    }
unknown's avatar
unknown committed
989
    DBUG_PRINT("info", ("Reading user information over SSL layer"));
990
    if ((pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
991 992
	pkt_len < NORMAL_HANDSHAKE_SIZE)
    {
unknown's avatar
unknown committed
993 994
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
unknown's avatar
unknown committed
995 996 997 998
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
999 1000 1001
#endif

  if (end >= (char*) net->read_pos+ pkt_len +2)
unknown's avatar
unknown committed
1002
  {
1003 1004
    inc_host_errors(&thd->remote.sin_addr);
    return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
1005 1006 1007
  }

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
1008
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
1009
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
1010 1011
      opt_using_transactions)
    net->return_status= &thd->server_status;
unknown's avatar
unknown committed
1012
  net->read_timeout=(uint) thd->variables.net_read_timeout;
unknown's avatar
unknown committed
1013

1014 1015
  char *user= end;
  char *passwd= strend(user)+1;
unknown's avatar
unknown committed
1016
  char *db= passwd;
1017
  char db_buff[NAME_LEN+1];                     // buffer to store db in utf8
unknown's avatar
unknown committed
1018
  char user_buff[USERNAME_LENGTH+1];		// buffer to store user in utf8
1019 1020 1021
  uint dummy_errors;

  /*
unknown's avatar
unknown committed
1022 1023 1024 1025
    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'.
  */
1026
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
unknown's avatar
unknown committed
1027 1028 1029
    *passwd++ : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
unknown's avatar
unknown committed
1030

unknown's avatar
unknown committed
1031 1032
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
unknown's avatar
unknown committed
1033
  {
1034 1035 1036
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info,
                             db, strlen(db),
1037
                             thd->charset(), &dummy_errors)]= 0;
1038
    db= db_buff;
unknown's avatar
unknown committed
1039
  }
unknown's avatar
unknown committed
1040

1041 1042 1043 1044
  user_buff[copy_and_convert(user_buff, sizeof(user_buff)-1,
                             system_charset_info, user, strlen(user),
                             thd->charset(), &dummy_errors)]= '\0';
  user= user_buff;
unknown's avatar
unknown committed
1045

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

1053

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

1060 1061 1062 1063 1064 1065 1066 1067 1068
  thd->proc_info= "Execution of init_command";
  /*
    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
1069 1070
  save_client_capabilities= thd->client_capabilities;
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
1071 1072 1073 1074
  /*
    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
1075 1076
  save_vio= thd->net.vio;
  thd->net.vio= 0;
1077
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
1078
  dispatch_command(COM_QUERY, thd, thd->query, thd->query_length+1);
1079
  rw_unlock(var_mutex);
unknown's avatar
unknown committed
1080 1081 1082 1083 1084
  thd->client_capabilities= save_client_capabilities;
  thd->net.vio= save_vio;
}


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

  pthread_detach_this_thread();

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

1106 1107 1108 1109 1110 1111 1112
  /*
    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
1113 1114
  DBUG_PRINT("info", ("handle_one_connection called by thread %d\n",
		      thd->thread_id));
unknown's avatar
unknown committed
1115
  /* now that we've called my_thread_init(), it is safe to call DBUG_* */
unknown's avatar
unknown committed
1116

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

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

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

unknown's avatar
unknown committed
1159
    thd->version= refresh_version;
1160
    thd->proc_info= 0;
1161
    thd->command= COM_SLEEP;
1162 1163
    thd->set_time();
    thd->init_for_queries();
unknown's avatar
unknown committed
1164

1165
    if (sys_init_connect.value_length && !(sctx->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1166
    {
1167 1168
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
unknown's avatar
unknown committed
1169
	thd->killed= THD::KILL_CONNECTION;
1170 1171 1172
      thd->proc_info=0;
      thd->set_time();
      thd->init_for_queries();
unknown's avatar
unknown committed
1173 1174
    }

1175 1176
    while (!net->error && net->vio != 0 &&
           !(thd->killed == THD::KILL_CONNECTION))
unknown's avatar
unknown committed
1177
    {
1178
      net->no_send_error= 0;
unknown's avatar
unknown committed
1179 1180 1181
      if (do_command(thd))
	break;
    }
1182 1183
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
unknown's avatar
unknown committed
1184
    if (net->error && net->vio != 0 && net->report_error)
unknown's avatar
unknown committed
1185
    {
1186
      if (!thd->killed && thd->variables.log_warnings > 1)
unknown's avatar
unknown committed
1187
	sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
unknown's avatar
unknown committed
1188
                          thd->thread_id,(thd->db ? thd->db : "unconnected"),
1189 1190
                          sctx->user ? sctx->user : "unauthenticated",
                          sctx->host_or_ip,
unknown's avatar
unknown committed
1191 1192
                          (net->last_errno ? ER(net->last_errno) :
                           ER(ER_UNKNOWN_ERROR)));
1193
      net_send_error(thd, net->last_errno, NullS);
unknown's avatar
unknown committed
1194
      statistic_increment(aborted_threads,&LOCK_status);
unknown's avatar
unknown committed
1195
    }
1196 1197 1198 1199
    else if (thd->killed)
    {
      statistic_increment(aborted_threads,&LOCK_status);
    }
1200
    
unknown's avatar
unknown committed
1201
end_thread:
1202
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1203 1204 1205 1206 1207 1208
    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;
unknown's avatar
unknown committed
1209
    thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1210 1211 1212 1213 1214
  } 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
1215 1216
#endif /* EMBEDDED_LIBRARY */

1217 1218 1219 1220
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
1221

1222
pthread_handler_t handle_bootstrap(void *arg)
unknown's avatar
unknown committed
1223
{
1224 1225 1226
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
unknown's avatar
unknown committed
1227

1228
  /* The following must be called before DBUG_ENTER */
1229
  thd->thread_stack= (char*) &thd;
1230
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
1231
  {
unknown's avatar
unknown committed
1232
#ifndef EMBEDDED_LIBRARY
1233
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
1234
#endif
1235
    thd->fatal_error();
1236
    goto end;
unknown's avatar
unknown committed
1237
  }
1238 1239
  DBUG_ENTER("handle_bootstrap");

unknown's avatar
unknown committed
1240
#ifndef EMBEDDED_LIBRARY
1241 1242
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1243
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1244
  sigset_t set;
1245 1246
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
1247
#endif
unknown's avatar
unknown committed
1248
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1249

1250
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1251 1252 1253 1254
    thd->options |= OPTION_BIG_SELECTS;

  thd->proc_info=0;
  thd->version=refresh_version;
1255 1256
  thd->security_ctx->priv_user=
    thd->security_ctx->user= (char*) my_strdup("boot", MYF(MY_WME));
unknown's avatar
unknown committed
1257
  thd->security_ctx->priv_host[0]=0;
unknown's avatar
unknown committed
1258

1259
  buff= (char*) thd->net.buff;
1260
  thd->init_for_queries();
unknown's avatar
unknown committed
1261 1262
  while (fgets(buff, thd->net.max_packet, file))
  {
unknown's avatar
unknown committed
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
   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
1283
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1284
           buff[length-1] == ';'))
unknown's avatar
unknown committed
1285 1286
      length--;
    buff[length]=0;
1287
    thd->query_length=length;
unknown's avatar
unknown committed
1288 1289
    thd->query= thd->memdup_w_gap(buff, length+1, 
				  thd->db_length+1+QUERY_CACHE_FLAGS_SIZE);
unknown's avatar
unknown committed
1290
    thd->query[length] = '\0';
1291 1292 1293 1294
    /*
      We don't need to obtain LOCK_thread_count here because in bootstrap
      mode we have only one thread.
    */
1295
    thd->query_id=next_query_id();
unknown's avatar
unknown committed
1296 1297
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
1298
    if (thd->is_fatal_error)
1299
      break;
unknown's avatar
unknown committed
1300
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1301
#ifdef USING_TRANSACTIONS
1302
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
1303
#endif
unknown's avatar
unknown committed
1304
  }
1305 1306 1307

  /* thd->fatal_error should be set in case something went wrong */
end:
1308 1309 1310 1311 1312 1313
  bootstrap_error= thd->is_fatal_error;

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

unknown's avatar
unknown committed
1314
#ifndef EMBEDDED_LIBRARY
1315 1316 1317
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1318
  (void) pthread_cond_broadcast(&COND_thread_count);
1319 1320
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1321
#endif
1322
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1323 1324
}

1325
    /* This works because items are allocated with sql_alloc() */
unknown's avatar
unknown committed
1326

1327
void free_items(Item *item)
unknown's avatar
unknown committed
1328
{
unknown's avatar
unknown committed
1329
  Item *next;
unknown's avatar
unknown committed
1330
  DBUG_ENTER("free_items");
unknown's avatar
unknown committed
1331 1332 1333
  for (; item ; item=next)
  {
    next=item->next;
1334
    item->delete_self();
unknown's avatar
unknown committed
1335
  }
unknown's avatar
unknown committed
1336
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1337 1338
}

1339 1340 1341 1342
    /* This works because items are allocated with sql_alloc() */

void cleanup_items(Item *item)
{
unknown's avatar
unknown committed
1343
  DBUG_ENTER("cleanup_items");  
1344 1345
  for (; item ; item=item->next)
    item->cleanup();
unknown's avatar
unknown committed
1346
  DBUG_VOID_RETURN;
1347 1348
}

unknown's avatar
unknown committed
1349 1350 1351 1352 1353 1354 1355
int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd)
{
  TABLE* table;
  TABLE_LIST* table_list;
  int error = 0;
  DBUG_ENTER("mysql_table_dump");
  db = (db && db[0]) ? db : thd->db;
1356
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1357
    DBUG_RETURN(1); // out of memory
unknown's avatar
VIEW  
unknown committed
1358
  table_list->db= db;
1359
  table_list->table_name= table_list->alias= tbl_name;
unknown's avatar
VIEW  
unknown committed
1360 1361
  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
1362

1363 1364
  if (!db || check_db_name(db))
  {
1365
    my_error(ER_WRONG_DB_NAME ,MYF(0), db ? db : "NULL");
1366 1367
    goto err;
  }
1368
  if (lower_case_table_names)
1369
    my_casedn_str(files_charset_info, tbl_name);
1370
  remove_escape(table_list->table_name);
1371 1372 1373 1374

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

unknown's avatar
unknown committed
1375
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1376 1377
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1378
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1379
  thd->query = tbl_name;
unknown's avatar
unknown committed
1380
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1381
  {
1382
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1383 1384
    goto err;
  }
unknown's avatar
unknown committed
1385
  net_flush(&thd->net);
1386
  if ((error= table->file->dump(thd,fd)))
1387
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1388

unknown's avatar
unknown committed
1389
err:
unknown's avatar
unknown committed
1390
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1391 1392
}

unknown's avatar
unknown committed
1393 1394 1395 1396
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1397
    end_trans()
unknown's avatar
unknown committed
1398 1399 1400 1401 1402 1403 1404
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1405
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
unknown's avatar
unknown committed
1406 1407 1408
{
  bool do_release= 0;
  int res= 0;
1409
  DBUG_ENTER("end_trans");
unknown's avatar
unknown committed
1410

1411
  if (unlikely(thd->in_sub_stmt))
1412 1413 1414 1415
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
1416 1417 1418 1419 1420 1421
  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
1422 1423 1424 1425 1426 1427 1428 1429
  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;
1430
    res= ha_commit(thd);
1431
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
1432 1433
    break;
  case COMMIT_RELEASE:
unknown's avatar
unknown committed
1434
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1435 1436 1437 1438 1439 1440
  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
1441
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1442 1443 1444 1445
  case ROLLBACK:
  case ROLLBACK_AND_CHAIN:
  {
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
unknown's avatar
unknown committed
1446
    if (ha_rollback(thd))
unknown's avatar
unknown committed
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
      res= -1;
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    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
1458

unknown's avatar
unknown committed
1459 1460 1461
  if (res < 0)
    my_error(thd->killed_errno(), MYF(0));
  else if ((res == 0) && do_release)
unknown's avatar
unknown committed
1462 1463
    thd->killed= THD::KILL_CONNECTION;

unknown's avatar
unknown committed
1464 1465
  DBUG_RETURN(res);
}
unknown's avatar
unknown committed
1466

1467
#ifndef EMBEDDED_LIBRARY
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478

/*
  Read one command from socket and execute it (query or simple command).
  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
1479 1480 1481
bool do_command(THD *thd)
{
  char *packet;
unknown's avatar
unknown committed
1482 1483
  uint old_timeout;
  ulong packet_length;
unknown's avatar
unknown committed
1484 1485 1486 1487 1488
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
unknown's avatar
unknown committed
1489 1490 1491 1492
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1493
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1494 1495

  packet=0;
unknown's avatar
unknown committed
1496
  old_timeout=net->read_timeout;
unknown's avatar
unknown committed
1497
  /* Wait max for 8 hours */
unknown's avatar
unknown committed
1498
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
unknown's avatar
unknown committed
1499
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1500 1501 1502 1503

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1504 1505 1506 1507 1508
    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)
1509 1510
    {
      statistic_increment(aborted_threads,&LOCK_status);
1511
      DBUG_RETURN(TRUE);			// We have to close it.
1512
    }
1513
    net_send_error(thd, net->last_errno, NullS);
1514
    net->error= 0;
1515
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1516 1517 1518 1519 1520
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1521 1522
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
1523 1524 1525
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
1526
  }
unknown's avatar
unknown committed
1527
  net->read_timeout=old_timeout;		// restore it
1528 1529 1530 1531 1532 1533 1534 1535 1536
  /*
    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
1537
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1538
}
1539
#endif  /* EMBEDDED_LIBRARY */
1540

1541

1542 1543
/*
   Perform one connection-level (COM_XXXX) command.
1544

1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
  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
*/
1558

1559 1560 1561 1562
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1563
  bool error= 0;
1564 1565
  DBUG_ENTER("dispatch_command");

1566 1567 1568
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
    thd->killed= THD::NOT_KILLED;

1569
  thd->command=command;
unknown's avatar
unknown committed
1570
  /*
1571 1572
    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
1573
  */
1574
  thd->enable_slow_log= TRUE;
1575
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
unknown's avatar
unknown committed
1576
  thd->set_time();
unknown's avatar
unknown committed
1577 1578 1579
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
1580
    next_query_id();
unknown's avatar
unknown committed
1581
  thread_running++;
1582
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1583
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1584

1585 1586
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1587
  switch (command) {
unknown's avatar
unknown committed
1588
  case COM_INIT_DB:
unknown's avatar
unknown committed
1589 1590
  {
    LEX_STRING tmp;
1591 1592
    statistic_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB],
			&LOCK_status);
unknown's avatar
unknown committed
1593 1594
    thd->convert_string(&tmp, system_charset_info,
			packet, strlen(packet), thd->charset());
1595 1596
    if (!mysql_change_db(thd, tmp.str, FALSE))
    {
1597
      general_log_print(thd, command, "%s",thd->db);
1598 1599
      send_ok(thd);
    }
unknown's avatar
unknown committed
1600 1601
    break;
  }
unknown's avatar
unknown committed
1602
#ifdef HAVE_REPLICATION
1603 1604
  case COM_REGISTER_SLAVE:
  {
1605
    if (!register_slave(thd, (uchar*)packet, packet_length))
1606
      send_ok(thd);
1607 1608
    break;
  }
1609
#endif
unknown's avatar
unknown committed
1610
  case COM_TABLE_DUMP:
1611 1612 1613 1614 1615
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
    uint tbl_len= *(uchar*) (packet + db_len + 1);

1616
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1617
    thd->enable_slow_log= opt_log_slow_admin_statements;
1618
    db= thd->alloc(db_len + tbl_len + 2);
1619 1620 1621 1622 1623
    if (!db)
    {
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
      break;
    }
1624 1625
    tbl_name= strmake(db, packet + 1, db_len)+1;
    strmake(tbl_name, packet + db_len + 2, tbl_len);
unknown's avatar
unknown committed
1626
    mysql_table_dump(thd, db, tbl_name, -1);
1627 1628
    break;
  }
unknown's avatar
unknown committed
1629 1630
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1631
    thd->change_user();
1632
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1633

1634
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1635
    char *user= (char*) packet;
unknown's avatar
unknown committed
1636
    char *passwd= strend(user)+1;
1637
    /*
unknown's avatar
unknown committed
1638 1639 1640 1641
      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).
    */
1642
    char db_buff[NAME_LEN+1];                 // buffer to store db in utf8
unknown's avatar
unknown committed
1643
    char *db= passwd;
1644
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
unknown's avatar
unknown committed
1645 1646
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1647
#ifndef EMBEDDED_LIBRARY
1648
    /* Small check for incoming packet */
unknown's avatar
unknown committed
1649
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1650
    {
unknown's avatar
unknown committed
1651
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1652 1653
      break;
    }
1654
#endif
1655
    /* Convert database name to utf8 */
1656
    uint dummy_errors;
1657 1658
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1659
                             thd->charset(), &dummy_errors)]= 0;
1660
    db= db_buff;
unknown's avatar
unknown committed
1661

1662 1663 1664
    /* Save user and privileges */
    uint save_db_length= thd->db_length;
    char *save_db= thd->db;
1665
    Security_context save_security_ctx= *thd->security_ctx;
unknown's avatar
unknown committed
1666
    USER_CONN *save_user_connect= thd->user_connect;
1667 1668

    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
1669
    {
1670
      thd->security_ctx->user= save_security_ctx.user;
unknown's avatar
unknown committed
1671
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1672 1673
      break;
    }
unknown's avatar
unknown committed
1674

unknown's avatar
unknown committed
1675 1676
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1677
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1678

1679 1680
    if (res)
    {
1681
      /* authentication failure, we shall restore old user */
1682
      if (res > 0)
unknown's avatar
unknown committed
1683
        my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1684 1685
      x_free(thd->security_ctx->user);
      *thd->security_ctx= save_security_ctx;
unknown's avatar
unknown committed
1686
      thd->user_connect= save_user_connect;
1687 1688 1689 1690 1691 1692
      thd->db= save_db;
      thd->db_length= save_db_length;
    }
    else
    {
      /* we've authenticated new user */
unknown's avatar
unknown committed
1693 1694
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1695
      x_free((gptr) save_db);
1696
      x_free((gptr)  save_security_ctx.user);
1697
    }
unknown's avatar
unknown committed
1698 1699
    break;
  }
1700
  case COM_STMT_EXECUTE:
unknown's avatar
unknown committed
1701
  {
1702
    mysql_stmt_execute(thd, packet, packet_length);
unknown's avatar
unknown committed
1703 1704
    break;
  }
1705
  case COM_STMT_FETCH:
1706 1707 1708 1709
  {
    mysql_stmt_fetch(thd, packet, packet_length);
    break;
  }
1710
  case COM_STMT_SEND_LONG_DATA:
unknown's avatar
unknown committed
1711
  {
1712
    mysql_stmt_get_longdata(thd, packet, packet_length);
unknown's avatar
unknown committed
1713 1714
    break;
  }
1715
  case COM_STMT_PREPARE:
unknown's avatar
unknown committed
1716
  {
1717
    mysql_stmt_prepare(thd, packet, packet_length);
unknown's avatar
unknown committed
1718 1719
    break;
  }
1720
  case COM_STMT_CLOSE:
unknown's avatar
unknown committed
1721
  {
1722
    mysql_stmt_close(thd, packet);
unknown's avatar
unknown committed
1723 1724
    break;
  }
1725
  case COM_STMT_RESET:
1726 1727 1728 1729
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
unknown's avatar
unknown committed
1730 1731
  case COM_QUERY:
  {
1732 1733
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1734
    char *packet_end= thd->query + thd->query_length;
1735
    general_log_print(thd, command, "%s", thd->query);
1736
    DBUG_PRINT("query",("%-.4096s",thd->query));
1737 1738 1739 1740

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

1741
    mysql_parse(thd,thd->query, thd->query_length);
1742

1743
    while (!thd->killed && thd->lex->found_semicolon && !thd->net.report_error)
1744
    {
1745
      char *packet= thd->lex->found_semicolon;
1746
      net->no_send_error= 0;
1747
      /*
1748 1749
        Multiple queries exits, execute them individually
      */
1750 1751
      if (thd->lock || thd->open_tables || thd->derived_tables ||
          thd->prelocked_mode)
1752
        close_thread_tables(thd);
1753
      ulong length= (ulong)(packet_end-packet);
1754

1755
      log_slow_statement(thd);
1756

1757
      /* Remove garbage at start of query */
unknown's avatar
unknown committed
1758
      while (my_isspace(thd->charset(), *packet) && length > 0)
1759 1760 1761 1762
      {
        packet++;
        length--;
      }
unknown's avatar
unknown committed
1763
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1764
      thd->query_length= length;
1765
      thd->query= packet;
1766
      thd->query_id= next_query_id();
1767
      thd->set_time(); /* Reset the query start time. */
1768
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1769
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1770 1771 1772
      mysql_parse(thd, packet, length);
    }

unknown's avatar
unknown committed
1773 1774 1775 1776 1777
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1778
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1779
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
1780 1781
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
unknown's avatar
unknown committed
1782 1783 1784
    break;
#else
  {
1785
    char *fields, *pend;
1786 1787
    /* Locked closure of all tables */
    TABLE_LIST *locked_tables= NULL;
unknown's avatar
unknown committed
1788
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1789
    LEX_STRING conv_name;
1790
    /* Saved variable value */
1791 1792 1793
    my_bool old_innodb_table_locks=  thd->variables.innodb_table_locks;


unknown's avatar
unknown committed
1794 1795
    /* used as fields initializator */
    lex_start(thd, 0, 0);
1796

unknown's avatar
unknown committed
1797

1798 1799
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
unknown's avatar
unknown committed
1800 1801 1802
    bzero((char*) &table_list,sizeof(table_list));
    if (!(table_list.db=thd->db))
    {
unknown's avatar
unknown committed
1803
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
unknown's avatar
unknown committed
1804 1805
      break;
    }
1806
    pend= strend(packet);
unknown's avatar
unknown committed
1807 1808
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1809
    table_list.alias= table_list.table_name= conv_name.str;
1810
    packet= pend+1;
1811 1812 1813 1814 1815 1816 1817 1818 1819

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

1820
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
unknown's avatar
unknown committed
1821 1822
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1823
    general_log_print(thd, command, "%s %s", table_list.table_name, fields);
1824
    if (lower_case_table_names)
1825 1826
      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
1827

unknown's avatar
unknown committed
1828
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
1829
		     0, 0, test(table_list.schema_table)))
unknown's avatar
unknown committed
1830
      break;
unknown's avatar
unknown committed
1831 1832
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1833
      break;
1834 1835 1836 1837 1838 1839
    /* 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
1840
    thd->lex->add_to_query_tables(&table_list);
1841

1842 1843
    /* switch on VIEW optimisation: do not fill temporary tables */
    thd->lex->sql_command= SQLCOM_SHOW_FIELDS;
unknown's avatar
unknown committed
1844
    mysqld_list_fields(thd,&table_list,fields);
1845
    thd->lex->unit.cleanup();
1846
    thd->cleanup_after_query();
unknown's avatar
unknown committed
1847 1848 1849 1850
    break;
  }
#endif
  case COM_QUIT:
1851
    /* We don't calculate statistics for this command */
1852
    general_log_print(thd, command, NullS);
unknown's avatar
unknown committed
1853 1854 1855 1856
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1857
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1858
    {
unknown's avatar
unknown committed
1859
      char *db=thd->strdup(packet), *alias;
1860
      HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1861

1862 1863
      statistic_increment(thd->status_var.com_stat[SQLCOM_CREATE_DB],
			  &LOCK_status);
1864
      // null test to handle EOM
unknown's avatar
unknown committed
1865
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1866
      {
1867
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1868 1869
	break;
      }
1870
      if (check_access(thd,CREATE_ACL,db,0,1,0,is_schema_db(db)))
unknown's avatar
unknown committed
1871
	break;
1872
      general_log_print(thd, command, packet);
1873
      bzero(&create_info, sizeof(create_info));
1874 1875
      mysql_create_db(thd, (lower_case_table_names == 2 ? alias : db),
                      &create_info, 0);
unknown's avatar
unknown committed
1876 1877
      break;
    }
unknown's avatar
unknown committed
1878
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1879
    {
1880 1881
      statistic_increment(thd->status_var.com_stat[SQLCOM_DROP_DB],
			  &LOCK_status);
1882
      char *db=thd->strdup(packet);
unknown's avatar
unknown committed
1883
      /*  null test to handle EOM */
1884
      if (!db || check_db_name(db))
1885
      {
1886
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1887 1888
	break;
      }
1889
      if (check_access(thd,DROP_ACL,db,0,1,0,is_schema_db(db)))
1890
	break;
unknown's avatar
unknown committed
1891 1892
      if (thd->locked_tables || thd->active_transaction())
      {
unknown's avatar
unknown committed
1893 1894
	my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                   ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
unknown's avatar
unknown committed
1895
	break;
unknown's avatar
unknown committed
1896
      }
1897
      general_log_print(thd, command, db);
1898
      mysql_rm_db(thd, db, 0, 0);
unknown's avatar
unknown committed
1899 1900
      break;
    }
1901
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1902 1903
  case COM_BINLOG_DUMP:
    {
unknown's avatar
unknown committed
1904 1905 1906 1907
      ulong pos;
      ushort flags;
      uint32 slave_server_id;

1908
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1909
      thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
unknown committed
1910
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1911
	break;
unknown's avatar
unknown committed
1912

1913
      /* TODO: The following has to be changed to an 8 byte integer */
1914 1915
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1916
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1917
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1918
	kill_zombie_dump_threads(slave_server_id);
1919
      thd->server_id = slave_server_id;
unknown's avatar
unknown committed
1920

1921
      general_log_print(thd, command, "Log: '%s'  Pos: %ld", packet+10,
unknown's avatar
unknown committed
1922
                      (long) pos);
1923
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1924
      unregister_slave(thd,1,1);
unknown's avatar
unknown committed
1925
      /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
1926 1927
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
1928 1929
      break;
    }
1930
#endif
unknown's avatar
unknown committed
1931
  case COM_REFRESH:
unknown's avatar
unknown committed
1932 1933 1934 1935 1936 1937
  {
    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
1938
      break;
1939
    general_log_print(thd, command, NullS);
unknown's avatar
unknown committed
1940 1941 1942 1943
    if (!reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, &not_used))
      send_ok(thd);
    break;
  }
1944
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1945
  case COM_SHUTDOWN:
1946
  {
1947
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
1948
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
1949
      break; /* purecov: inspected */
1950
    /*
1951 1952 1953 1954
      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].
1955
    */
1956 1957
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
1958
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1959 1960 1961 1962 1963 1964 1965
    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;
    }
1966
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1967
    general_log_print(thd, command, NullS);
1968
    send_eof(thd);
unknown's avatar
unknown committed
1969 1970 1971
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
unknown's avatar
unknown committed
1972
#ifndef OS2
1973
    send_eof(thd);				// This is for 'quit request'
unknown's avatar
unknown committed
1974
#endif
1975
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1976 1977 1978 1979
    close_thread_tables(thd);			// Free before kill
    kill_mysql();
    error=TRUE;
    break;
1980
  }
1981
#endif
unknown's avatar
unknown committed
1982 1983
  case COM_STATISTICS:
  {
1984
    general_log_print(thd, command, NullS);
1985 1986
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_STATUS],
			&LOCK_status);
unknown's avatar
unknown committed
1987
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1988
    char buff[200];
unknown's avatar
unknown committed
1989 1990 1991
#else
    char *buff= thd->net.last_error;
#endif
1992
    ulong uptime = (ulong) (thd->start_time - start_time);
unknown's avatar
unknown committed
1993
    sprintf((char*) buff,
1994
	    "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
1995
	    uptime,
1996 1997
	    (int) thread_count, (ulong) thd->query_id,
            (ulong) thd->status_var.long_query_count,
unknown's avatar
unknown committed
1998 1999
	    thd->status_var.opened_tables, refresh_version,
            cached_open_tables(),
2000 2001
	    (uptime ? (ulonglong2double(thd->query_id) / (double) uptime) :
	     (double) 0));
unknown's avatar
unknown committed
2002
#ifdef SAFEMALLOC
2003
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
2004
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
2005 2006
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
2007 2008
#endif
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2009
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
2010
    VOID(net_flush(net));
unknown's avatar
unknown committed
2011
#endif
unknown's avatar
unknown committed
2012 2013 2014
    break;
  }
  case COM_PING:
2015
    statistic_increment(thd->status_var.com_other, &LOCK_status);
2016
    send_ok(thd);				// Tell client we are alive
unknown's avatar
unknown committed
2017 2018
    break;
  case COM_PROCESS_INFO:
2019 2020
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST],
			&LOCK_status);
2021 2022
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd, PROCESS_ACL))
unknown's avatar
unknown committed
2023
      break;
2024
    general_log_print(thd, command, NullS);
unknown's avatar
unknown committed
2025
    mysqld_list_processes(thd,
2026 2027
			  thd->security_ctx->master_access & PROCESS_ACL ? 
			  NullS : thd->security_ctx->priv_user, 0);
unknown's avatar
unknown committed
2028 2029 2030
    break;
  case COM_PROCESS_KILL:
  {
2031
    statistic_increment(thd->status_var.com_stat[SQLCOM_KILL], &LOCK_status);
2032
    ulong id=(ulong) uint4korr(packet);
unknown's avatar
SCRUM  
unknown committed
2033
    kill_one_thread(thd,id,false);
unknown's avatar
unknown committed
2034 2035
    break;
  }
2036 2037
  case COM_SET_OPTION:
  {
2038 2039
    statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
			&LOCK_status);
2040 2041 2042 2043
    enum_mysql_set_option command= (enum_mysql_set_option) uint2korr(packet);
    switch (command) {
    case MYSQL_OPTION_MULTI_STATEMENTS_ON:
      thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
2044
      send_eof(thd);
2045 2046 2047
      break;
    case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
2048
      send_eof(thd);
2049 2050
      break;
    default:
unknown's avatar
unknown committed
2051
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
2052 2053 2054 2055
      break;
    }
    break;
  }
unknown's avatar
unknown committed
2056
  case COM_DEBUG:
2057
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
2058
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2059
      break;					/* purecov: inspected */
2060
    mysql_print_status();
2061
    general_log_print(thd, command, NullS);
2062
    send_eof(thd);
unknown's avatar
unknown committed
2063 2064 2065 2066 2067
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
2068
  case COM_END:
unknown's avatar
unknown committed
2069
  default:
unknown's avatar
unknown committed
2070
    my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
2071 2072
    break;
  }
2073 2074
  if (thd->lock || thd->open_tables || thd->derived_tables ||
      thd->prelocked_mode)
unknown's avatar
unknown committed
2075 2076 2077 2078
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088
  /*
    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())
2089
    thd->transaction.xid_state.xid.null();
unknown's avatar
unknown committed
2090

unknown's avatar
unknown committed
2091 2092 2093
  /* report error issued during command execution */
  if (thd->killed_errno() && !thd->net.report_error)
    thd->send_kill_message();
unknown's avatar
unknown committed
2094
  if (thd->net.report_error)
2095
    net_send_error(thd);
unknown's avatar
unknown committed
2096

2097
  log_slow_statement(thd);
2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112

  thd->proc_info="cleaning up";
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
  thd->proc_info=0;
  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);
}


2113
void log_slow_statement(THD *thd)
2114
{
unknown's avatar
unknown committed
2115
  DBUG_ENTER("log_slow_statement");
2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
  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;
2127
  thd->end_time();				// Set start time
2128

2129 2130 2131 2132 2133
  /*
    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
2134
  {
2135 2136
    thd->proc_info="logging slow query";

2137 2138
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2139 2140
	((thd->server_status &
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2141
	 (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES)))
2142
    {
2143
      thd->status_var.long_query_count++;
2144
      slow_log_print(thd, thd->query, thd->query_length, start_of_query);
2145
    }
unknown's avatar
unknown committed
2146
  }
unknown's avatar
unknown committed
2147
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2148 2149
}

2150

2151 2152 2153 2154 2155
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;
2156
  switch (schema_table_idx) {
2157 2158
  case SCH_SCHEMATA:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
2159 2160
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0));   /* purecov: inspected */
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170
    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:
2171
  case SCH_TRIGGERS:
2172
  case SCH_EVENTS:
2173
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2174 2175
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2176 2177 2178 2179 2180 2181
    DBUG_RETURN(1);
#else
    {
      char *db= lex->select_lex.db ? lex->select_lex.db : thd->db;
      if (!db)
      {
unknown's avatar
unknown committed
2182 2183
	my_message(ER_NO_DB_ERROR,
                   ER(ER_NO_DB_ERROR), MYF(0)); /* purecov: inspected */
2184 2185 2186 2187 2188
        DBUG_RETURN(1);				/* purecov: inspected */
      }
      remove_escape(db);				// Fix escaped '_'
      if (check_db_name(db))
      {
unknown's avatar
unknown committed
2189
        my_error(ER_WRONG_DB_NAME, MYF(0), db);
2190 2191
        DBUG_RETURN(1);
      }
2192 2193
      if (check_access(thd, SELECT_ACL, db, &thd->col_access, 0, 0,
                       is_schema_db(db)))
2194 2195 2196
        DBUG_RETURN(1);			        /* purecov: inspected */
      if (!thd->col_access && check_grant_db(thd,db))
      {
unknown's avatar
unknown committed
2197
	my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
2198 2199
                 thd->security_ctx->priv_user, thd->security_ctx->priv_host,
                 db);
2200 2201
	DBUG_RETURN(1);
      }
2202 2203 2204 2205 2206
      /*
        We need to do a copy to make this prepared statement safe if this
        was thd->db
      */
      lex->select_lex.db= thd->strdup(db);
2207 2208 2209 2210 2211 2212
      break;
    }
#endif
  case SCH_COLUMNS:
  case SCH_STATISTICS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2213 2214
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2215 2216 2217 2218 2219 2220
    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
2221 2222
      /* 'parent_lex' is used in init_query() so it must be before it. */
      sel->parent_lex= lex;
2223
      sel->init_query();
unknown's avatar
unknown committed
2224
      if (!sel->add_table_to_list(thd, table_ident, 0, 0, TL_READ, 
2225 2226 2227 2228 2229 2230
                                 (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 '_'
2231
      remove_escape(table_list->table_name);
2232
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
2233 2234
                       &table_list->grant.privilege, 0, 0,
                       test(table_list->schema_table)))
2235 2236 2237 2238 2239 2240 2241
        DBUG_RETURN(1);				/* purecov: inspected */
      if (grant_option && check_grant(thd, SELECT_ACL, table_list, 2,
                                      UINT_MAX, 0))
        DBUG_RETURN(1);
      break;
    }
#endif
2242 2243 2244
  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
2245 2246
  case SCH_PROCEDURES:
  case SCH_CHARSETS:
unknown's avatar
unknown committed
2247
  case SCH_ENGINES:
2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266
  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;
2267
  table_list->schema_table_reformed= 1;
2268 2269
  statistic_increment(thd->status_var.com_stat[lex->orig_sql_command],
                      &LOCK_status);
2270 2271 2272 2273
  DBUG_RETURN(0);
}


2274 2275
/*
  Read query from packet and store in thd->query
2276
  Used in COM_QUERY and COM_STMT_PREPARE
2277 2278 2279 2280 2281 2282 2283

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
unknown's avatar
unknown committed
2284 2285
    FALSE ok
    TRUE  error;  In this case thd->fatal_error is set
2286 2287
*/

2288
bool alloc_query(THD *thd, const char *packet, uint packet_length)
2289 2290
{
  packet_length--;				// Remove end null
2291
  /* Remove garbage at start and end of query */
unknown's avatar
unknown committed
2292
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
2293 2294 2295 2296
  {
    packet++;
    packet_length--;
  }
2297
  const char *pos= packet + packet_length;     // Point at end null
unknown's avatar
unknown committed
2298
  while (packet_length > 0 &&
unknown's avatar
unknown committed
2299
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
2300 2301 2302 2303 2304
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
2305
  thd->query_length= 0;                        // Extra safety: Avoid races
2306 2307
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
2308 2309
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
unknown's avatar
unknown committed
2310
    return TRUE;
2311 2312
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
2313 2314 2315 2316

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

unknown's avatar
unknown committed
2318
  return FALSE;
2319 2320
}

2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
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;
  thd->one_shot_set= 0;
}

2337

unknown's avatar
unknown committed
2338 2339 2340 2341 2342
/****************************************************************************
** mysql_execute_command
** Execute command saved in thd and current_lex->sql_command
****************************************************************************/

unknown's avatar
unknown committed
2343
bool
2344
mysql_execute_command(THD *thd)
unknown's avatar
unknown committed
2345
{
unknown's avatar
unknown committed
2346
  bool	res= FALSE;
unknown's avatar
unknown committed
2347
  int result= 0;
unknown's avatar
unknown committed
2348
  LEX	*lex= thd->lex;
unknown's avatar
unknown committed
2349
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
unknown's avatar
unknown committed
2350
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
2351
  /* first table of first SELECT_LEX */
unknown's avatar
unknown committed
2352
  TABLE_LIST *first_table= (TABLE_LIST*) select_lex->table_list.first;
unknown's avatar
VIEW  
unknown committed
2353 2354 2355
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
2356
  SELECT_LEX_UNIT *unit= &lex->unit;
2357
  /* Saved variable value */
unknown's avatar
unknown committed
2358
  DBUG_ENTER("mysql_execute_command");
2359
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
2360

unknown's avatar
VIEW  
unknown committed
2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376
  /*
    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();
2377
  /* should be assigned after making first tables same */
unknown's avatar
VIEW  
unknown committed
2378
  all_tables= lex->query_tables;
2379 2380 2381 2382
  /* 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
2383

2384 2385 2386 2387 2388
  /*
    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.
2389
    Don't reset warnings when executing a stored routine.
2390
  */
2391
  if ((all_tables || &lex->select_lex != lex->all_selects_list ||
2392
       lex->sroutines.records) && !thd->spcont ||
2393
      lex->time_zone_tables_used)
unknown's avatar
unknown committed
2394
    mysql_reset_errors(thd, 0);
2395

unknown's avatar
SCRUM  
unknown committed
2396
#ifdef HAVE_REPLICATION
2397
  if (unlikely(thd->slave_thread))
2398
  {
unknown's avatar
unknown committed
2399
    /*
unknown's avatar
unknown committed
2400 2401
      Check if statment should be skipped because of slave filtering
      rules
2402 2403

      Exceptions are:
unknown's avatar
unknown committed
2404 2405
      - UPDATE MULTI: For this statement, we want to check the filtering
        rules later in the code
2406
      - SET: we always execute it (Not that many SET commands exists in
unknown's avatar
unknown committed
2407 2408
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
2409 2410
      - 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
2411
    */
unknown's avatar
unknown committed
2412 2413
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
	!(lex->sql_command == SQLCOM_SET_OPTION) &&
2414
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2415
          lex->drop_temporary && lex->drop_if_exists) &&
unknown's avatar
Merge  
unknown committed
2416
        all_tables_not_ok(thd, all_tables))
unknown's avatar
unknown committed
2417 2418
    {
      /* we warn the slave SQL thread */
unknown's avatar
unknown committed
2419
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2420
      reset_one_shot_variables(thd);
2421
      DBUG_RETURN(0);
unknown's avatar
unknown committed
2422
    }
2423
  }
2424
  else
2425
  {
2426
#endif /* HAVE_REPLICATION */
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444
    /*
      When option readonly is set deny operations which change non-temporary
      tables. Except for the replication thread and the 'super' users.
    */
    if (opt_readonly &&
	!(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_UPDATE_MULTI) &&
	 some_non_temp_table_to_be_updated(thd, all_tables)))
    {
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
      DBUG_RETURN(-1);
    }
#ifdef HAVE_REPLICATION
  } /* endif unlikely slave */
#endif
2445 2446 2447
  if(lex->orig_sql_command == SQLCOM_END)
    statistic_increment(thd->status_var.com_stat[lex->sql_command],
                        &LOCK_status);
2448

2449 2450 2451
  if (lex->binlog_row_based_if_mixed)
    thd->set_current_stmt_binlog_row_based_if_mixed();

unknown's avatar
unknown committed
2452 2453 2454
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2455 2456 2457 2458
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
2459 2460
	param->select_limit=
          new Item_int((ulonglong)thd->variables.select_limit);
2461 2462
    }

2463
    select_result *result=lex->result;
unknown's avatar
VIEW  
unknown committed
2464
    if (all_tables)
unknown's avatar
unknown committed
2465
    {
2466
      if (lex->orig_sql_command != SQLCOM_SHOW_STATUS_PROC &&
2467 2468
          lex->orig_sql_command != SQLCOM_SHOW_STATUS_FUNC &&
          lex->orig_sql_command != SQLCOM_SHOW_EVENTS)
2469 2470 2471 2472
        res= check_table_access(thd,
                                lex->exchange ? SELECT_ACL | FILE_ACL :
                                SELECT_ACL,
                                all_tables, 0);
2473 2474 2475
      else if (lex->orig_sql_command == SQLCOM_SHOW_EVENTS)
        res= check_access(thd, EVENT_ACL, thd->lex->select_lex.db, 0, 0, 0,
                       is_schema_db(thd->lex->select_lex.db));
unknown's avatar
unknown committed
2476 2477
    }
    else
unknown's avatar
VIEW  
unknown committed
2478 2479
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
2480
			any_db, 0, 0, 0, 0);
unknown's avatar
unknown committed
2481
    if (res)
unknown's avatar
unknown committed
2482
      goto error;
unknown's avatar
unknown committed
2483

unknown's avatar
VIEW  
unknown committed
2484
    if (!(res= open_and_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
2485
    {
unknown's avatar
unknown committed
2486
      if (lex->describe)
unknown's avatar
unknown committed
2487
      {
2488 2489 2490 2491 2492 2493
        /*
          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.
        */
2494
	if (!(result= new select_send()))
2495
	  goto error;
2496 2497
	else
	  thd->send_explain_fields(result);
unknown's avatar
unknown committed
2498
	res= mysql_explain_union(thd, &thd->lex->unit, result);
unknown's avatar
unknown committed
2499 2500 2501 2502 2503
	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
2504
	  thd->lex->unit.print(&str);
unknown's avatar
unknown committed
2505 2506 2507 2508
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2509
	result->send_eof();
2510
        delete result;
unknown's avatar
unknown committed
2511 2512 2513
      }
      else
      {
2514
	if (!result && !(result= new select_send()))
unknown's avatar
unknown committed
2515
          goto error;
unknown's avatar
VIEW  
unknown committed
2516
	query_cache_store_query(thd, all_tables);
2517
	res= handle_select(thd, lex, result, 0);
2518 2519
        if (result != lex->result)
          delete result;
unknown's avatar
unknown committed
2520
      }
unknown's avatar
unknown committed
2521
    }
unknown's avatar
unknown committed
2522 2523
    break;
  }
unknown's avatar
unknown committed
2524
  case SQLCOM_PREPARE:
2525
  {
2526
    mysql_sql_stmt_prepare(thd);
unknown's avatar
unknown committed
2527 2528 2529 2530
    break;
  }
  case SQLCOM_EXECUTE:
  {
2531
    mysql_sql_stmt_execute(thd);
unknown's avatar
unknown committed
2532 2533 2534 2535
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2536
    mysql_sql_stmt_close(thd);
unknown's avatar
unknown committed
2537 2538
    break;
  }
unknown's avatar
unknown committed
2539
  case SQLCOM_DO:
2540 2541
    if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
        open_and_lock_tables(thd, all_tables))
unknown's avatar
unknown committed
2542
      goto error;
unknown's avatar
unknown committed
2543 2544

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

2547
  case SQLCOM_EMPTY_QUERY:
2548
    send_ok(thd);
2549 2550
    break;

unknown's avatar
unknown committed
2551 2552 2553 2554
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2555
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2556
  case SQLCOM_PURGE:
2557
  {
unknown's avatar
unknown committed
2558
    if (check_global_access(thd, SUPER_ACL))
2559
      goto error;
unknown's avatar
unknown committed
2560
    /* PURGE MASTER LOGS TO 'file' */
2561 2562 2563
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2564 2565
  case SQLCOM_PURGE_BEFORE:
  {
2566 2567
    Item *it;

2568 2569
    if (check_global_access(thd, SUPER_ACL))
      goto error;
unknown's avatar
unknown committed
2570
    /* PURGE MASTER LOGS BEFORE 'data' */
2571
    it= (Item *)lex->value_list.head();
2572
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
unknown's avatar
unknown committed
2573
        it->check_cols(1))
2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
    {
      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());
2585 2586
    break;
  }
2587
#endif
unknown's avatar
unknown committed
2588 2589
  case SQLCOM_SHOW_WARNS:
  {
2590 2591
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2592 2593 2594
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
unknown's avatar
unknown committed
2595 2596 2597 2598
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2599 2600
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
unknown's avatar
unknown committed
2601 2602
    break;
  }
unknown's avatar
unknown committed
2603 2604
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
2605
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2606
      goto error;
2607
    /* This query don't work now. See comment in repl_failsafe.cc */
unknown's avatar
unknown committed
2608
#ifndef WORKING_NEW_MASTER
unknown's avatar
unknown committed
2609 2610
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "SHOW NEW MASTER");
    goto error;
unknown's avatar
unknown committed
2611
#else
unknown's avatar
unknown committed
2612 2613
    res = show_new_master(thd);
    break;
unknown's avatar
unknown committed
2614
#endif
unknown's avatar
unknown committed
2615
  }
2616

unknown's avatar
unknown committed
2617
#ifdef HAVE_REPLICATION
2618 2619
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2620
    if (check_global_access(thd, REPL_SLAVE_ACL))
2621 2622 2623 2624
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2625 2626
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2627
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2628
      goto error;
2629
    res = mysql_show_binlog_events(thd);
unknown's avatar
unknown committed
2630 2631
    break;
  }
2632 2633
#endif

unknown's avatar
unknown committed
2634
  case SQLCOM_BACKUP_TABLE:
2635
  {
unknown's avatar
VIEW  
unknown committed
2636 2637 2638
    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
2639
	check_global_access(thd, FILE_ACL))
2640
      goto error; /* purecov: inspected */
2641
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2642
    res = mysql_backup_table(thd, first_table);
2643
    select_lex->table_list.first= (byte*) first_table;
2644
    lex->query_tables=all_tables;
2645 2646
    break;
  }
unknown's avatar
unknown committed
2647
  case SQLCOM_RESTORE_TABLE:
2648
  {
unknown's avatar
VIEW  
unknown committed
2649 2650 2651
    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
2652
	check_global_access(thd, FILE_ACL))
2653
      goto error; /* purecov: inspected */
2654
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2655
    res = mysql_restore_table(thd, first_table);
2656
    select_lex->table_list.first= (byte*) first_table;
2657
    lex->query_tables=all_tables;
2658 2659
    break;
  }
unknown's avatar
unknown committed
2660 2661
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
unknown's avatar
VIEW  
unknown committed
2662 2663 2664
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
2665 2666
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2667
      goto error;
2668
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
unknown's avatar
unknown committed
2669 2670
    break;
  }
unknown's avatar
unknown committed
2671 2672
  case SQLCOM_PRELOAD_KEYS:
  {
unknown's avatar
VIEW  
unknown committed
2673 2674 2675
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
2676 2677
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
2678
      goto error;
unknown's avatar
VIEW  
unknown committed
2679
    res = mysql_preload_keys(thd, first_table);
unknown's avatar
unknown committed
2680 2681
    break;
  }
unknown's avatar
unknown committed
2682
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2683
  case SQLCOM_CHANGE_MASTER:
2684
  {
unknown's avatar
unknown committed
2685
    if (check_global_access(thd, SUPER_ACL))
2686
      goto error;
2687
    pthread_mutex_lock(&LOCK_active_mi);
2688
    res = change_master(thd,active_mi);
2689
    pthread_mutex_unlock(&LOCK_active_mi);
2690 2691
    break;
  }
unknown's avatar
unknown committed
2692
  case SQLCOM_SHOW_SLAVE_STAT:
2693
  {
2694 2695
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2696
      goto error;
2697
    pthread_mutex_lock(&LOCK_active_mi);
2698
    res = show_master_info(thd,active_mi);
2699
    pthread_mutex_unlock(&LOCK_active_mi);
2700 2701
    break;
  }
unknown's avatar
unknown committed
2702
  case SQLCOM_SHOW_MASTER_STAT:
2703
  {
2704 2705
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2706 2707 2708 2709
      goto error;
    res = show_binlog_info(thd);
    break;
  }
unknown's avatar
unknown committed
2710

2711
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
2712
    if (check_global_access(thd, SUPER_ACL))
2713
      goto error;
2714
    if (end_active_trans(thd))
unknown's avatar
unknown committed
2715
      goto error;
2716 2717
    else
      res = load_master_data(thd);
2718
    break;
unknown's avatar
unknown committed
2719
#endif /* HAVE_REPLICATION */
2720
  case SQLCOM_SHOW_ENGINE_STATUS:
unknown's avatar
unknown committed
2721
    {
2722
      if (check_global_access(thd, SUPER_ACL))
2723 2724
        goto error;
      res = ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_STATUS);
unknown's avatar
unknown committed
2725 2726
      break;
    }
2727
  case SQLCOM_SHOW_ENGINE_MUTEX:
unknown's avatar
unknown committed
2728 2729
    {
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2730
        goto error;
2731
      res = ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_MUTEX);
unknown's avatar
unknown committed
2732 2733
      break;
    }
unknown's avatar
unknown committed
2734
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2735
  case SQLCOM_LOAD_MASTER_TABLE:
2736
  {
unknown's avatar
VIEW  
unknown committed
2737 2738 2739 2740
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (!first_table->db)
      first_table->db= thd->db;
    if (check_access(thd, CREATE_ACL, first_table->db,
2741 2742
		     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2743 2744 2745 2746
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
unknown's avatar
VIEW  
unknown committed
2747
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2748
	goto error;
unknown's avatar
unknown committed
2749
    }
2750
    if (strlen(first_table->table_name) > NAME_LEN)
unknown's avatar
unknown committed
2751
    {
2752
      my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name);
unknown's avatar
unknown committed
2753 2754
      break;
    }
2755
    pthread_mutex_lock(&LOCK_active_mi);
2756 2757 2758 2759
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2760
    if (!fetch_master_table(thd, first_table->db, first_table->table_name,
2761
			    active_mi, 0, 0))
2762
    {
2763
      send_ok(thd);
2764
    }
2765
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2766
    break;
2767
  }
unknown's avatar
unknown committed
2768
#endif /* HAVE_REPLICATION */
2769

unknown's avatar
unknown committed
2770
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
2771
  {
2772
    /* If CREATE TABLE of non-temporary table, do implicit commit */
2773 2774 2775 2776 2777 2778 2779 2780 2781 2782
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
    {
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
    else 
    {
unknown's avatar
unknown committed
2783 2784
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
2785
    }
unknown's avatar
VIEW  
unknown committed
2786 2787 2788 2789 2790
    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
2791

unknown's avatar
VIEW  
unknown committed
2792
    if ((res= create_table_precheck(thd, select_tables, create_table)))
unknown's avatar
unknown committed
2793
      goto end_with_restore_list;
unknown's avatar
unknown committed
2794

2795 2796 2797
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
2798
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
2799
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
2800
			   create_table->table_name) ||
unknown's avatar
VIEW  
unknown committed
2801
	append_file_to_dir(thd, &lex->create_info.index_file_name,
2802
			   create_table->table_name))
unknown's avatar
unknown committed
2803
      goto end_with_restore_list;
2804
#endif
2805
    /*
2806
      If we are using SET CHARSET without DEFAULT, add an implicit
2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817
      DEFAULT to not confuse old users. (This may change).
    */
    if ((lex->create_info.used_fields & 
	 (HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) ==
	HA_CREATE_USED_CHARSET)
    {
      lex->create_info.used_fields&= ~HA_CREATE_USED_CHARSET;
      lex->create_info.used_fields|= HA_CREATE_USED_DEFAULT_CHARSET;
      lex->create_info.default_table_charset= lex->create_info.table_charset;
      lex->create_info.table_charset= 0;
    }
2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832
    /*
      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.
    */
    if (wait_if_global_read_lock(thd, 0, 1))
    {
unknown's avatar
unknown committed
2833 2834
      res= 1;
      goto end_with_restore_list;
2835
    }
2836
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
2837 2838
    {
      select_result *result;
2839

2840
      select_lex->options|= SELECT_NO_UNLOCK;
2841
      unit->set_limit(select_lex);
2842

unknown's avatar
VIEW  
unknown committed
2843
      if (!(res= open_and_lock_tables(thd, select_tables)))
2844
      {
2845 2846 2847 2848
        /*
          Is table which we are changing used somewhere in other parts
          of query
        */
2849
        if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
2850
        {
2851
          TABLE_LIST *duplicate;
2852
          if ((duplicate= unique_table(thd, create_table, select_tables)))
2853 2854 2855 2856 2857
          {
            update_non_unique_table_error(create_table, "CREATE", duplicate);
            res= 1;
            goto end_with_restart_wait;
          }
2858
        }
unknown's avatar
unknown committed
2859 2860 2861 2862 2863 2864 2865 2866
        /* If we create merge table, we have to test tables in merge, too */
        if (lex->create_info.used_fields & HA_CREATE_USED_UNION)
        {
          TABLE_LIST *tab;
          for (tab= (TABLE_LIST*) lex->create_info.merge_list.first;
               tab;
               tab= tab->next_local)
          {
2867
            TABLE_LIST *duplicate;
2868
            if ((duplicate= unique_table(thd, tab, select_tables)))
unknown's avatar
unknown committed
2869
            {
2870
              update_non_unique_table_error(tab, "CREATE", duplicate);
unknown's avatar
unknown committed
2871 2872
              res= 1;
              goto end_with_restart_wait;
unknown's avatar
unknown committed
2873 2874 2875
            }
          }
        }
2876

unknown's avatar
VIEW  
unknown committed
2877 2878 2879 2880 2881
        if ((result= new select_create(create_table,
				       &lex->create_info,
				       lex->create_list,
				       lex->key_list,
				       select_lex->item_list,
2882 2883
				       lex->duplicates,
				       lex->ignore)))
2884 2885 2886 2887 2888
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
2889
          res= handle_select(thd, lex, result, 0);
2890
          delete result;
2891
        }
unknown's avatar
unknown committed
2892
	/* reset for PS */
2893 2894
	lex->create_list.empty();
	lex->key_list.empty();
2895 2896
      }
    }
unknown's avatar
unknown committed
2897
    else
unknown's avatar
unknown committed
2898
    {
unknown's avatar
unknown committed
2899
      /* regular create */
unknown's avatar
unknown committed
2900
      if (lex->like_name)
unknown's avatar
unknown committed
2901
        res= mysql_create_like_table(thd, create_table, &lex->create_info, 
unknown's avatar
unknown committed
2902
                                     lex->like_name); 
unknown's avatar
unknown committed
2903
      else
2904
      {
unknown's avatar
VIEW  
unknown committed
2905
        res= mysql_create_table(thd, create_table->db,
2906
				create_table->table_name, &lex->create_info,
unknown's avatar
VIEW  
unknown committed
2907
				lex->create_list,
unknown's avatar
unknown committed
2908
				lex->key_list, 0, 0);
2909
      }
unknown's avatar
unknown committed
2910
      if (!res)
2911
	send_ok(thd);
unknown's avatar
unknown committed
2912
    }
2913

unknown's avatar
unknown committed
2914
end_with_restart_wait:
2915 2916 2917 2918 2919 2920
    /*
      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);

unknown's avatar
unknown committed
2921
    /* put tables back for PS rexecuting */
unknown's avatar
unknown committed
2922
end_with_restore_list:
unknown's avatar
VIEW  
unknown committed
2923
    lex->link_first_table_back(create_table, link_to_local);
unknown's avatar
unknown committed
2924
    break;
unknown's avatar
unknown committed
2925
  }
unknown's avatar
unknown committed
2926
  case SQLCOM_CREATE_INDEX:
unknown's avatar
VIEW  
unknown committed
2927 2928
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
unknown's avatar
unknown committed
2929
      goto error; /* purecov: inspected */
2930
    thd->enable_slow_log= opt_log_slow_admin_statements;
2931
    if (end_active_trans(thd))
unknown's avatar
unknown committed
2932
      goto error;
2933
    else
unknown's avatar
VIEW  
unknown committed
2934
      res = mysql_create_index(thd, first_table, lex->key_list);
unknown's avatar
unknown committed
2935 2936
    break;

unknown's avatar
unknown committed
2937
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2938
  case SQLCOM_SLAVE_START:
2939
  {
2940
    pthread_mutex_lock(&LOCK_active_mi);
2941
    start_slave(thd,active_mi,1 /* net report*/);
2942
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2943
    break;
2944
  }
unknown's avatar
unknown committed
2945
  case SQLCOM_SLAVE_STOP:
2946 2947 2948 2949 2950 2951
  /*
    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,
2952
      so it waits for the client thread because t is locked by it.
2953
    - then the client thread does SLAVE STOP.
2954 2955
      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.
2956 2957 2958
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
2959
  if (thd->locked_tables || thd->active_transaction() || thd->global_read_lock)
2960
  {
2961 2962
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
2963
    goto error;
2964
  }
2965
  {
2966
    pthread_mutex_lock(&LOCK_active_mi);
2967
    stop_slave(thd,active_mi,1/* net report*/);
2968
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2969
    break;
2970
  }
unknown's avatar
unknown committed
2971
#endif /* HAVE_REPLICATION */
2972

unknown's avatar
unknown committed
2973
  case SQLCOM_ALTER_TABLE:
unknown's avatar
VIEW  
unknown committed
2974
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2975
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
2976 2977
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
2978
    goto error;
unknown's avatar
unknown committed
2979 2980
#else
    {
unknown's avatar
unknown committed
2981
      ulong priv=0;
unknown's avatar
unknown committed
2982
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
unknown's avatar
unknown committed
2983
      {
2984
	my_error(ER_WRONG_TABLE_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
2985
        goto error;
unknown's avatar
unknown committed
2986
      }
2987
      if (!select_lex->db)
2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
      {
        /*
          In the case of ALTER TABLE ... RENAME we should supply the
          default database if the new name is not explicitly qualified
          by a database. (Bug #11493)
        */
        if (lex->alter_info.flags & ALTER_RENAME)
        {
          if (! thd->db)
          {
unknown's avatar
unknown committed
2998
            my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
2999 3000 3001 3002 3003
            goto error;
          }
          select_lex->db= thd->db;
        }
        else
3004
          select_lex->db= first_table->db;
3005
      }
unknown's avatar
VIEW  
unknown committed
3006
      if (check_access(thd, ALTER_ACL, first_table->db,
3007 3008 3009 3010
		       &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
3011
	  check_merge_table_access(thd, first_table->db,
3012 3013 3014
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
3015 3016
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
3017
	if (check_grant(thd, ALTER_ACL, all_tables, 0, UINT_MAX, 0))
unknown's avatar
unknown committed
3018 3019 3020 3021 3022
	  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));
3023
	  tmp_table.table_name=lex->name;
3024
	  tmp_table.db=select_lex->db;
unknown's avatar
unknown committed
3025
	  tmp_table.grant.privilege=priv;
unknown's avatar
unknown committed
3026 3027
	  if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0,
			  UINT_MAX, 0))
unknown's avatar
unknown committed
3028 3029 3030
	    goto error;
	}
      }
3031 3032
      /* Don't yet allow changing of symlinks with ALTER TABLE */
      lex->create_info.data_file_name=lex->create_info.index_file_name=0;
unknown's avatar
unknown committed
3033
      /* ALTER TABLE ends previous transaction */
3034
      if (end_active_trans(thd))
unknown's avatar
unknown committed
3035
	goto error;
unknown's avatar
unknown committed
3036
      else
unknown's avatar
unknown committed
3037
      {
3038
        thd->enable_slow_log= opt_log_slow_admin_statements;
3039
	res= mysql_alter_table(thd, select_lex->db, lex->name,
unknown's avatar
unknown committed
3040
			       &lex->create_info,
unknown's avatar
VIEW  
unknown committed
3041
			       first_table, lex->create_list,
3042
			       lex->key_list,
3043
			       select_lex->order_list.elements,
3044
                               (ORDER *) select_lex->order_list.first,
unknown's avatar
unknown committed
3045 3046
			       lex->duplicates, lex->ignore, &lex->alter_info,
                               1);
unknown's avatar
unknown committed
3047
      }
unknown's avatar
unknown committed
3048 3049
      break;
    }
unknown's avatar
unknown committed
3050
#endif /*DONT_ALLOW_SHOW_COMMANDS*/
unknown's avatar
unknown committed
3051
  case SQLCOM_RENAME_TABLE:
unknown's avatar
unknown committed
3052
  {
unknown's avatar
VIEW  
unknown committed
3053
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3054
    TABLE_LIST *table;
unknown's avatar
VIEW  
unknown committed
3055
    if (check_db_used(thd, all_tables))
unknown's avatar
unknown committed
3056
      goto error;
unknown's avatar
VIEW  
unknown committed
3057
    for (table= first_table; table; table= table->next_local->next_local)
unknown's avatar
unknown committed
3058
    {
unknown's avatar
unknown committed
3059
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
3060
		       &table->grant.privilege,0,0, test(table->schema_table)) ||
unknown's avatar
VIEW  
unknown committed
3061
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next_local->db,
3062 3063
		       &table->next_local->grant.privilege, 0, 0,
                       test(table->next_local->schema_table)))
unknown's avatar
unknown committed
3064 3065 3066
	goto error;
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
3067
	TABLE_LIST old_list, new_list;
unknown's avatar
unknown committed
3068 3069 3070 3071
	/*
	  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
3072 3073 3074 3075
	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,
3076
			    INSERT_ACL | CREATE_ACL) &&
unknown's avatar
VIEW  
unknown committed
3077
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0, 1, 0)))
unknown's avatar
unknown committed
3078 3079 3080
	  goto error;
      }
    }
unknown's avatar
VIEW  
unknown committed
3081
    query_cache_invalidate3(thd, first_table, 0);
unknown's avatar
unknown committed
3082
    if (end_active_trans(thd) || mysql_rename_tables(thd, first_table, 0))
unknown's avatar
unknown committed
3083
      goto error;
unknown's avatar
unknown committed
3084
    break;
unknown's avatar
unknown committed
3085
  }
3086
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3087 3088
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3089 3090
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3091
    goto error;
unknown's avatar
unknown committed
3092 3093
#else
    {
unknown's avatar
unknown committed
3094
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
3095 3096 3097 3098
	goto error;
      res = show_binlogs(thd);
      break;
    }
unknown's avatar
unknown committed
3099
#endif
3100
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
3101
  case SQLCOM_SHOW_CREATE:
unknown's avatar
VIEW  
unknown committed
3102
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3103
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3104 3105
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3106
    goto error;
unknown's avatar
unknown committed
3107
#else
unknown's avatar
unknown committed
3108
    {
3109 3110 3111 3112
      /* Ignore temporary tables if this is "SHOW CREATE VIEW" */
      if (lex->only_view)
        first_table->skip_temporary= 1;

unknown's avatar
VIEW  
unknown committed
3113 3114
      if (check_db_used(thd, all_tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, first_table->db,
3115 3116
		       &first_table->grant.privilege, 0, 0, 
                       test(first_table->schema_table)))
unknown's avatar
unknown committed
3117
	goto error;
unknown's avatar
unknown committed
3118
      if (grant_option && check_grant(thd, SELECT_ACL, all_tables, 2, UINT_MAX, 0))
3119
	goto error;
unknown's avatar
unknown committed
3120
      res= mysqld_show_create(thd, first_table);
unknown's avatar
unknown committed
3121 3122
      break;
    }
unknown's avatar
unknown committed
3123
#endif
3124 3125
  case SQLCOM_CHECKSUM:
  {
unknown's avatar
VIEW  
unknown committed
3126 3127 3128
    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))
3129
      goto error; /* purecov: inspected */
unknown's avatar
VIEW  
unknown committed
3130
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
3131 3132
    break;
  }
unknown's avatar
unknown committed
3133
  case SQLCOM_REPAIR:
3134
  {
unknown's avatar
VIEW  
unknown committed
3135 3136 3137
    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))
3138
      goto error; /* purecov: inspected */
3139
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3140
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
3141 3142 3143 3144 3145
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3146
	thd->clear_error(); // No binlog error generated
3147
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3148 3149 3150
        mysql_bin_log.write(&qinfo);
      }
    }
3151
    select_lex->table_list.first= (byte*) first_table;
3152
    lex->query_tables=all_tables;
3153 3154
    break;
  }
unknown's avatar
unknown committed
3155
  case SQLCOM_CHECK:
3156
  {
unknown's avatar
VIEW  
unknown committed
3157 3158 3159
    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))
3160
      goto error; /* purecov: inspected */
3161
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3162
    res = mysql_check_table(thd, first_table, &lex->check_opt);
3163
    select_lex->table_list.first= (byte*) first_table;
3164
    lex->query_tables=all_tables;
3165 3166
    break;
  }
unknown's avatar
unknown committed
3167 3168
  case SQLCOM_ANALYZE:
  {
unknown's avatar
VIEW  
unknown committed
3169 3170 3171
    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
3172
      goto error; /* purecov: inspected */
3173
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3174
    res = mysql_analyze_table(thd, first_table, &lex->check_opt);
3175 3176 3177 3178 3179
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3180
	thd->clear_error(); // No binlog error generated
3181
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3182 3183 3184
        mysql_bin_log.write(&qinfo);
      }
    }
3185
    select_lex->table_list.first= (byte*) first_table;
3186
    lex->query_tables=all_tables;
unknown's avatar
unknown committed
3187
    break;
unknown's avatar
unknown committed
3188
  }
3189

unknown's avatar
unknown committed
3190 3191
  case SQLCOM_OPTIMIZE:
  {
unknown's avatar
VIEW  
unknown committed
3192 3193 3194
    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
3195
      goto error; /* purecov: inspected */
3196
    thd->enable_slow_log= opt_log_slow_admin_statements;
3197
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
unknown's avatar
VIEW  
unknown committed
3198 3199
      mysql_recreate_table(thd, first_table, 1) :
      mysql_optimize_table(thd, first_table, &lex->check_opt);
3200 3201 3202 3203 3204
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3205
	thd->clear_error(); // No binlog error generated
3206
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3207 3208 3209
        mysql_bin_log.write(&qinfo);
      }
    }
3210
    select_lex->table_list.first= (byte*) first_table;
3211
    lex->query_tables=all_tables;
unknown's avatar
unknown committed
3212 3213 3214
    break;
  }
  case SQLCOM_UPDATE:
unknown's avatar
VIEW  
unknown committed
3215 3216
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (update_precheck(thd, all_tables))
unknown's avatar
unknown committed
3217
      break;
3218 3219
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
unknown's avatar
unknown committed
3220 3221 3222 3223 3224 3225
    res= (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,
3226
                               unit->select_limit_cnt,
3227
                               lex->duplicates, lex->ignore));
3228
    /* mysql_update return 2 if we need to switch to multi-update */
unknown's avatar
unknown committed
3229
    if (result != 2)
3230
      break;
3231
  case SQLCOM_UPDATE_MULTI:
unknown's avatar
unknown committed
3232 3233 3234 3235
  {
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    /* if we switched from normal update, rights are checked */
    if (result != 2)
3236
    {
unknown's avatar
unknown committed
3237 3238 3239 3240 3241
      if ((res= multi_update_precheck(thd, all_tables)))
        break;
    }
    else
      res= 0;
unknown's avatar
unknown committed
3242

3243
    res= mysql_multi_update_prepare(thd);
unknown's avatar
unknown committed
3244

3245
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3246
    /* Check slave filtering rules */
3247
    if (unlikely(thd->slave_thread))
unknown's avatar
unknown committed
3248
    {
3249 3250
      if (all_tables_not_ok(thd, all_tables))
      {
3251 3252 3253 3254 3255
        if (res!= 0)
        {
          res= 0;             /* don't care of prev failure  */
          thd->clear_error(); /* filters are of highest prior */
        }
3256 3257 3258 3259
        /* we warn the slave SQL thread */
        my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
        break;
      }
3260 3261
      if (res)
        break;
unknown's avatar
unknown committed
3262
    }
3263 3264
    else
    {
3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277
#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
3278

unknown's avatar
unknown committed
3279 3280 3281 3282 3283 3284
    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
3285
    break;
unknown's avatar
unknown committed
3286
  }
unknown's avatar
unknown committed
3287
  case SQLCOM_REPLACE:
3288 3289
  case SQLCOM_INSERT:
  {
unknown's avatar
VIEW  
unknown committed
3290
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3291
    if ((res= insert_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3292
      break;
3293 3294
    /* Skip first table, which is the table we are inserting in */
    select_lex->context.table_list= first_table->next_local;
unknown's avatar
VIEW  
unknown committed
3295
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
unknown's avatar
unknown committed
3296
		      lex->update_list, lex->value_list,
3297
                      lex->duplicates, lex->ignore);
unknown's avatar
VIEW  
unknown committed
3298 3299
    if (first_table->view && !first_table->contain_auto_increment)
      thd->last_insert_id= 0; // do not show last insert ID if VIEW have not it
unknown's avatar
unknown committed
3300
    break;
3301
  }
unknown's avatar
unknown committed
3302 3303 3304
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
unknown's avatar
unknown committed
3305
    select_result *result;
unknown's avatar
VIEW  
unknown committed
3306
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3307
    if ((res= insert_precheck(thd, all_tables)))
3308
      break;
unknown's avatar
unknown committed
3309

3310
    /* Fix lock for first table */
unknown's avatar
VIEW  
unknown committed
3311 3312
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
3313

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

3317
    unit->set_limit(select_lex);
unknown's avatar
VIEW  
unknown committed
3318
    if (!(res= open_and_lock_tables(thd, all_tables)))
3319
    {
3320
      /* Skip first table, which is the table we are inserting in */
unknown's avatar
unknown committed
3321 3322
      TABLE_LIST *second_table= first_table->next_local;
      select_lex->table_list.first= (byte*) second_table;
3323 3324
      select_lex->context.table_list= 
        select_lex->context.first_name_resolution_table= second_table;
3325 3326 3327
      res= mysql_insert_select_prepare(thd);
      if (!res && (result= new select_insert(first_table, first_table->table,
                                             &lex->field_list,
3328 3329
                                             &lex->update_list,
                                             &lex->value_list,
3330
                                             lex->duplicates, lex->ignore)))
3331
      {
unknown's avatar
unknown committed
3332 3333 3334 3335 3336 3337 3338
        /*
          Skip first table, which is the table we are inserting in.
          Below we set context.table_list again because the call above to
          mysql_insert_select_prepare() calls resolve_in_table_list_only(),
          which in turn resets context.table_list and
          context.first_name_resolution_table.
        */
3339 3340
        select_lex->context.table_list= 
          select_lex->context.first_name_resolution_table= second_table;
3341
	res= handle_select(thd, lex, result, OPTION_SETUP_TABLES_DONE);
3342 3343
        delete result;
      }
3344
      /* revert changes for SP */
unknown's avatar
unknown committed
3345
      select_lex->table_list.first= (byte*) first_table;
3346
    }
unknown's avatar
VIEW  
unknown committed
3347 3348 3349

    if (first_table->view && !first_table->contain_auto_increment)
      thd->last_insert_id= 0; // do not show last insert ID if VIEW have not it
unknown's avatar
unknown committed
3350 3351
    break;
  }
3352
  case SQLCOM_TRUNCATE:
3353 3354 3355 3356 3357
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
VIEW  
unknown committed
3358 3359
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
unknown's avatar
unknown committed
3360
      goto error;
3361 3362 3363 3364
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
3365
    if ((thd->locked_tables && !lex->sphead) || thd->active_transaction())
3366
    {
unknown's avatar
unknown committed
3367 3368
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3369 3370
      goto error;
    }
unknown's avatar
VIEW  
unknown committed
3371

unknown's avatar
unknown committed
3372
    res= mysql_truncate(thd, first_table, 0);
3373
    break;
unknown's avatar
unknown committed
3374
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
3375
  {
unknown's avatar
VIEW  
unknown committed
3376 3377
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= delete_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3378
      break;
3379 3380
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
unknown's avatar
VIEW  
unknown committed
3381
    res = mysql_delete(thd, all_tables, select_lex->where,
3382
                       &select_lex->order_list,
unknown's avatar
unknown committed
3383 3384
                       unit->select_limit_cnt, select_lex->options,
                       FALSE);
unknown's avatar
unknown committed
3385 3386
    break;
  }
3387
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
3388
  {
unknown's avatar
VIEW  
unknown committed
3389
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3390 3391
    TABLE_LIST *aux_tables=
      (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
unknown's avatar
unknown committed
3392
    multi_delete *result;
unknown's avatar
unknown committed
3393

3394
    if ((res= multi_delete_precheck(thd, all_tables)))
3395
      break;
unknown's avatar
unknown committed
3396

unknown's avatar
unknown committed
3397
    /* condition will be TRUE on SP re-excuting */
3398 3399
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
unknown's avatar
unknown committed
3400
    if (add_item_to_list(thd, new Item_null()))
unknown's avatar
unknown committed
3401
      goto error;
3402

unknown's avatar
unknown committed
3403
    thd->proc_info="init";
unknown's avatar
VIEW  
unknown committed
3404 3405 3406 3407
    if ((res= open_and_lock_tables(thd, all_tables)))
      break;

    if ((res= mysql_multi_delete_prepare(thd)))
unknown's avatar
unknown committed
3408
      goto error;
3409

3410
    if (!thd->is_fatal_error && (result= new multi_delete(aux_tables,
3411
							  lex->table_count)))
unknown's avatar
unknown committed
3412
    {
3413 3414 3415
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3416
			select_lex->item_list,
unknown's avatar
unknown committed
3417
			select_lex->where,
3418
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
unknown's avatar
unknown committed
3419 3420
			(ORDER *)NULL,
			select_lex->options | thd->options |
3421 3422
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                        OPTION_SETUP_TABLES_DONE,
3423
			result, unit, select_lex);
3424
      delete result;
unknown's avatar
unknown committed
3425 3426
    }
    else
3427
      res= TRUE;                                // Error
unknown's avatar
unknown committed
3428 3429
    break;
  }
unknown's avatar
unknown committed
3430
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
3431
  {
unknown's avatar
VIEW  
unknown committed
3432
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3433 3434
    if (!lex->drop_temporary)
    {
unknown's avatar
VIEW  
unknown committed
3435
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
3436 3437
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
unknown's avatar
unknown committed
3438
        goto error;
3439
    }
unknown's avatar
unknown committed
3440
    else
unknown's avatar
unknown committed
3441 3442 3443 3444 3445 3446
    {
      /*
	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
3447 3448
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
unknown's avatar
unknown committed
3449 3450 3451
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
3452

unknown's avatar
unknown committed
3453 3454
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
unknown's avatar
unknown committed
3455
    }
unknown's avatar
VIEW  
unknown committed
3456 3457
    res= mysql_rm_table(thd, first_table, lex->drop_if_exists,
			lex->drop_temporary);
unknown's avatar
unknown committed
3458 3459
  }
  break;
unknown's avatar
unknown committed
3460
  case SQLCOM_DROP_INDEX:
unknown's avatar
VIEW  
unknown committed
3461 3462
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
unknown's avatar
unknown committed
3463
      goto error;				/* purecov: inspected */
3464
    if (end_active_trans(thd))
unknown's avatar
unknown committed
3465
      goto error;
3466
    else
unknown's avatar
VIEW  
unknown committed
3467
      res = mysql_drop_index(thd, first_table, &lex->alter_info);
unknown's avatar
unknown committed
3468 3469
    break;
  case SQLCOM_SHOW_PROCESSLIST:
3470 3471
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
3472
      break;
unknown's avatar
unknown committed
3473
    mysqld_list_processes(thd,
3474 3475 3476 3477
			  (thd->security_ctx->master_access & PROCESS_ACL ?
                           NullS :
                           thd->security_ctx->priv_user),
                          lex->verbose);
unknown's avatar
unknown committed
3478
    break;
unknown's avatar
unknown committed
3479 3480
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
unknown's avatar
unknown committed
3481
    break;
unknown's avatar
unknown committed
3482 3483 3484
  case SQLCOM_SHOW_AUTHORS:
    res= mysqld_show_authors(thd);
    break;
unknown's avatar
unknown committed
3485 3486 3487 3488 3489 3490
  case SQLCOM_SHOW_PRIVILEGES:
    res= mysqld_show_privileges(thd);
    break;
  case SQLCOM_SHOW_COLUMN_TYPES:
    res= mysqld_show_column_types(thd);
    break;
3491
  case SQLCOM_SHOW_ENGINE_LOGS:
unknown's avatar
unknown committed
3492
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3493 3494
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
3495
    goto error;
unknown's avatar
unknown committed
3496 3497
#else
    {
3498
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0,0))
unknown's avatar
unknown committed
3499
	goto error;
3500
      res= ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_LOGS);
unknown's avatar
unknown committed
3501 3502
      break;
    }
unknown's avatar
unknown committed
3503 3504
#endif
  case SQLCOM_CHANGE_DB:
3505 3506
    if (!mysql_change_db(thd,select_lex->db,FALSE))
      send_ok(thd);
unknown's avatar
unknown committed
3507
    break;
3508

unknown's avatar
unknown committed
3509 3510
  case SQLCOM_LOAD:
  {
unknown's avatar
VIEW  
unknown committed
3511
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3512
    uint privilege= (lex->duplicates == DUP_REPLACE ?
unknown's avatar
unknown committed
3513 3514
		     INSERT_ACL | DELETE_ACL : INSERT_ACL) |
                    (lex->local_file ? 0 : FILE_ACL);
3515

unknown's avatar
unknown committed
3516
    if (lex->local_file)
unknown's avatar
unknown committed
3517
    {
3518
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
3519
          !opt_local_infile)
3520
      {
unknown's avatar
unknown committed
3521
	my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
3522 3523
	goto error;
      }
unknown's avatar
unknown committed
3524
    }
unknown's avatar
unknown committed
3525 3526 3527 3528

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

unknown's avatar
VIEW  
unknown committed
3529
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
unknown's avatar
unknown committed
3530
                    lex->update_list, lex->value_list, lex->duplicates,
3531
                    lex->ignore, (bool) lex->local_file);
unknown's avatar
unknown committed
3532 3533
    break;
  }
3534

unknown's avatar
unknown committed
3535
  case SQLCOM_SET_OPTION:
3536 3537
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
3538
    if ((check_table_access(thd, SELECT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
3539 3540
	 open_and_lock_tables(thd, all_tables)))
      goto error;
3541 3542
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
unknown's avatar
unknown committed
3543 3544
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
      goto error;
3545 3546 3547 3548 3549 3550 3551 3552
    }
    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;
3553
      send_ok(thd);
3554
    }
unknown's avatar
unknown committed
3555
    break;
3556
  }
unknown's avatar
unknown committed
3557

unknown's avatar
unknown committed
3558
  case SQLCOM_UNLOCK_TABLES:
3559 3560 3561 3562 3563 3564
    /*
      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
3565
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
3566 3567
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
3568
      end_active_trans(thd);
unknown's avatar
unknown committed
3569
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3570 3571
    }
    if (thd->global_read_lock)
3572
      unlock_global_read_lock(thd);
3573
    send_ok(thd);
unknown's avatar
unknown committed
3574 3575
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
3576
    unlock_locked_tables(thd);
unknown's avatar
VIEW  
unknown committed
3577
    if (check_db_used(thd, all_tables) || end_active_trans(thd))
unknown's avatar
unknown committed
3578
      goto error;
unknown's avatar
VIEW  
unknown committed
3579
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3580
      goto error;
unknown's avatar
unknown committed
3581
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
3582
    thd->options|= OPTION_TABLE_LOCK;
unknown's avatar
VIEW  
unknown committed
3583

3584
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
3585
    {
3586 3587
#ifdef HAVE_QUERY_CACHE
      if (thd->variables.query_cache_wlock_invalidate)
unknown's avatar
VIEW  
unknown committed
3588
	query_cache.invalidate_locked_for_write(first_table);
3589
#endif /*HAVE_QUERY_CACHE*/
unknown's avatar
unknown committed
3590 3591
      thd->locked_tables=thd->lock;
      thd->lock=0;
3592
      send_ok(thd);
unknown's avatar
unknown committed
3593
    }
unknown's avatar
unknown committed
3594 3595
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3596 3597 3598
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3599
  {
3600 3601 3602 3603 3604
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
unknown committed
3605
    char *alias;
unknown's avatar
unknown committed
3606
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3607
    {
3608
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3609 3610
      break;
    }
3611 3612 3613
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
3614
      For that reason, db_ok() in sql/slave.cc did not check the
3615 3616 3617
      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.
    */
3618
#ifdef HAVE_REPLICATION
3619 3620 3621
    if (thd->slave_thread && 
	(!rpl_filter->db_ok(lex->name) ||
	 !rpl_filter->db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3622
    {
unknown's avatar
unknown committed
3623
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3624
      break;
unknown's avatar
unknown committed
3625
    }
3626
#endif
3627
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3628
      break;
unknown's avatar
unknown committed
3629
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
unknown's avatar
unknown committed
3630
			 &lex->create_info, 0);
3631 3632
    break;
  }
unknown's avatar
unknown committed
3633
  case SQLCOM_DROP_DB:
3634
  {
3635 3636 3637 3638 3639
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3640
    if (check_db_name(lex->name))
unknown's avatar
unknown committed
3641
    {
3642
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3643 3644
      break;
    }
3645 3646 3647 3648 3649 3650 3651
    /*
      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.
    */
3652
#ifdef HAVE_REPLICATION
3653
    if (thd->slave_thread && 
3654 3655
	(!rpl_filter->db_ok(lex->name) ||
	 !rpl_filter->db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3656
    {
unknown's avatar
unknown committed
3657
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3658
      break;
unknown's avatar
unknown committed
3659
    }
3660
#endif
3661
    if (check_access(thd,DROP_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3662
      break;
3663 3664
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
3665 3666
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3667 3668
      goto error;
    }
3669
    res= mysql_rm_db(thd, lex->name, lex->drop_if_exists, 0);
3670 3671
    break;
  }
unknown's avatar
unknown committed
3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713
  case SQLCOM_RENAME_DB:
  {
    LEX_STRING *olddb, *newdb;
    List_iterator <LEX_STRING> db_list(lex->db_list);
    olddb= db_list++;
    newdb= db_list++;
    if (end_active_trans(thd))
    {
      res= 1;
      break;
    }
#ifdef HAVE_REPLICATION
    if (thd->slave_thread && 
       (!rpl_filter->db_ok(olddb->str) ||
        !rpl_filter->db_ok(newdb->str) ||
        !rpl_filter->db_ok_with_wild_table(olddb->str) ||
        !rpl_filter->db_ok_with_wild_table(newdb->str)))
    {
      res= 1;
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
      break;
    }
#endif
    if (check_access(thd,ALTER_ACL,olddb->str,0,1,0,is_schema_db(olddb->str)) ||
        check_access(thd,DROP_ACL,olddb->str,0,1,0,is_schema_db(olddb->str)) ||
        check_access(thd,CREATE_ACL,newdb->str,0,1,0,is_schema_db(newdb->str)))
    {
      res= 1;
      break;
    }
    if (thd->locked_tables || thd->active_transaction())
    {
      res= 1;
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
      goto error;
    }
    res= mysql_rename_db(thd, olddb, newdb);
    if (!res)
      send_ok(thd);
    break;
  }
3714 3715
  case SQLCOM_ALTER_DB:
  {
3716 3717
    char *db= lex->name ? lex->name : thd->db;
    if (!db)
3718
    {
unknown's avatar
unknown committed
3719 3720
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      break;
3721 3722
    }
    if (!strip_sp(db) || check_db_name(db))
3723
    {
3724
      my_error(ER_WRONG_DB_NAME, MYF(0), db);
3725 3726
      break;
    }
unknown's avatar
unknown committed
3727 3728 3729
    /*
      If in a slave thread :
      ALTER DATABASE DB may not be preceded by USE DB.
3730
      For that reason, maybe db_ok() in sql/slave.cc did not check the
unknown's avatar
unknown committed
3731 3732 3733 3734
      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
3735
    if (thd->slave_thread &&
3736 3737
	(!rpl_filter->db_ok(db) ||
	 !rpl_filter->db_ok_with_wild_table(db)))
unknown's avatar
unknown committed
3738
    {
unknown's avatar
unknown committed
3739
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
unknown's avatar
unknown committed
3740 3741 3742
      break;
    }
#endif
3743
    if (check_access(thd, ALTER_ACL, db, 0, 1, 0, is_schema_db(db)))
3744 3745 3746
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
3747 3748
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3749 3750
      goto error;
    }
3751
    res= mysql_alter_db(thd, db, &lex->create_info);
3752 3753
    break;
  }
unknown's avatar
unknown committed
3754 3755 3756 3757
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3758
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3759 3760
      break;
    }
unknown's avatar
unknown committed
3761
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
unknown's avatar
unknown committed
3762 3763
    break;
  }
3764 3765
  case SQLCOM_CREATE_EVENT:
  case SQLCOM_ALTER_EVENT:
3766
  case SQLCOM_DROP_EVENT:
3767
  {
unknown's avatar
unknown committed
3768
    uint rows_affected= 1;
3769
    DBUG_ASSERT(lex->et);
3770 3771 3772 3773 3774 3775 3776
    do {
      if (! lex->et->dbname.str)
      {
        my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
        res= true;
        break;
      }
unknown's avatar
unknown committed
3777

3778 3779 3780
      if (check_access(thd, EVENT_ACL, lex->et->dbname.str, 0, 0, 0,
                       is_schema_db(lex->et->dbname.str)))
        break;
unknown's avatar
unknown committed
3781

3782 3783 3784 3785 3786 3787
      if (end_active_trans(thd))
      {
        res= -1;
        break;
      }

3788 3789
      switch (lex->sql_command) {
      case SQLCOM_CREATE_EVENT:
unknown's avatar
unknown committed
3790 3791
        res= evex_create_event(thd, lex->et, (uint) lex->create_info.options,
                               &rows_affected);
3792 3793
        break;
      case SQLCOM_ALTER_EVENT:
unknown's avatar
unknown committed
3794
        res= evex_update_event(thd, lex->et, lex->spname, &rows_affected);
3795 3796
        break;
      case SQLCOM_DROP_EVENT:
unknown's avatar
unknown committed
3797
        res= evex_drop_event(thd, lex->et, lex->drop_if_exists, &rows_affected);
3798 3799
      default:;
      }
3800 3801
      DBUG_PRINT("info", ("CREATE/ALTER/DROP returned error code=%d af_rows=%d",
                  res, rows_affected));
3802
      if (!res)
unknown's avatar
unknown committed
3803
        send_ok(thd, rows_affected);
3804

3805
      /* lex->unit.cleanup() is called outside, no need to call it here */
3806 3807 3808 3809 3810 3811 3812 3813
    } while (0);
    if (!thd->spcont)
    {
      lex->et->free_sphead_on_delete= true;
      lex->et->free_sp();
      lex->et->deinit_mutexes();
    }
    
3814 3815 3816 3817
    break;
  }
  case SQLCOM_SHOW_CREATE_EVENT:
  {
3818 3819 3820 3821 3822 3823 3824 3825
    DBUG_ASSERT(lex->spname);
    DBUG_ASSERT(lex->et);
    if (! lex->spname->m_db.str)
    {
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      res= true;
      break;
    }
unknown's avatar
unknown committed
3826 3827
    if (check_access(thd, EVENT_ACL, lex->spname->m_db.str, 0, 0, 0,
                     is_schema_db(lex->spname->m_db.str)))
3828 3829 3830 3831 3832 3833 3834
      break;

    if (lex->spname->m_name.length > NAME_LEN)
    {
      my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
      goto error;
    }
3835
    res= evex_show_create_event(thd, lex->spname, lex->et->definer);
3836 3837
    break;
  }
unknown's avatar
unknown committed
3838
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
unknown's avatar
unknown committed
3839
  {
3840
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0))
unknown's avatar
unknown committed
3841
      break;
unknown's avatar
unknown committed
3842
#ifdef HAVE_DLOPEN
3843 3844
    if (sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                        &thd->sp_func_cache, FALSE))
unknown's avatar
unknown committed
3845
    {
3846
      my_error(ER_UDF_EXISTS, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
3847 3848
      goto error;
    }
3849
    if (!(res = mysql_create_function(thd, &lex->udf)))
unknown's avatar
unknown committed
3850
      send_ok(thd);
unknown's avatar
unknown committed
3851
#else
unknown's avatar
unknown committed
3852
    my_error(ER_CANT_OPEN_LIBRARY, MYF(0), lex->udf.dl, 0, "feature disabled");
unknown's avatar
unknown committed
3853
    res= TRUE;
unknown's avatar
unknown committed
3854 3855
#endif
    break;
unknown's avatar
unknown committed
3856
  }
unknown's avatar
unknown committed
3857
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3858 3859
  case SQLCOM_CREATE_USER:
  {
3860
    if (check_access(thd, INSERT_ACL, "mysql", 0, 1, 1, 0) &&
3861
        check_global_access(thd,CREATE_USER_ACL))
3862
      break;
3863 3864
    if (end_active_trans(thd))
      goto error;
3865 3866 3867 3868
    if (!(res= mysql_create_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3869 3870
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3871 3872 3873 3874 3875
      }
      send_ok(thd);
    }
    break;
  }
3876 3877
  case SQLCOM_DROP_USER:
  {
3878
    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 1, 0) &&
3879
        check_global_access(thd,CREATE_USER_ACL))
3880
      break;
3881 3882
    if (end_active_trans(thd))
      goto error;
3883 3884 3885 3886
    if (!(res= mysql_drop_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3887 3888
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3889 3890 3891 3892 3893 3894 3895
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_RENAME_USER:
  {
3896
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
3897
        check_global_access(thd,CREATE_USER_ACL))
3898
      break;
3899 3900
    if (end_active_trans(thd))
      goto error;
3901 3902 3903 3904
    if (!(res= mysql_rename_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3905 3906
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3907 3908 3909 3910 3911 3912 3913
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
3914
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
3915
        check_global_access(thd,CREATE_USER_ACL))
3916 3917 3918 3919 3920
      break;
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3921 3922
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3923 3924 3925 3926 3927
      }
      send_ok(thd);
    }
    break;
  }
3928 3929 3930 3931
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
unknown's avatar
unknown committed
3932
		     first_table ?  first_table->db : select_lex->db,
unknown's avatar
VIEW  
unknown committed
3933
		     first_table ? &first_table->grant.privilege : 0,
3934 3935 3936
		     first_table ? 0 : 1, 0,
                     first_table ? (bool) first_table->schema_table :
                     select_lex->db ? is_schema_db(select_lex->db) : 0))
3937 3938
      goto error;

3939
    if (thd->security_ctx->user)              // If not replication
unknown's avatar
unknown committed
3940 3941
    {
      LEX_USER *user;
3942 3943
      uint counter;

unknown's avatar
unknown committed
3944
      List_iterator <LEX_USER> user_list(lex->users_list);
3945
      while ((user= user_list++))
unknown's avatar
unknown committed
3946
      {
3947 3948 3949 3950 3951 3952 3953 3954
        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);
3955
        if (strcmp(thd->security_ctx->user, user->user.str) ||
3956
            my_strcasecmp(system_charset_info,
3957
                          user->host.str, thd->security_ctx->host_or_ip))
3958 3959 3960
        {
          // TODO: use check_change_password()
          if (check_acl_user(user, &counter) && user->password.str &&
3961
              check_access(thd, UPDATE_ACL,"mysql",0,1,1,0))
3962 3963 3964 3965 3966 3967
          {
            my_message(ER_PASSWORD_NOT_ALLOWED,
                       ER(ER_PASSWORD_NOT_ALLOWED), MYF(0));
            goto error;
          }
        }
unknown's avatar
SCRUM  
unknown committed
3968 3969
      }
    }
unknown's avatar
VIEW  
unknown committed
3970
    if (first_table)
3971
    {
3972 3973
      if (lex->type == TYPE_ENUM_PROCEDURE ||
          lex->type == TYPE_ENUM_FUNCTION)
3974 3975 3976 3977 3978
      {
        uint grants= lex->all_privileges 
		   ? (PROC_ACLS & ~GRANT_ACL) | (lex->grant & GRANT_ACL)
		   : lex->grant;
        if (grant_option && 
3979 3980
	    check_grant_routine(thd, grants | GRANT_ACL, all_tables,
                                lex->type == TYPE_ENUM_PROCEDURE, 0))
3981
	  goto error;
3982 3983 3984 3985
        res= mysql_routine_grant(thd, all_tables,
                                 lex->type == TYPE_ENUM_PROCEDURE, 
                                 lex->users_list, grants,
                                 lex->sql_command == SQLCOM_REVOKE, 0);
3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998
      }
      else
      {
	if (grant_option && check_grant(thd,
					(lex->grant | lex->grant_tot_col |
					 GRANT_ACL),
					all_tables, 0, UINT_MAX, 0))
	  goto error;
        res= mysql_table_grant(thd, all_tables, lex->users_list,
			       lex->columns, lex->grant,
			       lex->sql_command == SQLCOM_REVOKE);
      }
      if (!res && mysql_bin_log.is_open())
3999
      {
unknown's avatar
unknown committed
4000
        thd->clear_error();
4001 4002
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
4003 4004 4005 4006
      }
    }
    else
    {
4007
      if (lex->columns.elements || lex->type)
4008
      {
unknown's avatar
unknown committed
4009 4010
	my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE),
                   MYF(0));
unknown's avatar
unknown committed
4011
        goto error;
4012 4013 4014 4015 4016 4017 4018 4019
      }
      else
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
	if (mysql_bin_log.is_open())
	{
unknown's avatar
unknown committed
4020
          thd->clear_error();
4021 4022
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
4023
	}
4024
	if (lex->sql_command == SQLCOM_GRANT)
4025
	{
unknown's avatar
unknown committed
4026 4027 4028
	  List_iterator <LEX_USER> str_list(lex->users_list);
	  LEX_USER *user;
	  while ((user=str_list++))
unknown's avatar
unknown committed
4029
	    reset_mqh(user);
4030
	}
4031 4032 4033 4034
      }
    }
    break;
  }
unknown's avatar
SCRUM  
unknown committed
4035
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
unknown's avatar
unknown committed
4036
  case SQLCOM_RESET:
4037 4038 4039
    /*
      RESET commands are never written to the binary log, so we have to
      initialize this variable because RESET shares the same code as FLUSH
4040 4041 4042 4043
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
unknown's avatar
unknown committed
4044
    bool write_to_binlog;
unknown's avatar
VIEW  
unknown committed
4045
    if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, all_tables))
unknown's avatar
unknown committed
4046
      goto error;
4047 4048 4049 4050
    /*
      reload_acl_and_cache() will tell us if we are allowed to write to the
      binlog or not.
    */
unknown's avatar
unknown committed
4051
    if (!reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
4052 4053 4054 4055 4056 4057 4058 4059 4060
    {
      /*
        We WANT to write and we CAN write.
        ! we write after unlocking the table.
      */
      if (!lex->no_write_to_binlog && write_to_binlog)
      {
        if (mysql_bin_log.is_open())
        {
4061
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
4062 4063 4064 4065 4066
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
    }
unknown's avatar
unknown committed
4067
    break;
4068
  }
unknown's avatar
unknown committed
4069
  case SQLCOM_KILL:
4070 4071 4072
  {
    Item *it= (Item *)lex->value_list.head();

4073
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) || it->check_cols(1))
4074 4075 4076 4077 4078 4079
    {
      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
4080
    break;
4081
  }
unknown's avatar
unknown committed
4082
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
4083
  case SQLCOM_SHOW_GRANTS:
4084 4085
    if ((thd->security_ctx->priv_user &&
	 !strcmp(thd->security_ctx->priv_user, lex->grant_user->user.str)) ||
4086
	!check_access(thd, SELECT_ACL, "mysql",0,1,0,0))
unknown's avatar
unknown committed
4087 4088 4089 4090
    {
      res = mysql_show_grants(thd,lex->grant_user);
    }
    break;
unknown's avatar
unknown committed
4091
#endif
4092
  case SQLCOM_HA_OPEN:
unknown's avatar
VIEW  
unknown committed
4093 4094 4095
    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))
4096
      goto error;
unknown's avatar
unknown committed
4097
    res= mysql_ha_open(thd, first_table, 0);
4098 4099
    break;
  case SQLCOM_HA_CLOSE:
unknown's avatar
VIEW  
unknown committed
4100 4101
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables))
4102
      goto error;
unknown's avatar
VIEW  
unknown committed
4103
    res= mysql_ha_close(thd, first_table);
4104 4105
    break;
  case SQLCOM_HA_READ:
unknown's avatar
VIEW  
unknown committed
4106
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
4107 4108 4109 4110 4111
    /*
      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
4112
    if (check_db_used(thd, all_tables))
4113
      goto error;
4114
    unit->set_limit(select_lex);
4115
    res= mysql_ha_read(thd, first_table, lex->ha_read_mode, lex->ident.str,
unknown's avatar
VIEW  
unknown committed
4116
                       lex->insert_list, lex->ha_rkey_mode, select_lex->where,
4117
                       unit->select_limit_cnt, unit->offset_limit_cnt);
4118 4119
    break;

unknown's avatar
unknown committed
4120
  case SQLCOM_BEGIN:
4121 4122 4123 4124 4125 4126
    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
4127
    if (begin_trans(thd))
unknown's avatar
unknown committed
4128
      goto error;
unknown's avatar
unknown committed
4129
    send_ok(thd);
unknown's avatar
unknown committed
4130 4131
    break;
  case SQLCOM_COMMIT:
4132
    if (end_trans(thd, lex->tx_release ? COMMIT_RELEASE :
unknown's avatar
unknown committed
4133
                              lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
unknown's avatar
unknown committed
4134
      goto error;
4135
    send_ok(thd);
unknown's avatar
unknown committed
4136 4137
    break;
  case SQLCOM_ROLLBACK:
4138
    if (end_trans(thd, lex->tx_release ? ROLLBACK_RELEASE :
unknown's avatar
unknown committed
4139
                              lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
unknown's avatar
unknown committed
4140
      goto error;
4141
    send_ok(thd);
unknown's avatar
unknown committed
4142
    break;
unknown's avatar
unknown committed
4143
  case SQLCOM_RELEASE_SAVEPOINT:
unknown's avatar
unknown committed
4144
  {
4145 4146
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
unknown's avatar
unknown committed
4147 4148 4149
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4150
                       (uchar *)sv->name, sv->length) == 0)
unknown's avatar
unknown committed
4151 4152
        break;
    }
4153
    if (sv)
unknown's avatar
unknown committed
4154
    {
4155
      if (ha_release_savepoint(thd, sv))
unknown's avatar
unknown committed
4156
        res= TRUE; // cannot happen
unknown's avatar
unknown committed
4157 4158
      else
        send_ok(thd);
4159
      thd->transaction.savepoints=sv->prev;
unknown's avatar
unknown committed
4160
    }
4161
    else
unknown's avatar
unknown committed
4162
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
4163
    break;
unknown's avatar
unknown committed
4164
  }
unknown's avatar
unknown committed
4165
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
unknown's avatar
unknown committed
4166
  {
4167 4168
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
4169 4170 4171
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4172
                       (uchar *)sv->name, sv->length) == 0)
4173 4174
        break;
    }
4175
    if (sv)
4176
    {
4177
      if (ha_rollback_to_savepoint(thd, sv))
4178 4179
        res= TRUE; // cannot happen
      else
unknown's avatar
unknown committed
4180 4181 4182 4183 4184 4185 4186 4187
      {
        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);
      }
4188
      thd->transaction.savepoints=sv;
unknown's avatar
unknown committed
4189 4190
    }
    else
4191
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
4192
    break;
4193
  }
4194
  case SQLCOM_SAVEPOINT:
4195 4196
    if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN) ||
          thd->in_sub_stmt) || !opt_using_transactions)
unknown's avatar
unknown committed
4197
      send_ok(thd);
unknown's avatar
unknown committed
4198
    else
4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236
    {
      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
4237
    break;
4238 4239
  case SQLCOM_CREATE_PROCEDURE:
  case SQLCOM_CREATE_SPFUNCTION:
unknown's avatar
unknown committed
4240
  {
4241
    uint namelen;
4242
    char *name, *db;
unknown's avatar
unknown committed
4243
    int result;
4244

4245
    DBUG_ASSERT(lex->sphead != 0);
4246

4247 4248
    if (!lex->sphead->m_db.str || !lex->sphead->m_db.str[0])
    {
4249
      if (!thd->db)
4250 4251 4252 4253 4254 4255 4256 4257 4258 4259
      {
        my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
        delete lex->sphead;
        lex->sphead= 0;
        goto error;
      }
      lex->sphead->m_db.length= strlen(thd->db);
      lex->sphead->m_db.str= thd->db;
    }

4260 4261
    if (check_access(thd, CREATE_PROC_ACL, lex->sphead->m_db.str, 0, 0, 0,
                     is_schema_db(lex->sphead->m_db.str)))
4262 4263 4264 4265 4266 4267
    {
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
    }

4268
    if (end_active_trans(thd)) 
4269
    {
4270 4271 4272
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
4273
    }
4274 4275

    name= lex->sphead->name(&namelen);
4276
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
4277 4278 4279
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
4280

unknown's avatar
unknown committed
4281
      if (udf)
4282
      {
4283
	my_error(ER_UDF_EXISTS, MYF(0), name);
unknown's avatar
unknown committed
4284
	delete lex->sphead;
4285
	lex->sphead= 0;
4286
	goto error;
4287
      }
unknown's avatar
unknown committed
4288 4289 4290
    }
#endif

4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 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
    /*
      If the definer is not specified, this means that CREATE-statement missed
      DEFINER-clause. DEFINER-clause can be missed in two cases:
      
        - 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.
          
          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)
    {
      bool res= FALSE;
      Query_arena original_arena;
      Query_arena *ps_arena = thd->activate_stmt_arena_if_needed(&original_arena);

      if (!(lex->definer= create_default_definer(thd)))
        res= TRUE;

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

      if (res)
      {
        /* Error has been already reported. */
        delete lex->sphead;
        lex->sphead= 0;
        goto error;
      }

      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).
    */
    
    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");
        delete lex->sphead;
        lex->sphead= 0;
        goto error;
      }
    }

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

4375 4376 4377 4378 4379
    /*
      We need to copy name and db in order to use them for
      check_routine_access which is called after lex->sphead has
      been deleted.
    */
4380
    name= thd->strdup(name); 
4381 4382
    lex->sphead->m_db.str= db= thd->strmake(lex->sphead->m_db.str,
                                            lex->sphead->m_db.length);
unknown's avatar
unknown committed
4383
    res= (result= lex->sphead->create(thd));
unknown's avatar
unknown committed
4384 4385
    if (result == SP_OK)
    {
4386 4387 4388
      /*
        We must cleanup the unit and the lex here because
        sp_grant_privileges calls (indirectly) db_find_routine,
4389
        which in turn may call MYSQLparse with THD::lex.
4390 4391
        TODO: fix db_find_routine to use a temporary lex.
      */
4392
      lex->unit.cleanup();
unknown's avatar
unknown committed
4393 4394
      delete lex->sphead;
      lex->sphead= 0;
unknown's avatar
unknown committed
4395
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4396
      /* only add privileges if really neccessary */
4397
      if (sp_automatic_privileges && !opt_noacl &&
4398 4399 4400
          check_routine_access(thd, DEFAULT_CREATE_PROC_ACLS,
      			       db, name,
                               lex->sql_command == SQLCOM_CREATE_PROCEDURE, 1))
4401
      {
4402 4403
        if (sp_grant_privileges(thd, db, name, 
                                lex->sql_command == SQLCOM_CREATE_PROCEDURE))
4404 4405 4406
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
	  	       ER_PROC_AUTO_GRANT_FAIL,
		       ER(ER_PROC_AUTO_GRANT_FAIL));
4407
        close_thread_tables(thd);
4408
      }
unknown's avatar
unknown committed
4409
#endif
4410
      send_ok(thd);
unknown's avatar
unknown committed
4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430
    }
    else
    {
      switch (result) {
      case SP_WRITE_ROW_FAILED:
	my_error(ER_SP_ALREADY_EXISTS, MYF(0), SP_TYPE_STRING(lex), name);
	break;
      case SP_NO_DB_ERROR:
	my_error(ER_BAD_DB_ERROR, MYF(0), lex->sphead->m_db.str);
	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;
      }
4431
      lex->unit.cleanup();
unknown's avatar
unknown committed
4432 4433 4434
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
4435
    }
unknown's avatar
unknown committed
4436 4437
    break;
  }
4438 4439 4440 4441
  case SQLCOM_CALL:
    {
      sp_head *sp;

4442 4443 4444 4445 4446 4447 4448 4449 4450
      /*
        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;

      /*
4451 4452
        By this moment all needed SPs should be in cache so no need to look 
        into DB. 
4453
      */
4454 4455
      if (!(sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                                &thd->sp_proc_cache, TRUE)))
4456
      {
4457
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PROCEDURE",
unknown's avatar
unknown committed
4458
                 lex->spname->m_qname.str);
4459
	goto error;
4460 4461 4462
      }
      else
      {
4463
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4464
	Security_context *save_ctx;
4465
#endif
unknown's avatar
unknown committed
4466
	ha_rows select_limit;
unknown's avatar
unknown committed
4467 4468
        /* bits that should be cleared in thd->server_status */
	uint bits_to_be_cleared= 0;
4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480
        /*
          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;
        }
4481

4482 4483
	my_bool nsok= thd->net.no_send_ok;
	thd->net.no_send_ok= TRUE;
4484
	if (sp->m_flags & sp_head::MULTI_RESULTS)
4485
	{
4486
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
4487
	  {
4488 4489 4490 4491
            /*
              The client does not support multiple result sets being sent
              back
            */
4492
	    my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str);
4493 4494 4495
	    thd->net.no_send_ok= nsok;
	    goto error;
	  }
unknown's avatar
unknown committed
4496 4497 4498 4499 4500 4501 4502
          /*
            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;
4503 4504
	}

4505
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4506 4507 4508
	if (check_routine_access(thd, EXECUTE_ACL,
				 sp->m_db.str, sp->m_name.str, TRUE, 0) ||
          sp_change_security_context(thd, sp, &save_ctx))
4509 4510 4511 4512
	{
	  thd->net.no_send_ok= nsok;
	  goto error;
	}
4513 4514 4515
	if (save_ctx &&
            check_routine_access(thd, EXECUTE_ACL,
                                 sp->m_db.str, sp->m_name.str, TRUE, 0))
4516 4517
	{
	  thd->net.no_send_ok= nsok;
4518
	  sp_restore_security_context(thd, save_ctx);
4519 4520 4521
	  goto error;
	}

4522
#endif
unknown's avatar
unknown committed
4523 4524
	select_limit= thd->variables.select_limit;
	thd->variables.select_limit= HA_POS_ERROR;
4525

4526
        thd->row_count_func= 0;
4527 4528
        
        /* 
4529
          We never write CALL statements into binlog:
4530 4531 4532 4533 4534
           - 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.
4535
        */
4536
	res= sp->execute_procedure(thd, &lex->value_list);
4537 4538 4539
	/*
          If warnings have been cleared, we have to clear total_warn_count
          too, otherwise the clients get confused.
4540 4541 4542 4543
	 */
	if (thd->warn_list.is_empty())
	  thd->total_warn_count= 0;

unknown's avatar
unknown committed
4544
	thd->variables.select_limit= select_limit;
4545
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4546
	sp_restore_security_context(thd, save_ctx);
4547
#endif
4548

4549
	thd->net.no_send_ok= nsok;
unknown's avatar
unknown committed
4550
        thd->server_status&= ~bits_to_be_cleared;
4551

unknown's avatar
unknown committed
4552
	if (!res)
unknown's avatar
unknown committed
4553 4554
	  send_ok(thd, (ulong) (thd->row_count_func < 0 ? 0 :
                                thd->row_count_func));
4555 4556
	else
	  goto error;		// Substatement should already have sent error
4557
      }
4558
      break;
4559 4560
    }
  case SQLCOM_ALTER_PROCEDURE:
4561
  case SQLCOM_ALTER_FUNCTION:
4562
    {
unknown's avatar
unknown committed
4563
      int result;
4564 4565 4566 4567
      sp_head *sp;
      st_sp_chistics chistics;

      memcpy(&chistics, &lex->sp_chistics, sizeof(chistics));
unknown's avatar
unknown committed
4568
      if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4569 4570
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
4571
      else
4572 4573
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
unknown's avatar
unknown committed
4574
      mysql_reset_errors(thd, 0);
4575
      if (! sp)
4576 4577 4578 4579 4580 4581 4582 4583 4584
      {
	if (lex->spname->m_db.str)
	  result= SP_KEY_NOT_FOUND;
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
      }
4585 4586
      else
      {
4587 4588 4589
        if (check_routine_access(thd, ALTER_PROC_ACL, sp->m_db.str, 
				 sp->m_name.str,
                                 lex->sql_command == SQLCOM_ALTER_PROCEDURE, 0))
4590
	  goto error;
4591 4592 4593

        if (end_active_trans(thd)) 
          goto error;
4594
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
4595 4596
        if ((sp->m_type == TYPE_ENUM_FUNCTION) &&
            !trust_function_creators &&  mysql_bin_log.is_open() &&
4597 4598 4599 4600 4601 4602 4603 4604 4605 4606
            !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));
          result= SP_INTERNAL_ERROR;
        }
        else
        {
4607 4608 4609 4610 4611 4612
          /*
            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.
          */
4613 4614 4615 4616 4617
          if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
            result= sp_update_procedure(thd, lex->spname, &lex->sp_chistics);
          else
            result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
        }
4618
      }
unknown's avatar
unknown committed
4619
      switch (result)
4620
      {
unknown's avatar
unknown committed
4621
      case SP_OK:
4622 4623 4624
        if (mysql_bin_log.is_open())
        {
          thd->clear_error();
4625 4626
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
4627
        }
4628
	send_ok(thd);
unknown's avatar
unknown committed
4629 4630
	break;
      case SP_KEY_NOT_FOUND:
4631 4632
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4633 4634
	goto error;
      default:
4635 4636
	my_error(ER_SP_CANT_ALTER, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4637
	goto error;
4638
      }
4639
      break;
4640 4641
    }
  case SQLCOM_DROP_PROCEDURE:
4642
  case SQLCOM_DROP_FUNCTION:
4643
    {
unknown's avatar
unknown committed
4644
      int result;
4645 4646
      int type= (lex->sql_command == SQLCOM_DROP_PROCEDURE ?
                 TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION);
4647

4648
      result= sp_routine_exists_in_table(thd, type, lex->spname);
unknown's avatar
unknown committed
4649
      mysql_reset_errors(thd, 0);
4650
      if (result == SP_OK)
4651
      {
4652 4653 4654
        char *db= lex->spname->m_db.str;
	char *name= lex->spname->m_name.str;

4655 4656
	if (check_routine_access(thd, ALTER_PROC_ACL, db, name,
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE, 0))
unknown's avatar
merge  
unknown committed
4657
          goto error;
4658 4659 4660

        if (end_active_trans(thd)) 
          goto error;
unknown's avatar
unknown committed
4661
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4662
	if (sp_automatic_privileges && !opt_noacl &&
4663 4664
	    sp_revoke_privileges(thd, db, name, 
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE))
4665 4666 4667 4668 4669
	{
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
		       ER_PROC_AUTO_REVOKE_FAIL,
		       ER(ER_PROC_AUTO_REVOKE_FAIL));
	}
unknown's avatar
unknown committed
4670
#endif
4671
	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
unknown's avatar
merge  
unknown committed
4672
	  result= sp_drop_procedure(thd, lex->spname);
4673
	else
unknown's avatar
merge  
unknown committed
4674
	  result= sp_drop_function(thd, lex->spname);
4675 4676 4677
      }
      else
      {
4678
#ifdef HAVE_DLOPEN
4679 4680 4681 4682 4683 4684
	if (lex->sql_command == SQLCOM_DROP_FUNCTION)
	{
          udf_func *udf = find_udf(lex->spname->m_name.str,
                                   lex->spname->m_name.length);
          if (udf)
          {
4685
	    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 0, 0))
4686 4687
	      goto error;
	    if (!(res = mysql_drop_function(thd, &lex->spname->m_name)))
4688
	    {
4689 4690
	      send_ok(thd);
	      break;
4691 4692
	    }
	  }
4693
	}
4694
#endif
4695 4696 4697 4698 4699 4700 4701
	if (lex->spname->m_db.str)
	  result= SP_KEY_NOT_FOUND;
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
4702
      }
unknown's avatar
unknown committed
4703 4704
      res= result;
      switch (result)
4705 4706
      {
      case SP_OK:
4707 4708 4709
        if (mysql_bin_log.is_open())
        {
          thd->clear_error();
4710 4711
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
4712
        }
4713
	send_ok(thd);
4714 4715
	break;
      case SP_KEY_NOT_FOUND:
4716 4717
	if (lex->drop_if_exists)
	{
4718
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
4719
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
4720
			      SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4721
	  res= FALSE;
4722 4723 4724
	  send_ok(thd);
	  break;
	}
4725 4726
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4727 4728
	goto error;
      default:
4729 4730
	my_error(ER_SP_DROP_FAILED, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4731
	goto error;
4732
      }
4733
      break;
4734
    }
unknown's avatar
unknown committed
4735 4736
  case SQLCOM_SHOW_CREATE_PROC:
    {
4737
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4738
      {
4739
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4740 4741
	goto error;
      }
unknown's avatar
unknown committed
4742
      if (sp_show_create_procedure(thd, lex->spname) != SP_OK)
4743
      {			/* We don't distinguish between errors for now */
4744 4745
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4746 4747 4748 4749 4750 4751
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
4752
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4753
      {
4754
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4755 4756
	goto error;
      }
unknown's avatar
unknown committed
4757
      if (sp_show_create_function(thd, lex->spname) != SP_OK)
4758
      {			/* We don't distinguish between errors for now */
4759 4760
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4761 4762 4763 4764 4765 4766
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
4767
      res= sp_show_status_procedure(thd, (lex->wild ?
unknown's avatar
unknown committed
4768 4769 4770 4771 4772
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
4773
      res= sp_show_status_function(thd, (lex->wild ? 
unknown's avatar
unknown committed
4774 4775 4776
					 lex->wild->ptr() : NullS));
      break;
    }
unknown's avatar
unknown committed
4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788
#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
4789 4790
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
unknown's avatar
unknown committed
4791
      else
unknown's avatar
unknown committed
4792 4793
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
4794
      if (!sp || sp->show_routine_code(thd))
4795 4796
      {
        /* We don't distinguish between errors for now */
unknown's avatar
unknown committed
4797 4798 4799 4800 4801 4802 4803
        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
4804 4805
  case SQLCOM_CREATE_VIEW:
    {
4806 4807 4808
      if (end_active_trans(thd))
        goto error;

4809 4810 4811
      if (!(res= mysql_create_view(thd, thd->lex->create_view_mode)) &&
          mysql_bin_log.is_open())
      {
4812
        String buff;
unknown's avatar
unknown committed
4813 4814 4815 4816
        const LEX_STRING command[3]=
          {{(char *)STRING_WITH_LEN("CREATE ")},
           {(char *)STRING_WITH_LEN("ALTER ")},
           {(char *)STRING_WITH_LEN("CREATE OR REPLACE ")}};
unknown's avatar
unknown committed
4817
        thd->clear_error();
4818 4819 4820 4821

        buff.append(command[thd->lex->create_view_mode].str,
                    command[thd->lex->create_view_mode].length);
        view_store_options(thd, first_table, &buff);
4822
        buff.append(STRING_WITH_LEN("VIEW "));
4823 4824
        /* Test if user supplied a db (ie: we did not use thd->db) */
        if (first_table->db != thd->db && first_table->db[0])
4825 4826 4827 4828 4829 4830 4831
        {
          append_identifier(thd, &buff, first_table->db,
                            first_table->db_length);
          buff.append('.');
        }
        append_identifier(thd, &buff, first_table->table_name,
                          first_table->table_name_length);
4832
        buff.append(STRING_WITH_LEN(" AS "));
4833 4834
        buff.append(first_table->source.str, first_table->source.length);

4835 4836
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          buff.ptr(), buff.length(), FALSE, FALSE);
4837
      }
unknown's avatar
VIEW  
unknown committed
4838 4839 4840 4841
      break;
    }
  case SQLCOM_DROP_VIEW:
    {
unknown's avatar
unknown committed
4842 4843 4844
      if (check_table_access(thd, DROP_ACL, all_tables, 0) ||
          end_active_trans(thd))
        goto error;
4845 4846 4847
      if (!(res= mysql_drop_view(thd, first_table, thd->lex->drop_mode)) &&
          mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
4848
        thd->clear_error();
4849 4850
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
4851
      }
unknown's avatar
VIEW  
unknown committed
4852 4853
      break;
    }
4854 4855
  case SQLCOM_CREATE_TRIGGER:
  {
4856 4857 4858
    if (end_active_trans(thd))
      goto error;

4859 4860 4861
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

    /* We don't care about trigger body after this point */
4862 4863 4864 4865 4866 4867
    delete lex->sphead;
    lex->sphead= 0;
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
4868 4869 4870
    if (end_active_trans(thd))
      goto error;

4871 4872 4873
    res= mysql_create_or_drop_trigger(thd, all_tables, 0);
    break;
  }
4874
  case SQLCOM_XA_START:
4875 4876
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
        thd->lex->xa_opt == XA_RESUME)
4877
    {
4878
      if (! thd->transaction.xid_state.xid.eq(thd->lex->xid))
4879 4880 4881 4882
      {
        my_error(ER_XAER_NOTA, MYF(0));
        break;
      }
4883
      thd->transaction.xid_state.xa_state=XA_ACTIVE;
4884 4885 4886
      send_ok(thd);
      break;
    }
unknown's avatar
unknown committed
4887
    if (thd->lex->xa_opt != XA_NONE)
4888 4889 4890 4891
    { // JOIN is not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
4892
    if (thd->transaction.xid_state.xa_state != XA_NOTR)
4893
    {
unknown's avatar
unknown committed
4894
      my_error(ER_XAER_RMFAIL, MYF(0),
4895
               xa_state_names[thd->transaction.xid_state.xa_state]);
4896 4897 4898 4899 4900 4901 4902
      break;
    }
    if (thd->active_transaction() || thd->locked_tables)
    {
      my_error(ER_XAER_OUTSIDE, MYF(0));
      break;
    }
4903 4904 4905 4906 4907 4908 4909 4910 4911
    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);
4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923
    thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
                   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;
    }
4924
    if (thd->transaction.xid_state.xa_state != XA_ACTIVE)
4925
    {
unknown's avatar
unknown committed
4926
      my_error(ER_XAER_RMFAIL, MYF(0),
4927
               xa_state_names[thd->transaction.xid_state.xa_state]);
4928 4929
      break;
    }
4930
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4931 4932 4933 4934
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
4935
    thd->transaction.xid_state.xa_state=XA_IDLE;
4936 4937 4938
    send_ok(thd);
    break;
  case SQLCOM_XA_PREPARE:
4939
    if (thd->transaction.xid_state.xa_state != XA_IDLE)
4940
    {
unknown's avatar
unknown committed
4941
      my_error(ER_XAER_RMFAIL, MYF(0),
4942
               xa_state_names[thd->transaction.xid_state.xa_state]);
4943 4944
      break;
    }
4945
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4946 4947 4948 4949 4950 4951 4952
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
    if (ha_prepare(thd))
    {
      my_error(ER_XA_RBROLLBACK, MYF(0));
4953 4954
      xid_cache_delete(&thd->transaction.xid_state);
      thd->transaction.xid_state.xa_state=XA_NOTR;
4955 4956
      break;
    }
4957
    thd->transaction.xid_state.xa_state=XA_PREPARED;
4958 4959 4960
    send_ok(thd);
    break;
  case SQLCOM_XA_COMMIT:
4961
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4962
    {
4963 4964
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
4965
        my_error(ER_XAER_NOTA, MYF(0));
unknown's avatar
unknown committed
4966
      else
4967 4968 4969
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 1);
        xid_cache_delete(xs);
unknown's avatar
unknown committed
4970
        send_ok(thd);
4971
      }
4972 4973
      break;
    }
4974
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
unknown's avatar
unknown committed
4975
        thd->lex->xa_opt == XA_ONE_PHASE)
4976
    {
unknown's avatar
unknown committed
4977 4978 4979
      int r;
      if ((r= ha_commit(thd)))
        my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0));
4980 4981 4982
      else
        send_ok(thd);
    }
4983
    else if (thd->transaction.xid_state.xa_state == XA_PREPARED &&
unknown's avatar
unknown committed
4984
             thd->lex->xa_opt == XA_NONE)
4985
    {
4986 4987 4988
      if (wait_if_global_read_lock(thd, 0, 0))
      {
        ha_rollback(thd);
4989
        my_error(ER_XAER_RMERR, MYF(0));
4990
      }
4991
      else
4992 4993 4994 4995 4996 4997 4998
      {
        if (ha_commit_one_phase(thd, 1))
          my_error(ER_XAER_RMERR, MYF(0));
        else
          send_ok(thd);
        start_waiting_global_read_lock(thd);
      }
4999 5000 5001
    }
    else
    {
unknown's avatar
unknown committed
5002
      my_error(ER_XAER_RMFAIL, MYF(0),
5003
               xa_state_names[thd->transaction.xid_state.xa_state]);
5004 5005 5006 5007
      break;
    }
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
5008 5009
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
5010 5011
    break;
  case SQLCOM_XA_ROLLBACK:
5012
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
5013
    {
5014 5015
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
5016
        my_error(ER_XAER_NOTA, MYF(0));
unknown's avatar
unknown committed
5017
      else
5018 5019 5020
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 0);
        xid_cache_delete(xs);
unknown's avatar
unknown committed
5021
        send_ok(thd);
5022
      }
5023 5024
      break;
    }
5025 5026
    if (thd->transaction.xid_state.xa_state != XA_IDLE &&
        thd->transaction.xid_state.xa_state != XA_PREPARED)
5027
    {
unknown's avatar
unknown committed
5028
      my_error(ER_XAER_RMFAIL, MYF(0),
5029
               xa_state_names[thd->transaction.xid_state.xa_state]);
5030 5031 5032 5033 5034 5035 5036 5037
      break;
    }
    if (ha_rollback(thd))
      my_error(ER_XAER_RMERR, MYF(0));
    else
      send_ok(thd);
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
5038 5039
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
5040 5041
    break;
  case SQLCOM_XA_RECOVER:
5042
    res= mysql_xa_recover(thd);
5043
    break;
unknown's avatar
unknown committed
5044 5045 5046 5047 5048 5049
  case SQLCOM_ALTER_TABLESPACE:
    if (check_access(thd, ALTER_ACL, thd->db, 0, 1, 0, thd->db ? is_schema_db(thd->db) : 0))
      break;
    if (!(res= mysql_alter_tablespace(thd, lex->alter_tablespace_info)))
      send_ok(thd);
    break;
5050 5051 5052 5053 5054 5055 5056 5057 5058
  case SQLCOM_INSTALL_PLUGIN:
    if (! (res= mysql_install_plugin(thd, &thd->lex->comment,
                                     &thd->lex->ident)))
      send_ok(thd);
    break;
  case SQLCOM_UNINSTALL_PLUGIN:
    if (! (res= mysql_uninstall_plugin(thd, &thd->lex->comment)))
      send_ok(thd);
    break;
5059 5060 5061 5062 5063 5064 5065 5066 5067
  case SQLCOM_BINLOG_BASE64_EVENT:
  {
#ifndef EMBEDDED_LIBRARY
    mysql_client_binlog_statement(thd);
#else /* EMBEDDED_LIBRARY */
    my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "embedded");
#endif /* EMBEDDED_LIBRARY */
    break;
  }
5068
  default:
5069
#ifndef EMBEDDED_LIBRARY
5070
    DBUG_ASSERT(0);                             /* Impossible */
5071
#endif
5072
    send_ok(thd);
unknown's avatar
unknown committed
5073 5074
    break;
  }
5075 5076

end:
unknown's avatar
unknown committed
5077
  thd->proc_info="query end";
5078 5079

  /*
5080
    Binlog-related cleanup:
5081 5082 5083 5084 5085 5086 5087 5088 5089 5090
    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);
5091
  thd->reset_current_stmt_binlog_row_based();
5092

5093
  /*
5094 5095 5096 5097 5098 5099
    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.
5100
   */
5101 5102
  if (lex->sql_command != SQLCOM_CALL && lex->sql_command != SQLCOM_EXECUTE &&
      uc_update_queries[lex->sql_command]<2)
5103
    thd->row_count_func= -1;
unknown's avatar
unknown committed
5104
  DBUG_RETURN(res || thd->net.report_error);
unknown's avatar
unknown committed
5105 5106

error:
5107 5108
  res= 1;           // would be better to set res=1 before "goto error"
  goto end;
unknown's avatar
unknown committed
5109 5110 5111
}


unknown's avatar
unknown committed
5112 5113
/*
  Check grants for commands which work only with one table and all other
5114
  tables belonging to subselects or implicitly opened tables.
unknown's avatar
unknown committed
5115

5116
  SYNOPSIS
unknown's avatar
unknown committed
5117 5118
    check_one_table_access()
    thd			Thread handler
5119
    privilege		requested privilege
unknown's avatar
VIEW  
unknown committed
5120
    all_tables		global table list of query
unknown's avatar
unknown committed
5121 5122 5123

  RETURN
    0 - OK
unknown's avatar
unknown committed
5124
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
5125 5126
*/

5127
bool check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *all_tables)
unknown's avatar
unknown committed
5128
{
unknown's avatar
VIEW  
unknown committed
5129
  if (check_access(thd, privilege, all_tables->db,
5130 5131
		   &all_tables->grant.privilege, 0, 0,
                   test(all_tables->schema_table)))
unknown's avatar
unknown committed
5132
    return 1;
unknown's avatar
unknown committed
5133

unknown's avatar
unknown committed
5134
  /* Show only 1 table for check_grant */
unknown's avatar
VIEW  
unknown committed
5135
  if (grant_option && check_grant(thd, privilege, all_tables, 0, 1, 0))
unknown's avatar
unknown committed
5136
    return 1;
unknown's avatar
unknown committed
5137

5138
  /* Check rights on tables of subselects and implictly opened tables */
unknown's avatar
unknown committed
5139
  TABLE_LIST *subselects_tables;
unknown's avatar
VIEW  
unknown committed
5140
  if ((subselects_tables= all_tables->next_global))
unknown's avatar
unknown committed
5141
  {
unknown's avatar
VIEW  
unknown committed
5142
    if ((check_table_access(thd, SELECT_ACL, subselects_tables, 0)))
unknown's avatar
unknown committed
5143 5144 5145
      return 1;
  }
  return 0;
unknown's avatar
unknown committed
5146 5147 5148
}


unknown's avatar
unknown committed
5149
/****************************************************************************
unknown's avatar
unknown committed
5150
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163

  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
5164 5165
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
5166 5167 5168
****************************************************************************/

bool
unknown's avatar
unknown committed
5169
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
5170
	     bool dont_check_global_grants, bool no_errors, bool schema_db)
unknown's avatar
unknown committed
5171
{
5172
  Security_context *sctx= thd->security_ctx;
unknown's avatar
unknown committed
5173 5174
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
unknown's avatar
unknown committed
5175
  bool  db_is_pattern= test(want_access & GRANT_ACL);
unknown's avatar
unknown committed
5176 5177
#endif
  ulong dummy;
5178 5179
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
5180
                      db ? db : "", want_access, sctx->master_access));
unknown's avatar
unknown committed
5181 5182 5183 5184 5185
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

5186
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
5187
  {
5188
    DBUG_PRINT("error",("No database"));
5189
    if (!no_errors)
unknown's avatar
unknown committed
5190 5191
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                 MYF(0));                       /* purecov: tested */
unknown's avatar
unknown committed
5192
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5193 5194
  }

5195 5196 5197 5198 5199
  if (schema_db)
  {
    if (want_access & ~(SELECT_ACL | EXTRA_ACL))
    {
      if (!no_errors)
5200 5201
      {
        const char *db_name= db ? db : thd->db;
5202
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5203 5204
                 sctx->priv_user, sctx->priv_host, db_name);
      }
5205 5206 5207 5208 5209 5210 5211 5212 5213
      DBUG_RETURN(TRUE);
    }
    else
    {
      *save_priv= SELECT_ACL;
      DBUG_RETURN(FALSE);
    }
  }

unknown's avatar
unknown committed
5214 5215 5216
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
5217
  if ((sctx->master_access & want_access) == want_access)
unknown's avatar
unknown committed
5218
  {
5219 5220 5221 5222 5223
    /*
      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
    */
5224 5225
    db_access= sctx->db_access;
    if (!(sctx->master_access & SELECT_ACL) &&
unknown's avatar
unknown committed
5226
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
5227 5228 5229
      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
5230
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
5231
  }
5232
  if (((want_access & ~sctx->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
5233
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
5234
  {						// We can never grant this
5235
    DBUG_PRINT("error",("No possible access"));
5236
    if (!no_errors)
5237
      my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
5238 5239
               sctx->priv_user,
               sctx->priv_host,
5240 5241 5242
               (thd->password ?
                ER(ER_YES) :
                ER(ER_NO)));                    /* purecov: tested */
unknown's avatar
unknown committed
5243
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5244 5245 5246
  }

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

unknown's avatar
unknown committed
5249
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
5250 5251
    db_access= acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                       db_is_pattern);
unknown's avatar
unknown committed
5252
  else
5253
    db_access= sctx->db_access;
5254
  DBUG_PRINT("info",("db_access: %lu", db_access));
unknown's avatar
unknown committed
5255
  /* Remove SHOW attribute and access rights we already have */
5256
  want_access &= ~(sctx->master_access | EXTRA_ACL);
5257 5258
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
5259
  db_access= ((*save_priv=(db_access | sctx->master_access)) & want_access);
5260 5261

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
5262
  if (db_access == want_access ||
5263
      (grant_option && !dont_check_global_grants &&
5264
       !(want_access & ~(db_access | TABLE_ACLS | PROC_ACLS))))
unknown's avatar
unknown committed
5265
    DBUG_RETURN(FALSE);				/* Ok */
5266 5267

  DBUG_PRINT("error",("Access denied"));
5268
  if (!no_errors)
5269
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5270
             sctx->priv_user, sctx->priv_host,
5271 5272 5273
             (db ? db : (thd->db ?
                         thd->db :
                         "unknown")));          /* purecov: tested */
unknown's avatar
unknown committed
5274
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5275
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
5276 5277 5278
}


5279 5280 5281 5282 5283 5284 5285 5286 5287
/*
  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
5288
    One gets access right if one has ANY of the rights in want_access
5289 5290 5291 5292 5293 5294 5295 5296
    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
5297 5298

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
5299
{
unknown's avatar
unknown committed
5300 5301 5302
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
5303
  char command[128];
5304
  if ((thd->security_ctx->master_access & want_access))
unknown's avatar
unknown committed
5305 5306
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
5307
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
unknown's avatar
unknown committed
5308
  return 1;
unknown's avatar
unknown committed
5309
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
5310 5311 5312
}


unknown's avatar
unknown committed
5313
/*
unknown's avatar
unknown committed
5314 5315
  Check the privilege for all used tables.  Table privileges are cached
  in the table list for GRANT checking
unknown's avatar
unknown committed
5316 5317
*/

5318
bool
unknown's avatar
unknown committed
5319
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
5320
		   bool no_errors)
unknown's avatar
unknown committed
5321
{
unknown's avatar
unknown committed
5322 5323
  uint found=0;
  ulong found_access=0;
5324 5325 5326
  TABLE_LIST *org_tables= tables;
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
  /*
unknown's avatar
unknown committed
5327 5328 5329
    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.
5330
  */
unknown's avatar
unknown committed
5331
  for (; tables != first_not_own_table; tables= tables->next_global)
unknown's avatar
unknown committed
5332
  {
5333
    if (tables->schema_table && 
5334
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5335 5336 5337
    {
      if (!no_errors)
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5338
                 thd->security_ctx->priv_user, thd->security_ctx->priv_host,
5339 5340 5341
                 information_schema_name.str);
      return TRUE;
    }
5342 5343 5344 5345 5346
    /*
       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);
5347
    if (tables->derived || tables->schema_table || tables->belong_to_view ||
5348
        (tables->table && (int)tables->table->s->tmp_table) ||
5349 5350
        my_tz_check_n_skip_implicit_tables(&tables,
                                           thd->lex->time_zone_tables_used))
unknown's avatar
unknown committed
5351
      continue;
5352 5353
    if ((thd->security_ctx->master_access & want_access) ==
        (want_access & ~EXTRA_ACL) &&
unknown's avatar
unknown committed
5354
	thd->db)
unknown's avatar
unknown committed
5355
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
5356
    else if (tables->db && tables->db == thd->db)
unknown's avatar
unknown committed
5357 5358 5359 5360 5361
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
5362
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5363
			 0, no_errors, test(tables->schema_table)))
unknown's avatar
unknown committed
5364 5365
	  return TRUE;				// Access denied
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
5366
	found=1;
unknown's avatar
unknown committed
5367 5368
      }
    }
5369
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5370
			  0, no_errors, test(tables->schema_table)))
5371
      return TRUE;
unknown's avatar
unknown committed
5372 5373
  }
  if (grant_option)
5374
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
unknown's avatar
unknown committed
5375
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
unknown's avatar
unknown committed
5376 5377 5378
  return FALSE;
}

5379

5380
bool
5381 5382
check_routine_access(THD *thd, ulong want_access,char *db, char *name,
		     bool is_proc, bool no_errors)
5383 5384 5385 5386 5387
{
  TABLE_LIST tables[1];
  
  bzero((char *)tables, sizeof(TABLE_LIST));
  tables->db= db;
5388
  tables->table_name= tables->alias= name;
5389
  
unknown's avatar
unknown committed
5390 5391 5392 5393 5394 5395 5396
  /*
    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)
5397 5398
    tables->grant.privilege= want_access;
  else if (check_access(thd,want_access,db,&tables->grant.privilege,
unknown's avatar
unknown committed
5399
			0, no_errors, 0))
5400 5401
    return TRUE;
  
unknown's avatar
unknown committed
5402
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5403
  if (grant_option)
5404
    return check_grant_routine(thd, want_access, tables, is_proc, no_errors);
unknown's avatar
unknown committed
5405
#endif
5406 5407 5408 5409

  return FALSE;
}

5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424

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

5425 5426
bool check_some_routine_access(THD *thd, const char *db, const char *name,
                               bool is_proc)
5427 5428
{
  ulong save_priv;
5429
  if (thd->security_ctx->master_access & SHOW_PROC_ACLS)
5430
    return FALSE;
5431 5432 5433 5434 5435
  /*
    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) ||
5436 5437
      (save_priv & SHOW_PROC_ACLS))
    return FALSE;
5438
  return check_routine_level_acl(thd, db, name, is_proc);
5439 5440 5441
}


5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466
/*
  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,
5467 5468
                        &table->grant.privilege, 0, 1,
                        test(table->schema_table)) &&
5469 5470 5471 5472 5473 5474 5475 5476 5477
          !grant_option || !check_grant(thd, access, table, 0, 1, 1))
        DBUG_RETURN(0);
    }
  }
  DBUG_PRINT("exit",("no matching access rights"));
  DBUG_RETURN(1);
}


5478 5479
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
5480 5481 5482 5483
{
  int error=0;
  if (table_list)
  {
5484
    /* Check that all tables use the current database */
5485
    TABLE_LIST *tmp;
unknown's avatar
VIEW  
unknown committed
5486
    for (tmp= table_list; tmp; tmp= tmp->next_local)
5487 5488 5489 5490
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
5491
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
unknown's avatar
unknown committed
5492
			     table_list,0);
5493 5494 5495 5496
  }
  return error;
}

unknown's avatar
unknown committed
5497 5498 5499

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
unknown's avatar
VIEW  
unknown committed
5500
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
5501 5502 5503 5504 5505
  {
    if (!tables->db)
    {
      if (!(tables->db=thd->db))
      {
unknown's avatar
unknown committed
5506 5507
	my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                   MYF(0));                     /* purecov: tested */
unknown's avatar
unknown committed
5508 5509 5510 5511 5512 5513
	return TRUE;				/* purecov: tested */
      }
    }
  }
  return FALSE;
}
5514

5515

unknown's avatar
unknown committed
5516 5517 5518 5519 5520 5521 5522 5523 5524 5525
/****************************************************************************
	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
5526 5527 5528 5529
#ifndef DBUG_OFF
long max_stack_used;
#endif

5530
#ifndef EMBEDDED_LIBRARY
5531 5532 5533 5534 5535 5536 5537 5538
/*
  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
5539 5540
{
  long stack_used;
5541
  DBUG_ASSERT(thd == current_thd);
unknown's avatar
unknown committed
5542
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
unknown's avatar
unknown committed
5543
      (long) (thread_stack - margin))
unknown's avatar
unknown committed
5544
  {
5545 5546 5547
    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));
5548
    thd->fatal_error();
unknown's avatar
unknown committed
5549 5550
    return 1;
  }
unknown's avatar
unknown committed
5551 5552 5553
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
unknown's avatar
unknown committed
5554 5555
  return 0;
}
5556
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
5557 5558 5559 5560

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

5561
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
unknown's avatar
unknown committed
5562 5563
{
  LEX	*lex=current_lex;
5564
  ulong old_info=0;
unknown's avatar
unknown committed
5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590
  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;
}


/****************************************************************************
5591
  Initialize global thd variables needed for query
unknown's avatar
unknown committed
5592 5593
****************************************************************************/

5594
void
unknown's avatar
unknown committed
5595
mysql_init_query(THD *thd, uchar *buf, uint length)
unknown's avatar
unknown committed
5596 5597
{
  DBUG_ENTER("mysql_init_query");
unknown's avatar
unknown committed
5598
  lex_start(thd, buf, length);
5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619
  mysql_reset_thd_for_next_command(thd);
  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");
5620
  thd->free_list= 0;
5621
  thd->select_number= 1;
unknown's avatar
unknown committed
5622
  thd->last_insert_id_used= thd->query_start_used= thd->insert_id_used=0;
5623
  thd->is_fatal_error= thd->time_zone_used= 0;
unknown's avatar
unknown committed
5624
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
unknown's avatar
unknown committed
5625 5626
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
5627
  DBUG_ASSERT(thd->security_ctx== &thd->main_security_ctx);
unknown's avatar
unknown committed
5628
  thd->tmp_table_used= 0;
5629 5630
  if (!thd->in_sub_stmt)
  {
5631
    if (opt_bin_log)
5632
    {
5633
      reset_dynamic(&thd->user_var_events);
5634 5635
      thd->user_var_events_alloc= thd->mem_root;
    }
5636
    thd->clear_error();
5637 5638 5639 5640
    thd->total_warn_count=0;			// Warnings for this query
    thd->rand_used= 0;
    thd->sent_row_count= thd->examined_row_count= 0;
  }
unknown's avatar
unknown committed
5641 5642 5643
  DBUG_VOID_RETURN;
}

5644

5645 5646 5647
void
mysql_init_select(LEX *lex)
{
unknown's avatar
unknown committed
5648
  SELECT_LEX *select_lex= lex->current_select;
unknown's avatar
unknown committed
5649
  select_lex->init_select();
5650
  lex->wild= 0;
5651 5652
  if (select_lex == &lex->select_lex)
  {
5653
    DBUG_ASSERT(lex->result == 0);
5654 5655
    lex->exchange= 0;
  }
5656 5657
}

5658

unknown's avatar
unknown committed
5659
bool
unknown's avatar
unknown committed
5660
mysql_new_select(LEX *lex, bool move_down)
5661
{
unknown's avatar
unknown committed
5662
  SELECT_LEX *select_lex;
5663
  THD *thd= lex->thd;
unknown's avatar
unknown committed
5664 5665
  DBUG_ENTER("mysql_new_select");

5666
  if (!(select_lex= new (thd->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
5667
    DBUG_RETURN(1);
5668
  select_lex->select_number= ++thd->select_number;
unknown's avatar
unknown committed
5669
  select_lex->parent_lex= lex; /* Used in init_query. */
unknown's avatar
unknown committed
5670 5671
  select_lex->init_query();
  select_lex->init_select();
unknown's avatar
unknown committed
5672 5673
  lex->nest_level++;
  select_lex->nest_level= lex->nest_level;
5674 5675 5676 5677 5678
  /*
    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
5679
  if (thd->stmt_arena->is_stmt_prepare())
5680
    select_lex->uncacheable|= UNCACHEABLE_PREPARE;
unknown's avatar
unknown committed
5681 5682
  if (move_down)
  {
unknown's avatar
unknown committed
5683
    SELECT_LEX_UNIT *unit;
5684
    lex->subqueries= TRUE;
unknown's avatar
unknown committed
5685
    /* first select_lex of subselect or derived table */
5686
    if (!(unit= new (thd->mem_root) SELECT_LEX_UNIT()))
unknown's avatar
unknown committed
5687
      DBUG_RETURN(1);
unknown's avatar
unknown committed
5688

unknown's avatar
unknown committed
5689 5690
    unit->init_query();
    unit->init_select();
5691
    unit->thd= thd;
unknown's avatar
unknown committed
5692
    unit->include_down(lex->current_select);
unknown's avatar
unknown committed
5693 5694
    unit->link_next= 0;
    unit->link_prev= 0;
5695
    unit->return_to= lex->current_select;
unknown's avatar
unknown committed
5696
    select_lex->include_down(unit);
5697 5698 5699 5700 5701
    /*
      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
5702 5703
  }
  else
unknown's avatar
unknown committed
5704
  {
5705
    Name_resolution_context *outer_context;
unknown's avatar
VIEW  
unknown committed
5706 5707
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
unknown's avatar
unknown committed
5708
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
unknown's avatar
unknown committed
5709
      DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
5710
    }
5711
    select_lex->include_neighbour(lex->current_select);
5712 5713 5714 5715 5716 5717
    /*
      we are not sure that we have one level of SELECTs above, so we take
      outer_context address from first select of unit
    */
    outer_context=
      select_lex->master_unit()->first_select()->context.outer_context;
unknown's avatar
unknown committed
5718 5719 5720 5721 5722 5723 5724 5725
    SELECT_LEX_UNIT *unit= select_lex->master_unit();
    SELECT_LEX *fake= unit->fake_select_lex;
    if (!fake)
    {
      /*
	as far as we included SELECT_LEX for UNION unit should have
	fake SELECT_LEX for UNION processing
      */
5726
      if (!(fake= unit->fake_select_lex= new (thd->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
5727
        DBUG_RETURN(1);
unknown's avatar
unknown committed
5728 5729 5730
      fake->include_standalone(unit,
			       (SELECT_LEX_NODE**)&unit->fake_select_lex);
      fake->select_number= INT_MAX;
unknown's avatar
unknown committed
5731
      fake->parent_lex= lex; /* Used in init_query. */
unknown's avatar
unknown committed
5732 5733
      fake->make_empty_select();
      fake->linkage= GLOBAL_OPTIONS_TYPE;
5734
      fake->select_limit= 0;
5735 5736 5737 5738 5739

      fake->context.outer_context= outer_context;
      /* allow item list resolving in fake select for ORDER BY */
      fake->context.resolve_in_select_list= TRUE;
      fake->context.select_lex= fake;
unknown's avatar
unknown committed
5740 5741 5742 5743 5744
      /*
        Remove the name resolution context of the fake select from the
        context stack.
       */
      lex->pop_context();
unknown's avatar
unknown committed
5745
    }
5746
    select_lex->context.outer_context= outer_context;
unknown's avatar
unknown committed
5747
  }
unknown's avatar
unknown committed
5748

5749
  select_lex->master_unit()->global_parameters= select_lex;
5750
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
5751
  lex->current_select= select_lex;
5752 5753 5754 5755 5756
  /*
    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
5757
  DBUG_RETURN(0);
5758
}
unknown's avatar
unknown committed
5759

5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774
/*
  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)
{
5775
  THD *thd;
5776
  LEX *lex;
5777
  LEX_STRING tmp, null_lex_string;
5778 5779
  Item *var;
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
5780
  DBUG_ENTER("create_select_for_variable");
5781 5782

  thd= current_thd;
unknown's avatar
unknown committed
5783
  lex= thd->lex;
5784 5785 5786 5787
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
5788
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
5789 5790 5791 5792
  /*
    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
5793 5794 5795 5796 5797 5798
  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);
  }
5799 5800 5801
  DBUG_VOID_RETURN;
}

5802

unknown's avatar
unknown committed
5803 5804
void mysql_init_multi_delete(LEX *lex)
{
unknown's avatar
unknown committed
5805
  lex->sql_command=  SQLCOM_DELETE_MULTI;
unknown's avatar
unknown committed
5806
  mysql_init_select(lex);
5807 5808
  lex->select_lex.select_limit= 0;
  lex->unit.select_limit_cnt= HA_POS_ERROR;
unknown's avatar
unknown committed
5809
  lex->select_lex.table_list.save_and_clear(&lex->auxilliary_table_list);
5810
  lex->lock_option= using_update_log ? TL_READ_NO_INSERT : TL_READ;
unknown's avatar
VIEW  
unknown committed
5811 5812
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
unknown's avatar
unknown committed
5813
}
unknown's avatar
unknown committed
5814

5815 5816 5817 5818
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
5819

5820
void mysql_parse(THD *thd, char *inBuf, uint length)
unknown's avatar
unknown committed
5821 5822
{
  DBUG_ENTER("mysql_parse");
unknown's avatar
unknown committed
5823
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
5824
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
unknown's avatar
unknown committed
5825
  {
unknown's avatar
unknown committed
5826
    LEX *lex= thd->lex;
5827
    
5828 5829
    sp_cache_flush_obsolete(&thd->sp_proc_cache);
    sp_cache_flush_obsolete(&thd->sp_func_cache);
5830
    
5831
    if (!MYSQLparse((void *)thd) && ! thd->is_fatal_error)
unknown's avatar
unknown committed
5832
    {
unknown's avatar
unknown committed
5833
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5834
      if (mqh_used && thd->user_connect &&
5835
	  check_mqh(thd, lex->sql_command))
5836 5837 5838 5839
      {
	thd->net.error = 0;
      }
      else
unknown's avatar
unknown committed
5840
#endif
5841
      {
unknown's avatar
unknown committed
5842
	if (thd->net.report_error)
5843 5844
	{
	  if (thd->lex->sphead)
5845 5846 5847 5848
	  {
	    delete thd->lex->sphead;
	    thd->lex->sphead= NULL;
	  }
unknown's avatar
unknown committed
5849 5850
          if (thd->lex->et)
          {
unknown's avatar
unknown committed
5851
            thd->lex->et->free_sphead_on_delete= true;
5852 5853 5854
            /* alloced on thd->mem_root so no real memory free but dtor call */
            thd->lex->et->free_sp();
            thd->lex->et->deinit_mutexes();
unknown's avatar
unknown committed
5855 5856
            thd->lex->et= NULL;
          }
5857
	}
unknown's avatar
unknown committed
5858 5859
	else
	{
5860 5861 5862 5863 5864 5865 5866 5867 5868 5869
          /*
            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
5870 5871
          if (lex->found_semicolon &&
              (thd->query_length= (ulong)(lex->found_semicolon - thd->query)))
5872 5873
            thd->query_length--;
          /* Actually execute the query */
unknown's avatar
unknown committed
5874
	  mysql_execute_command(thd);
unknown's avatar
SCRUM  
unknown committed
5875
	  query_cache_end_of_result(thd);
unknown's avatar
unknown committed
5876
	}
5877
      }
5878
      lex->unit.cleanup();
unknown's avatar
unknown committed
5879 5880
    }
    else
5881 5882
    {
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
5883
			 thd->is_fatal_error));
unknown's avatar
unknown committed
5884
      query_cache_abort(&thd->net);
5885
      lex->unit.cleanup();
5886
      if (thd->lex->sphead)
5887
      {
unknown's avatar
unknown committed
5888
	/* Clean up after failed stored procedure/function */
5889 5890 5891
	delete thd->lex->sphead;
	thd->lex->sphead= NULL;
      }
unknown's avatar
unknown committed
5892 5893
      if (thd->lex->et)
      {
unknown's avatar
unknown committed
5894
        thd->lex->et->free_sphead_on_delete= true;
5895 5896
        lex->et->free_sp();
        lex->et->deinit_mutexes();
unknown's avatar
unknown committed
5897 5898
        thd->lex->et= NULL;
      }
5899
    }
unknown's avatar
unknown committed
5900
    thd->proc_info="freeing items";
5901
    thd->end_statement();
5902
    thd->cleanup_after_query();
5903
    DBUG_ASSERT(thd->change_list.is_empty());
unknown's avatar
unknown committed
5904
  }
unknown's avatar
unknown committed
5905 5906 5907 5908
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
5909
#ifdef HAVE_REPLICATION
5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920
/*
  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
5921
  LEX *lex= thd->lex;
5922
  bool error= 0;
unknown's avatar
unknown committed
5923
  DBUG_ENTER("mysql_test_parse_for_slave");
5924

unknown's avatar
unknown committed
5925
  mysql_init_query(thd, (uchar*) inBuf, length);
5926
  if (!MYSQLparse((void*) thd) && ! thd->is_fatal_error &&
5927
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
unknown's avatar
unknown committed
5928
    error= 1;                  /* Ignore question */
5929
  thd->end_statement();
5930
  thd->cleanup_after_query();
unknown's avatar
unknown committed
5931
  DBUG_RETURN(error);
5932
}
unknown's avatar
unknown committed
5933
#endif
unknown's avatar
unknown committed
5934

5935

unknown's avatar
unknown committed
5936

unknown's avatar
unknown committed
5937 5938 5939 5940 5941
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

unknown's avatar
unknown committed
5942
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
unknown's avatar
unknown committed
5943
		       char *length, char *decimals,
5944
		       uint type_modifier,
5945 5946
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
5947 5948
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
unknown's avatar
unknown committed
5949
		       uint uint_geom_type)
unknown's avatar
unknown committed
5950 5951
{
  register create_field *new_field;
unknown's avatar
unknown committed
5952
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
5953 5954 5955 5956
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
5957
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
unknown's avatar
unknown committed
5958 5959 5960 5961 5962
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
5963
    lex->key_list.push_back(new Key(Key::PRIMARY, NullS, HA_KEY_ALG_UNDEF,
5964
				    0, lex->col_list));
unknown's avatar
unknown committed
5965 5966 5967 5968 5969
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
5970
    lex->key_list.push_back(new Key(Key::UNIQUE, NullS, HA_KEY_ALG_UNDEF, 0,
unknown's avatar
unknown committed
5971 5972 5973 5974
				    lex->col_list));
    lex->col_list.empty();
  }

5975
  if (default_value)
unknown's avatar
unknown committed
5976
  {
5977
    /* 
unknown's avatar
unknown committed
5978 5979
      Default value should be literal => basic constants =>
      no need fix_fields()
5980 5981 5982
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
5983
    */
5984 5985 5986
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
5987
    {
5988
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
5989 5990 5991
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
unknown's avatar
unknown committed
5992
    {
5993
      default_value= 0;
5994 5995 5996
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
5997
	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
5998 5999 6000 6001 6002
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
6003
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
unknown's avatar
unknown committed
6004 6005 6006
      DBUG_RETURN(1);
    }
  }
6007 6008 6009

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
6010
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
6011 6012
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
6013

6014 6015 6016 6017 6018 6019
  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
6020
    char buf[32];
6021
    my_snprintf(buf, sizeof(buf), "TIMESTAMP(%s)", length);
6022
    WARN_DEPRECATED(thd, "5.2", buf, "'TIMESTAMP'");
6023 6024
  }

6025 6026 6027 6028
  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
6029
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6030 6031 6032 6033 6034 6035

  lex->create_list.push_back(new_field);
  lex->last_field=new_field;
  DBUG_RETURN(0);
}

6036

unknown's avatar
unknown committed
6037 6038 6039 6040 6041 6042 6043 6044
/* Store position for column in ALTER TABLE .. ADD column */

void store_position_for_column(const char *name)
{
  current_lex->last_field->after=my_const_cast(char*) (name);
}

bool
unknown's avatar
unknown committed
6045
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
6046 6047 6048 6049
{
  ORDER *order;
  Item	**item_ptr;

unknown's avatar
unknown committed
6050
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
unknown's avatar
unknown committed
6051 6052 6053 6054 6055
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
unknown's avatar
unknown committed
6056
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
6057 6058 6059 6060 6061 6062 6063 6064
  return 0;
}


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

static void remove_escape(char *name)
{
6065 6066
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
6067 6068
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
6069
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
6070 6071 6072 6073 6074
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
6075 6076
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
unknown's avatar
unknown committed
6077 6078 6079 6080 6081 6082 6083 6084
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
6085
      name++;					// Skip '\\'
unknown's avatar
unknown committed
6086 6087 6088 6089 6090 6091 6092 6093 6094 6095
    *to++= *name;
  }
  *to=0;
}

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


unknown's avatar
unknown committed
6096
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
unknown's avatar
unknown committed
6097 6098 6099
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
unknown's avatar
unknown committed
6100
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
unknown's avatar
unknown committed
6101
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6102 6103
  order->item_ptr= item;
  order->item= &order->item_ptr;
unknown's avatar
unknown committed
6104 6105 6106
  order->asc = asc;
  order->free_me=0;
  order->used=0;
6107
  order->counter_used= 0;
unknown's avatar
unknown committed
6108
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
6109 6110 6111 6112
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131
/*
  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
    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
6132 6133
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
6134
					     LEX_STRING *alias,
unknown's avatar
unknown committed
6135 6136
					     ulong table_options,
					     thr_lock_type lock_type,
6137 6138
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
unknown's avatar
unknown committed
6139
                                             LEX_STRING *option)
unknown's avatar
unknown committed
6140 6141
{
  register TABLE_LIST *ptr;
unknown's avatar
unknown committed
6142
  TABLE_LIST *previous_table_ref; /* The table preceding the current one. */
unknown's avatar
unknown committed
6143
  char *alias_str;
6144
  LEX *lex= thd->lex;
unknown's avatar
unknown committed
6145
  DBUG_ENTER("add_table_to_list");
6146
  LINT_INIT(previous_table_ref);
unknown's avatar
unknown committed
6147 6148 6149 6150

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
unknown's avatar
unknown committed
6151
  if (check_table_name(table->table.str,table->table.length))
unknown's avatar
unknown committed
6152
  {
6153
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
unknown's avatar
unknown committed
6154 6155
    DBUG_RETURN(0);
  }
unknown's avatar
unknown committed
6156 6157 6158 6159 6160
  if (table->db.str && check_db_name(table->db.str))
  {
    my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
    DBUG_RETURN(0);
  }
unknown's avatar
unknown committed
6161 6162

  if (!alias)					/* Alias is case sensitive */
6163 6164 6165
  {
    if (table->sel)
    {
unknown's avatar
unknown committed
6166 6167
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
6168 6169
      DBUG_RETURN(0);
    }
6170
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
6171
      DBUG_RETURN(0);
6172
  }
unknown's avatar
unknown committed
6173
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
6174
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
6175
  if (table->db.str)
6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186
  {
    ptr->db= table->db.str;
    ptr->db_length= table->db.length;
  }
  else if (thd->db)
  {
    ptr->db= thd->db;
    ptr->db_length= thd->db_length;
  }
  else
  {
6187 6188
    /* The following can't be "" as we may do 'casedn_str()' on it */
    ptr->db= empty_c_string;
6189 6190
    ptr->db_length= 0;
  }
unknown's avatar
unknown committed
6191
  if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
6192
    ptr->db= thd->strdup(ptr->db);
unknown's avatar
unknown committed
6193

6194
  ptr->alias= alias_str;
6195 6196
  if (lower_case_table_names && table->table.length)
    my_casedn_str(files_charset_info, table->table.str);
6197 6198
  ptr->table_name=table->table.str;
  ptr->table_name_length=table->table.length;
6199
  ptr->lock_type=   lock_type;
unknown's avatar
unknown committed
6200 6201
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
6202
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
6203
  ptr->derived=	    table->sel;
6204 6205
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
                                      information_schema_name.str))
6206
  {
6207
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
6208 6209 6210
    if (!schema_table ||
        (schema_table->hidden && 
         lex->orig_sql_command == SQLCOM_END))  // not a 'show' command
6211
    {
unknown's avatar
unknown committed
6212
      my_error(ER_UNKNOWN_TABLE, MYF(0),
6213
               ptr->table_name, information_schema_name.str);
6214 6215
      DBUG_RETURN(0);
    }
6216
    ptr->schema_table_name= ptr->table_name;
6217 6218
    ptr->schema_table= schema_table;
  }
6219
  ptr->select_lex=  lex->current_select;
unknown's avatar
unknown committed
6220
  ptr->cacheable_table= 1;
6221 6222 6223 6224 6225 6226
  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
6227
  ptr->option= option ? option->str : 0;
unknown's avatar
unknown committed
6228
  /* check that used name is unique */
6229
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
6230
  {
unknown's avatar
unknown committed
6231 6232 6233 6234
    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
6235
	 tables ;
unknown's avatar
VIEW  
unknown committed
6236
	 tables=tables->next_local)
unknown's avatar
unknown committed
6237
    {
6238 6239
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
6240
      {
6241
	my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
unknown's avatar
unknown committed
6242 6243
	DBUG_RETURN(0);				/* purecov: tested */
      }
unknown's avatar
unknown committed
6244 6245
    }
  }
unknown's avatar
unknown committed
6246 6247 6248
  /* Store the table reference preceding the current one. */
  if (table_list.elements > 0)
  {
6249 6250 6251
    /*
      table_list.next points to the last inserted TABLE_LIST->next_local'
      element
6252
      We don't use the offsetof() macro here to avoid warnings from gcc
6253
    */
6254 6255 6256
    previous_table_ref= (TABLE_LIST*) ((char*) table_list.next -
                                       ((char*) &(ptr->next_local) -
                                        (char*) ptr));
6257 6258 6259 6260 6261 6262 6263 6264
    /*
      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
6265
  }
6266

unknown's avatar
unknown committed
6267 6268 6269 6270 6271 6272
  /*
    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
6273
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
unknown's avatar
unknown committed
6274
  ptr->next_name_resolution_table= NULL;
6275
  /* Link table in global list (all used tables) */
6276
  lex->add_to_query_tables(ptr);
unknown's avatar
unknown committed
6277 6278 6279
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
6280

6281 6282 6283 6284
/*
  Initialize a new table list for a nested join

  SYNOPSIS
unknown's avatar
unknown committed
6285
    init_nested_join()
6286
    thd         current thread
6287

6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306
  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");
6307

6308 6309
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6310
    DBUG_RETURN(1);
6311 6312 6313
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333
  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
6334
    moves it one level up, eliminating the nest.
6335 6336 6337 6338 6339 6340 6341 6342 6343

  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;
6344
  NESTED_JOIN *nested_join;
6345
  DBUG_ENTER("end_nested_join");
6346

unknown's avatar
unknown committed
6347
  DBUG_ASSERT(embedding);
6348 6349 6350
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
6351
  nested_join= ptr->nested_join;
6352 6353 6354 6355 6356 6357 6358 6359 6360
  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;
  }
6361
  else if (nested_join->join_list.elements == 0)
unknown's avatar
unknown committed
6362 6363
  {
    join_list->pop();
6364
    ptr= 0;                                     // return value
unknown's avatar
unknown committed
6365
  }
6366 6367 6368 6369 6370 6371 6372 6373
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
6374
    nest_last_join()
6375 6376 6377 6378 6379 6380
    thd         current thread

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

  RETURN VALUE
6381 6382 6383
    0  Error
    #  Pointer to TABLE_LIST element created for the new nested join

6384 6385 6386 6387 6388 6389
*/

TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
6390
  List<TABLE_LIST> *embedded_list;
6391
  DBUG_ENTER("nest_last_join");
6392

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

6399 6400
  ptr->embedding= embedding;
  ptr->join_list= join_list;
6401
  embedded_list= &nested_join->join_list;
6402
  embedded_list->empty();
6403 6404

  for (uint i=0; i < 2; i++)
6405 6406 6407 6408 6409
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
unknown's avatar
unknown committed
6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422
    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.
      */
      if (table->join_using_fields)
      {
        ptr->join_using_fields= table->join_using_fields;
        table->join_using_fields= NULL;
      }
    }
6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462
  }
  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
6463 6464 6465

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488
    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
*/

6489
TABLE_LIST *st_select_lex::convert_right_join()
6490 6491
{
  TABLE_LIST *tab2= join_list->pop();
6492
  TABLE_LIST *tab1= join_list->pop();
6493 6494 6495 6496 6497 6498 6499 6500 6501
  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
6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514
/*
  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
6515
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
unknown's avatar
unknown committed
6516 6517 6518 6519 6520 6521
{
  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
6522 6523 6524
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
unknown's avatar
unknown committed
6525 6526 6527 6528 6529 6530 6531
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
6532

unknown's avatar
unknown committed
6533
/*
6534 6535
  Push a new name resolution context for a JOIN ... ON clause to the
  context stack of a query block.
unknown's avatar
unknown committed
6536 6537

  SYNOPSIS
6538
    push_new_name_resolution_context()
unknown's avatar
unknown committed
6539
    thd       pointer to current thread
unknown's avatar
unknown committed
6540
    left_op   left  operand of the JOIN
unknown's avatar
unknown committed
6541 6542 6543 6544
    right_op  rigth operand of the JOIN

  DESCRIPTION
    Create a new name resolution context for a JOIN ... ON clause,
6545 6546 6547
    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
6548 6549

  RETURN
6550 6551
    FALSE  if all is OK
    TRUE   if a memory allocation error occured
unknown's avatar
unknown committed
6552 6553
*/

6554 6555 6556
bool
push_new_name_resolution_context(THD *thd,
                                 TABLE_LIST *left_op, TABLE_LIST *right_op)
unknown's avatar
unknown committed
6557 6558
{
  Name_resolution_context *on_context;
6559
  if (!(on_context= new (thd->mem_root) Name_resolution_context))
6560
    return TRUE;
unknown's avatar
unknown committed
6561 6562 6563 6564 6565
  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();
6566
  return thd->lex->push_context(on_context);
unknown's avatar
unknown committed
6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586
}


/*
  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
6587
{
6588
  if (expr)
6589
  {
6590
    if (!b->on_expr)
unknown's avatar
unknown committed
6591
      b->on_expr= expr;
6592 6593
    else
    {
unknown's avatar
unknown committed
6594 6595 6596 6597 6598 6599
      /*
        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);
6600 6601
    }
    b->on_expr->top_level_item();
6602
  }
unknown's avatar
unknown committed
6603 6604 6605
}


6606
/*
unknown's avatar
unknown committed
6607 6608
  Mark that there is a NATURAL JOIN or JOIN ... USING between two
  tables.
6609 6610 6611

  SYNOPSIS
    add_join_natural()
unknown's avatar
unknown committed
6612 6613 6614 6615
    a			Left join argument
    b			Right join argument
    using_fields        Field names from USING clause
  
6616
  IMPLEMENTATION
unknown's avatar
unknown committed
6617 6618 6619 6620 6621 6622 6623 6624 6625 6626
    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
6627 6628 6629
    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
6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640

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

unknown's avatar
unknown committed
6643
void add_join_natural(TABLE_LIST *a, TABLE_LIST *b, List<String> *using_fields)
unknown's avatar
unknown committed
6644
{
unknown's avatar
unknown committed
6645 6646
  b->natural_join= a;
  b->join_using_fields= using_fields;
unknown's avatar
unknown committed
6647 6648
}

unknown's avatar
unknown committed
6649

6650
/*
6651 6652 6653 6654
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
6655
    thd			Thread handler (can be NULL!)
6656 6657 6658 6659 6660
    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
6661 6662 6663
                        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.
6664 6665 6666

  RETURN
    0	 ok
unknown's avatar
unknown committed
6667
    !=0  error.  thd->killed or thd->net.report_error is set
6668 6669
*/

6670 6671
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
unknown's avatar
unknown committed
6672 6673 6674
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
6675
  bool tmp_write_to_binlog= 1;
6676

6677
  if (thd && thd->in_sub_stmt)
6678 6679 6680 6681 6682
  {
    my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "FLUSH");
    return 1;
  }

unknown's avatar
SCRUM  
unknown committed
6683
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
6684 6685
  if (options & REFRESH_GRANT)
  {
6686 6687 6688 6689 6690 6691
    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)))
6692 6693
    {
      thd->thread_stack= (char*) &tmp_thd;
6694
      thd->store_globals();
6695
    }
6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707
    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;
    }
6708
    reset_mqh((LEX_USER *)NULL, TRUE);
unknown's avatar
unknown committed
6709
  }
unknown's avatar
SCRUM  
unknown committed
6710
#endif
unknown's avatar
unknown committed
6711 6712
  if (options & REFRESH_LOG)
  {
6713
    /*
unknown's avatar
unknown committed
6714
      Flush the normal query log, the update log, the binary log,
6715 6716
      the slow query log, the relay log (if it exists) and the log
      tables.
6717
    */
unknown's avatar
unknown committed
6718

6719
    /*
unknown's avatar
unknown committed
6720 6721 6722 6723
      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)
6724 6725
    */
    tmp_write_to_binlog= 0;
6726
    mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
unknown's avatar
unknown committed
6727
#ifdef HAVE_REPLICATION
6728
    pthread_mutex_lock(&LOCK_active_mi);
6729
    rotate_relay_log(active_mi);
6730
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
6731
#endif
6732 6733 6734 6735

    /* flush slow and general logs */
    logger.flush_logs(thd);

unknown's avatar
unknown committed
6736
    if (ha_flush_logs(NULL))
unknown's avatar
unknown committed
6737
      result=1;
unknown's avatar
unknown committed
6738 6739
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
6740
  }
unknown's avatar
unknown committed
6741
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
6742 6743
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
6744
    query_cache.pack();				// FLUSH QUERY CACHE
6745
    options &= ~REFRESH_QUERY_CACHE;    // Don't flush cache, just free memory
unknown's avatar
unknown committed
6746 6747 6748
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
6749
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
6750
  }
unknown's avatar
unknown committed
6751
#endif /*HAVE_QUERY_CACHE*/
6752 6753 6754 6755 6756
  /*
    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
6757
  {
6758
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
6759
    {
6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770
      /*
        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
6771
        {
6772 6773 6774 6775 6776
          if ((*lock_p)->type == TL_WRITE)
          {
            my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
            return 1;
          }
unknown's avatar
unknown committed
6777
        }
6778
      }
unknown's avatar
unknown committed
6779 6780 6781 6782
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
6783
      tmp_write_to_binlog= 0;
6784
      if (lock_global_read_lock(thd))
unknown's avatar
unknown committed
6785
	return 1;                               // Killed
6786 6787
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
unknown's avatar
unknown committed
6788
      if (make_global_read_lock_block_commit(thd)) // Killed
6789 6790 6791 6792 6793
      {
        /* Don't leave things in a half-locked state */
        unlock_global_read_lock(thd);
        return 1;
      }
unknown's avatar
unknown committed
6794
    }
6795 6796
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
6797
    my_dbopt_cleanup();
unknown's avatar
unknown committed
6798 6799 6800
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
unknown's avatar
unknown committed
6801
  if (thd && (options & REFRESH_STATUS))
unknown's avatar
unknown committed
6802
    refresh_status(thd);
unknown's avatar
unknown committed
6803 6804
  if (options & REFRESH_THREADS)
    flush_thread_cache();
unknown's avatar
unknown committed
6805
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
6806
  if (options & REFRESH_MASTER)
6807
  {
6808
    DBUG_ASSERT(thd);
6809
    tmp_write_to_binlog= 0;
6810
    if (reset_master(thd))
unknown's avatar
unknown committed
6811
    {
6812
      result=1;
unknown's avatar
unknown committed
6813 6814
      thd->fatal_error();                       // Ensure client get error
    }
6815
  }
6816
#endif
unknown's avatar
unknown committed
6817
#ifdef OPENSSL
6818 6819 6820 6821 6822 6823
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
unknown's avatar
unknown committed
6824
#ifdef HAVE_REPLICATION
6825 6826
 if (options & REFRESH_SLAVE)
 {
6827
   tmp_write_to_binlog= 0;
6828
   pthread_mutex_lock(&LOCK_active_mi);
6829
   if (reset_slave(thd, active_mi))
6830
     result=1;
6831
   pthread_mutex_unlock(&LOCK_active_mi);
6832
 }
6833
#endif
6834
 if (options & REFRESH_USER_RESOURCES)
unknown's avatar
unknown committed
6835
   reset_mqh((LEX_USER *) NULL);
unknown's avatar
unknown committed
6836
 *write_to_binlog= tmp_write_to_binlog;
6837
 return result;
unknown's avatar
unknown committed
6838 6839
}

6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851
/*
  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
6852
void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
unknown's avatar
unknown committed
6853 6854 6855
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
6856 6857
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
6858 6859
  while ((tmp=it++))
  {
unknown's avatar
unknown committed
6860 6861
    if (tmp->command == COM_DAEMON)
      continue;
unknown's avatar
unknown committed
6862 6863
    if (tmp->thread_id == id)
    {
6864 6865
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
6866 6867 6868
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
6869 6870
  if (tmp)
  {
6871 6872
    if ((thd->security_ctx->master_access & SUPER_ACL) ||
	!strcmp(thd->security_ctx->user, tmp->security_ctx->user))
6873
    {
unknown's avatar
SCRUM  
unknown committed
6874
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
6875 6876 6877 6878 6879 6880 6881
      error=0;
    }
    else
      error=ER_KILL_DENIED_ERROR;
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }

unknown's avatar
unknown committed
6882
  if (!error)
6883
    send_ok(thd);
unknown's avatar
unknown committed
6884
  else
unknown's avatar
unknown committed
6885
    my_error(error, MYF(0), id);
unknown's avatar
unknown committed
6886 6887
}

unknown's avatar
unknown committed
6888

unknown's avatar
unknown committed
6889 6890
/* Clear most status variables */

unknown's avatar
unknown committed
6891
static void refresh_status(THD *thd)
unknown's avatar
unknown committed
6892 6893
{
  pthread_mutex_lock(&LOCK_status);
unknown's avatar
unknown committed
6894 6895 6896 6897 6898

  /* We must update the global status before cleaning up the thread */
  add_to_status(&global_status_var, &thd->status_var);
  bzero((char*) &thd->status_var, sizeof(thd->status_var));

unknown's avatar
unknown committed
6899 6900
  for (SHOW_VAR *ptr= status_vars; ptr->name; ptr++)
    if (ptr->type == SHOW_LONG) // note that SHOW_LONG_NOFLUSH variables are not reset
6901
      *(ulong*) ptr->value= 0;
unknown's avatar
unknown committed
6902

unknown's avatar
unknown committed
6903 6904
  /* Reset the counters of all key caches (default and named). */
  process_key_caches(reset_key_cache_counters);
unknown's avatar
unknown committed
6905 6906
  pthread_mutex_unlock(&LOCK_status);
}
6907 6908 6909 6910


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

6911 6912
bool append_file_to_dir(THD *thd, const char **filename_ptr,
                        const char *table_name)
6913
{
6914
  char buff[FN_REFLEN],*ptr, *end;
6915 6916 6917 6918 6919 6920 6921
  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))
  {
6922
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
6923 6924 6925 6926
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
6927
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
6928
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
6929 6930
    return 1;					// End of memory
  *filename_ptr=ptr;
6931
  strxmov(ptr,buff,table_name,NullS);
6932 6933
  return 0;
}
6934

6935

6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949
/*
  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;
6950 6951
  LEX *lex= thd->lex;
  if (lex->current_select != &lex->select_lex)
6952 6953
  {
    char command[80];
6954 6955
    strmake(command, lex->yylval->symbol.str,
	    min(lex->yylval->symbol.length, sizeof(command)-1));
6956
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
6957 6958 6959 6960
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
6961

unknown's avatar
unknown committed
6962

unknown's avatar
unknown committed
6963
Comp_creator *comp_eq_creator(bool invert)
unknown's avatar
unknown committed
6964
{
unknown's avatar
unknown committed
6965
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
unknown's avatar
unknown committed
6966 6967
}

unknown's avatar
unknown committed
6968

unknown's avatar
unknown committed
6969
Comp_creator *comp_ge_creator(bool invert)
unknown's avatar
unknown committed
6970
{
unknown's avatar
unknown committed
6971
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
unknown's avatar
unknown committed
6972 6973
}

unknown's avatar
unknown committed
6974

unknown's avatar
unknown committed
6975
Comp_creator *comp_gt_creator(bool invert)
unknown's avatar
unknown committed
6976
{
unknown's avatar
unknown committed
6977
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
unknown's avatar
unknown committed
6978 6979
}

unknown's avatar
unknown committed
6980

unknown's avatar
unknown committed
6981
Comp_creator *comp_le_creator(bool invert)
unknown's avatar
unknown committed
6982
{
unknown's avatar
unknown committed
6983
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
unknown's avatar
unknown committed
6984 6985
}

unknown's avatar
unknown committed
6986

unknown's avatar
unknown committed
6987
Comp_creator *comp_lt_creator(bool invert)
unknown's avatar
unknown committed
6988
{
unknown's avatar
unknown committed
6989
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
unknown's avatar
unknown committed
6990 6991
}

unknown's avatar
unknown committed
6992

unknown's avatar
unknown committed
6993
Comp_creator *comp_ne_creator(bool invert)
unknown's avatar
unknown committed
6994
{
unknown's avatar
unknown committed
6995
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
unknown's avatar
unknown committed
6996
}
unknown's avatar
unknown committed
6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016


/*
  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
7017
  if ((cmp == &comp_eq_creator) && !all)       //  = ANY <=> IN
unknown's avatar
unknown committed
7018
    return new Item_in_subselect(left_expr, select_lex);
unknown's avatar
unknown committed
7019 7020

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

  Item_allany_subselect *it=
7024
    new Item_allany_subselect(left_expr, (*cmp)(all), select_lex, all);
unknown's avatar
unknown committed
7025
  if (all)
7026
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
unknown's avatar
unknown committed
7027

7028
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
unknown's avatar
unknown committed
7029
}
7030 7031


7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043
/*
  CREATE INDEX and DROP INDEX are implemented by calling ALTER TABLE with
  the 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.
*/

unknown's avatar
unknown committed
7044
bool mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
7045 7046
{
  List<create_field> fields;
7047 7048
  ALTER_INFO alter_info;
  alter_info.flags= ALTER_ADD_INDEX;
7049 7050 7051
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_create_index");
  bzero((char*) &create_info,sizeof(create_info));
unknown's avatar
unknown committed
7052
  create_info.db_type= (handlerton*) &default_hton;
7053
  create_info.default_table_charset= thd->variables.collation_database;
7054
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
7055
				&create_info, table_list,
7056
				fields, keys, 0, (ORDER*)0,
unknown's avatar
unknown committed
7057
				DUP_ERROR, 0, &alter_info, 1));
7058 7059 7060
}


unknown's avatar
unknown committed
7061
bool mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
7062 7063 7064 7065 7066 7067
{
  List<create_field> fields;
  List<Key> keys;
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_drop_index");
  bzero((char*) &create_info,sizeof(create_info));
unknown's avatar
unknown committed
7068
  create_info.db_type= (handlerton*) &default_hton;
7069
  create_info.default_table_charset= thd->variables.collation_database;
7070 7071
  alter_info->clear();
  alter_info->flags= ALTER_DROP_INDEX;
7072
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
7073
				&create_info, table_list,
7074
				fields, keys, 0, (ORDER*)0,
unknown's avatar
unknown committed
7075
				DUP_ERROR, 0, alter_info, 1));
7076
}
unknown's avatar
merge  
unknown committed
7077 7078


7079 7080 7081 7082 7083
/*
  Multi update query pre-check

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

unknown's avatar
unknown committed
7087
  RETURN VALUE
unknown's avatar
unknown committed
7088 7089
    FALSE OK
    TRUE  Error
7090
*/
unknown's avatar
unknown committed
7091

unknown's avatar
unknown committed
7092
bool multi_update_precheck(THD *thd, TABLE_LIST *tables)
7093 7094 7095 7096 7097
{
  const char *msg= 0;
  TABLE_LIST *table;
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
7098
  DBUG_ENTER("multi_update_precheck");
7099 7100 7101

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
7102
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7103
    DBUG_RETURN(TRUE);
7104 7105 7106 7107 7108
  }
  /*
    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
7109
  for (table= tables; table; table= table->next_local)
7110
  {
7111 7112 7113
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
7114 7115
                           &table->grant.privilege, 0, 1,
                           test(table->schema_table)) ||
7116 7117
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
unknown's avatar
unknown committed
7118
             (check_access(thd, SELECT_ACL, table->db,
7119 7120
                           &table->grant.privilege, 0, 0,
                           test(table->schema_table)) ||
unknown's avatar
unknown committed
7121
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
unknown's avatar
unknown committed
7122
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7123

unknown's avatar
VIEW  
unknown committed
7124
    table->table_in_first_from_clause= 1;
7125
  }
unknown's avatar
unknown committed
7126 7127 7128
  /*
    Is there tables of subqueries?
  */
7129
  if (&lex->select_lex != lex->all_selects_list || lex->time_zone_tables_used)
7130
  {
7131
    DBUG_PRINT("info",("Checking sub query list"));
unknown's avatar
VIEW  
unknown committed
7132
    for (table= tables; table; table= table->next_global)
7133
    {
unknown's avatar
unknown committed
7134 7135 7136
      if (!my_tz_check_n_skip_implicit_tables(&table,
                                              lex->time_zone_tables_used) &&
          !table->table_in_first_from_clause)
7137 7138
      {
	if (check_access(thd, SELECT_ACL, table->db,
7139 7140
			 &table->grant.privilege, 0, 0,
                         test(table->schema_table)) ||
unknown's avatar
unknown committed
7141
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
unknown's avatar
unknown committed
7142
	  DBUG_RETURN(TRUE);
7143 7144 7145 7146 7147 7148
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
7149
  else if (select_lex->select_limit)
7150 7151 7152 7153
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
unknown's avatar
unknown committed
7154
    DBUG_RETURN(TRUE);
7155
  }
unknown's avatar
unknown committed
7156
  DBUG_RETURN(FALSE);
7157 7158 7159 7160 7161 7162 7163
}

/*
  Multi delete query pre-check

  SYNOPSIS
    multi_delete_precheck()
unknown's avatar
unknown committed
7164
    thd			Thread handler
unknown's avatar
VIEW  
unknown committed
7165
    tables		Global/local table list
7166

unknown's avatar
unknown committed
7167
  RETURN VALUE
unknown's avatar
unknown committed
7168 7169
    FALSE OK
    TRUE  error
7170
*/
unknown's avatar
unknown committed
7171

7172
bool multi_delete_precheck(THD *thd, TABLE_LIST *tables)
7173 7174 7175 7176
{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  TABLE_LIST *aux_tables=
    (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
unknown's avatar
VIEW  
unknown committed
7177
  DBUG_ENTER("multi_delete_precheck");
unknown's avatar
unknown committed
7178

7179 7180 7181 7182 7183
  /* 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) ||
      check_table_access(thd,SELECT_ACL, tables,0) ||
      check_table_access(thd,DELETE_ACL, aux_tables,0))
unknown's avatar
unknown committed
7184
    DBUG_RETURN(TRUE);
7185 7186
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
unknown's avatar
unknown committed
7187 7188
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
unknown's avatar
unknown committed
7189
    DBUG_RETURN(TRUE);
7190
  }
7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217
  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;

  for (target_tbl= (TABLE_LIST *)lex->auxilliary_table_list.first;
       target_tbl; target_tbl= target_tbl->next_local)
7218
  {
7219
    lex->table_count++;
7220 7221
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
unknown's avatar
VIEW  
unknown committed
7222
    for (walk= tables; walk; walk= walk->next_local)
7223
    {
unknown's avatar
unknown committed
7224 7225 7226
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
7227 7228 7229 7230
	break;
    }
    if (!walk)
    {
7231
      my_error(ER_UNKNOWN_TABLE, MYF(0),
7232
               target_tbl->table_name, "MULTI DELETE");
unknown's avatar
unknown committed
7233
      DBUG_RETURN(TRUE);
7234
    }
unknown's avatar
unknown committed
7235 7236 7237 7238 7239
    if (!walk->derived)
    {
      target_tbl->table_name= walk->table_name;
      target_tbl->table_name_length= walk->table_name_length;
    }
unknown's avatar
unknown committed
7240
    walk->updating= target_tbl->updating;
unknown's avatar
unknown committed
7241
    walk->lock_type= target_tbl->lock_type;
unknown's avatar
VIEW  
unknown committed
7242
    target_tbl->correspondent_table= walk;	// Remember corresponding table
7243
  }
unknown's avatar
unknown committed
7244
  DBUG_RETURN(FALSE);
7245 7246 7247
}


unknown's avatar
unknown committed
7248 7249 7250 7251 7252
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
unknown's avatar
unknown committed
7253 7254
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7255 7256

  RETURN VALUE
unknown's avatar
unknown committed
7257 7258
    FALSE OK
    TRUE  Error
unknown's avatar
unknown committed
7259
*/
unknown's avatar
unknown committed
7260

unknown's avatar
unknown committed
7261
bool update_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7262 7263 7264 7265
{
  DBUG_ENTER("update_precheck");
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
  {
unknown's avatar
unknown committed
7266
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7267
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7268
  }
unknown's avatar
unknown committed
7269 7270
  DBUG_RETURN(check_db_used(thd, tables) ||
	       check_one_table_access(thd, UPDATE_ACL, tables));
unknown's avatar
unknown committed
7271 7272 7273 7274 7275 7276 7277 7278
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
unknown's avatar
unknown committed
7279 7280
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7281 7282

  RETURN VALUE
unknown's avatar
unknown committed
7283 7284
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
7285
*/
unknown's avatar
unknown committed
7286

unknown's avatar
unknown committed
7287
bool delete_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7288 7289 7290
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
unknown's avatar
unknown committed
7291
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7292
  /* Set privilege for the WHERE clause */
unknown's avatar
unknown committed
7293
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
unknown's avatar
unknown committed
7294
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
7295 7296 7297 7298 7299 7300 7301 7302
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
unknown's avatar
unknown committed
7303 7304
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7305 7306

  RETURN VALUE
unknown's avatar
unknown committed
7307 7308
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
7309
*/
unknown's avatar
unknown committed
7310

unknown's avatar
merge  
unknown committed
7311
bool insert_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7312 7313 7314 7315
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

unknown's avatar
unknown committed
7316 7317 7318 7319
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
unknown's avatar
unknown committed
7320 7321 7322
  ulong privilege= (INSERT_ACL |
                    (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                    (lex->value_list.elements ? UPDATE_ACL : 0));
unknown's avatar
unknown committed
7323 7324

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

unknown's avatar
unknown committed
7327
  if (lex->update_list.elements != lex->value_list.elements)
unknown's avatar
unknown committed
7328
  {
unknown's avatar
unknown committed
7329
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7330
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7331
  }
unknown's avatar
unknown committed
7332
  DBUG_RETURN(FALSE);
7333
}
unknown's avatar
unknown committed
7334 7335 7336 7337 7338 7339 7340


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
unknown's avatar
unknown committed
7341 7342 7343
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
unknown's avatar
unknown committed
7344 7345

  RETURN VALUE
unknown's avatar
unknown committed
7346 7347
    FALSE   OK
    TRUE   Error
unknown's avatar
unknown committed
7348
*/
unknown's avatar
unknown committed
7349

unknown's avatar
unknown committed
7350 7351
bool create_table_precheck(THD *thd, TABLE_LIST *tables,
                           TABLE_LIST *create_table)
unknown's avatar
unknown committed
7352 7353
{
  LEX *lex= thd->lex;
7354 7355
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
unknown's avatar
merge  
unknown committed
7356
  bool error= TRUE;                                 // Error message is given
unknown's avatar
unknown committed
7357
  DBUG_ENTER("create_table_precheck");
7358 7359 7360

  want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
              CREATE_TMP_ACL : CREATE_ACL);
unknown's avatar
unknown committed
7361 7362
  lex->create_info.alias= create_table->alias;
  if (check_access(thd, want_priv, create_table->db,
7363 7364
		   &create_table->grant.privilege, 0, 0,
                   test(create_table->schema_table)) ||
unknown's avatar
unknown committed
7365 7366 7367
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
7368 7369 7370 7371 7372 7373 7374 7375 7376
    goto err;
  if (grant_option && want_priv != CREATE_TMP_ACL &&
      check_grant(thd, want_priv, create_table, 0, UINT_MAX, 0))
    goto err;

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

7377 7378
#ifdef NOT_NECESSARY_TO_CHECK_CREATE_TABLE_EXIST_WHEN_PREPARING_STATEMENT
    /* This code throws an ill error for CREATE TABLE t1 SELECT * FROM t1 */
7379
    /*
unknown's avatar
unknown committed
7380 7381 7382
      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).
7383
    */
unknown's avatar
unknown committed
7384
    if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
7385
    {
unknown's avatar
unknown committed
7386 7387 7388 7389
      /*
        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
7390
          find_table_in_global_list(tables, create_table->db,
7391
                                    create_table->table_name))
unknown's avatar
unknown committed
7392
      {
7393
	error= FALSE;
unknown's avatar
unknown committed
7394 7395 7396
        goto err;
      }
    }
7397
#endif
7398 7399 7400
    if (tables && check_table_access(thd, SELECT_ACL, tables,0))
      goto err;
  }
unknown's avatar
merge  
unknown committed
7401
  error= FALSE;
7402 7403 7404

err:
  DBUG_RETURN(error);
unknown's avatar
unknown committed
7405
}
unknown's avatar
unknown committed
7406 7407 7408 7409 7410 7411 7412


/*
  negate given expression

  SYNOPSIS
    negate_expression()
7413
    thd  thread handler
unknown's avatar
unknown committed
7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441
    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);
}
7442

7443 7444
/*
  Set the specified definer to the default value, which is the current user in
7445
  the thread.
7446 7447 7448 7449 7450 7451 7452
 
  SYNOPSIS
    get_default_definer()
    thd       [in] thread handler
    definer   [out] definer
*/
 
7453
void get_default_definer(THD *thd, LEX_USER *definer)
7454 7455 7456 7457 7458 7459 7460 7461 7462 7463
{
  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);
}

7464

7465
/*
7466
  Create default definer for the specified THD.
7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484

  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;

7485
  get_default_definer(thd, definer);
7486 7487

  return definer;
7488 7489
}

7490 7491

/*
unknown's avatar
unknown committed
7492
  Create definer with the given user and host names.
7493 7494

  SYNOPSIS
7495 7496 7497 7498
    create_definer()
    thd         [in] thread handler
    user_name   [in] user name
    host_name   [in] host name
7499 7500

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

7506
LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name)
7507
{
7508 7509 7510 7511
  LEX_USER *definer;

  /* Create and initialize. */

unknown's avatar
unknown committed
7512
  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
7513 7514 7515 7516 7517 7518
    return 0;

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

  return definer;
7519
}