sql_parse.cc 225 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"
unknown's avatar
unknown committed
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 71
static void remove_escape(char *name);

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

unknown's avatar
unknown committed
74 75 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
LEX_STRING command_name[]={
  (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
106 107
};

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

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

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

unknown's avatar
unknown committed
129 130 131 132 133
static void unlock_locked_tables(THD *thd)
{
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
134
    thd->locked_tables=0;			// Will be automatically closed
unknown's avatar
unknown committed
135 136 137 138
    close_thread_tables(thd);			// Free tables
  }
}

139

140
bool end_active_trans(THD *thd)
141
{
unknown's avatar
unknown committed
142
  int error=0;
143
  DBUG_ENTER("end_active_trans");
144
  if (unlikely(thd->in_sub_stmt))
145 146 147 148
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
149 150 151 152 153 154
  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
155
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
unknown's avatar
unknown committed
156
		      OPTION_TABLE_LOCK))
157
  {
158 159 160 161
    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;
162
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
163
    if (ha_commit(thd))
unknown's avatar
unknown committed
164
      error=1;
165
  }
166 167
  thd->options&= ~(OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE |
                   OPTION_KEEP_LOG);
168
  DBUG_RETURN(error);
169 170
}

unknown's avatar
unknown committed
171
bool begin_trans(THD *thd)
unknown's avatar
unknown committed
172 173
{
  int error=0;
174
  if (unlikely(thd->in_sub_stmt))
175 176 177 178
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    return 1;
  }
unknown's avatar
unknown committed
179 180 181 182 183 184 185 186 187 188
  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
  {
189
    LEX *lex= thd->lex;
190
    thd->options|= OPTION_BEGIN;
unknown's avatar
unknown committed
191 192
    thd->server_status|= SERVER_STATUS_IN_TRANS;
    if (lex->start_transaction_opt & MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT)
unknown's avatar
unknown committed
193
      error= ha_start_consistent_snapshot(thd);
unknown's avatar
unknown committed
194 195 196
  }
  return error;
}
197

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


210 211 212 213 214 215 216 217 218 219 220 221
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;
}

222 223
static HASH hash_user_connections;

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

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

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

272
}
273 274 275


/*
276 277
  Check if user exist and password supplied is correct. 

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

289
    Note, that host, user and passwd may point to communication buffer.
290
    Current implementation does not depend on that, but future changes
291 292 293
    should be done with this in mind; 'thd' is INOUT, all other params
    are 'IN'.

294
  RETURN VALUE
295 296
    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
297 298
   -1  access denied or handshake error; error is sent to client;
   >0  error, not sent to client
unknown's avatar
unknown committed
299 300
*/

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

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

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

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

unknown's avatar
unknown committed
426
      /* Why logging is performed before all checks've passed? */
unknown's avatar
unknown committed
427 428 429 430 431 432 433 434
      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
435

436
      /*
437 438 439
        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.
440
      */
441
      thd->main_security_ctx.db_access=0;
unknown's avatar
unknown committed
442 443

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

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

unknown's avatar
unknown committed
496
/*
unknown's avatar
unknown committed
497 498
  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
499 500
*/

501 502
extern "C" byte *get_key_conn(user_conn *buff, uint *length,
			      my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
503 504 505 506 507
{
  *length=buff->len;
  return (byte*) buff->user;
}

508
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
509 510 511 512
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
513
void init_max_user_conn(void)
unknown's avatar
unknown committed
514
{
unknown's avatar
unknown committed
515 516
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
517
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
518
		   0);
unknown's avatar
unknown committed
519 520 521
}


unknown's avatar
unknown committed
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
/*
  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
539 540
#ifndef NO_EMBEDDED_ACCESS_CHECKS

541
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
542
{
543
  int error=0;
544
  DBUG_ENTER("check_for_max_user_connections");
unknown's avatar
unknown committed
545

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

  end:
576 577
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
578
  (void) pthread_mutex_unlock(&LOCK_user_conn);
579
  DBUG_RETURN(error);
unknown's avatar
unknown committed
580
}
unknown's avatar
unknown committed
581
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
582

unknown's avatar
unknown committed
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
/*
  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.
*/

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

615

unknown's avatar
unknown committed
616 617 618 619 620
void free_max_user_conn(void)
{
  hash_free(&hash_user_connections);
}

unknown's avatar
unknown committed
621

622 623 624
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
unknown's avatar
unknown committed
625 626 627

  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
628 629 630 631 632 633

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

unknown's avatar
unknown committed
636
char  uc_update_queries[SQLCOM_END+1];
637 638 639

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

642 643 644
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
645 646 647 648 649 650
  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;
651 652 653 654 655
  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;
656 657
  uc_update_queries[SQLCOM_REPLACE]=2;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=2;
658 659 660 661
  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
662 663
  uc_update_queries[SQLCOM_CREATE_VIEW]=1;
  uc_update_queries[SQLCOM_DROP_VIEW]=1;
unknown's avatar
unknown committed
664 665 666
  uc_update_queries[SQLCOM_CREATE_EVENT]=1;
  uc_update_queries[SQLCOM_ALTER_EVENT]=1;
  uc_update_queries[SQLCOM_DROP_EVENT]=1;  
667 668
}

unknown's avatar
unknown committed
669 670
bool is_update_query(enum enum_sql_command command)
{
unknown's avatar
unknown committed
671
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
672
  return uc_update_queries[command] != 0;
unknown's avatar
unknown committed
673
}
674

unknown's avatar
unknown committed
675
/*
676 677
  Reset per-hour user resource limits when it has been more than
  an hour since they were last checked
unknown's avatar
unknown committed
678

679 680 681 682
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
unknown's avatar
unknown committed
683

684 685 686 687
  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.
*/
688

689
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
690
{
unknown's avatar
unknown committed
691
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
692
  DBUG_ENTER("time_out_user_resource_limits");
unknown's avatar
unknown committed
693

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

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

unknown's avatar
unknown committed
753

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

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

unknown's avatar
unknown committed
794
/*
795
    Perform handshake, authorize client and update thd ACL variables.
796
  SYNOPSIS
797
    check_connection()
798
    thd  thread handle
799 800

  RETURN
801
     0  success, OK is sent to user, thd is updated.
802 803
    -1  error, which is sent to user
   > 0  error code (not sent to user)
unknown's avatar
unknown committed
804 805
*/

unknown's avatar
unknown committed
806 807
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
unknown's avatar
unknown committed
808
{
809
  uint connect_errors= 0;
unknown's avatar
unknown committed
810
  NET *net= &thd->net;
unknown's avatar
unknown committed
811 812
  ulong pkt_len= 0;
  char *end;
813

814 815
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));
unknown's avatar
unknown committed
816
#ifdef SIGNAL_WITH_VIO_CLOSE
817
  thd->set_active_vio(net->vio);
unknown's avatar
unknown committed
818
#endif
819

820
  if (!thd->main_security_ctx.host)         // If TCP/IP connection
unknown's avatar
unknown committed
821
  {
822
    char ip[30];
823

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

869 870 871 872 873
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
874 875
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
876
      client_flags |= CLIENT_SSL;       /* Wow, SSL is available! */
unknown's avatar
unknown committed
877
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
878

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

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

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

  if (end >= (char*) net->read_pos+ pkt_len +2)
unknown's avatar
unknown committed
997
  {
998 999
    inc_host_errors(&thd->remote.sin_addr);
    return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
1000 1001 1002
  }

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
1003
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
1004
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
1005 1006
      opt_using_transactions)
    net->return_status= &thd->server_status;
unknown's avatar
unknown committed
1007
  net->read_timeout=(uint) thd->variables.net_read_timeout;
unknown's avatar
unknown committed
1008

1009 1010
  char *user= end;
  char *passwd= strend(user)+1;
1011
  uint user_len= passwd - user - 1;
unknown's avatar
unknown committed
1012
  char *db= passwd;
1013
  char db_buff[NAME_LEN+1];                     // buffer to store db in utf8
unknown's avatar
unknown committed
1014
  char user_buff[USERNAME_LENGTH+1];		// buffer to store user in utf8
1015 1016 1017
  uint dummy_errors;

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

unknown's avatar
unknown committed
1028
  if (passwd + passwd_len + db_len > (char *)net->read_pos + pkt_len)
unknown's avatar
unknown committed
1029 1030 1031 1032
  {
    inc_host_errors(&thd->remote.sin_addr);
    return ER_HANDSHAKE_ERROR;
  }
unknown's avatar
unknown committed
1033

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

1044 1045 1046
  user_buff[user_len= copy_and_convert(user_buff, sizeof(user_buff)-1,
                                       system_charset_info, user, user_len,
                                       thd->charset(), &dummy_errors)]= '\0';
1047
  user= user_buff;
unknown's avatar
unknown committed
1048

1049 1050 1051 1052 1053 1054 1055 1056
  /* If username starts and ends in "'", chop them off */
  if (user_len > 1 && user[0] == '\'' && user[user_len - 1] == '\'')
  {
    user[user_len-1]= 0;
    user++;
    user_len-= 2;
  }

1057 1058 1059
  if (thd->main_security_ctx.user)
    x_free(thd->main_security_ctx.user);
  if (!(thd->main_security_ctx.user= my_strdup(user, MYF(0))))
1060
    return (ER_OUT_OF_RESOURCES);
unknown's avatar
unknown committed
1061
  return check_user(thd, COM_CONNECT, passwd, passwd_len, db, TRUE);
unknown's avatar
unknown committed
1062 1063
}

1064

1065 1066
void execute_init_command(THD *thd, sys_var_str *init_command_var,
			  rw_lock_t *var_mutex)
unknown's avatar
unknown committed
1067 1068 1069 1070
{
  Vio* save_vio;
  ulong save_client_capabilities;

1071 1072 1073 1074 1075 1076 1077 1078 1079
  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
1080 1081
  save_client_capabilities= thd->client_capabilities;
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
1082 1083 1084 1085
  /*
    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
1086 1087
  save_vio= thd->net.vio;
  thd->net.vio= 0;
1088
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
1089
  dispatch_command(COM_QUERY, thd, thd->query, thd->query_length+1);
1090
  rw_unlock(var_mutex);
unknown's avatar
unknown committed
1091 1092 1093 1094 1095
  thd->client_capabilities= save_client_capabilities;
  thd->net.vio= save_vio;
}


1096
pthread_handler_t handle_one_connection(void *arg)
unknown's avatar
unknown committed
1097 1098 1099
{
  THD *thd=(THD*) arg;
  uint launch_time  =
unknown's avatar
unknown committed
1100
    (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
unknown's avatar
unknown committed
1101 1102 1103 1104 1105
  if (launch_time >= slow_launch_time)
    statistic_increment(slow_launch_threads,&LOCK_status );

  pthread_detach_this_thread();

unknown's avatar
unknown committed
1106
#if !defined( __WIN__) // Win32 calls this in pthread_create
unknown's avatar
unknown committed
1107
  /* The following calls needs to be done before we call DBUG_ macros */
1108
  if (!(test_flags & TEST_NO_THREADS) & my_thread_init())
unknown's avatar
unknown committed
1109
  {
1110
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
1111
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1112 1113 1114 1115 1116
    end_thread(thd,0);
    return 0;
  }
#endif

1117 1118 1119 1120 1121 1122 1123
  /*
    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
1124 1125
  DBUG_PRINT("info", ("handle_one_connection called by thread %d\n",
		      thd->thread_id));
unknown's avatar
unknown committed
1126
  /* now that we've called my_thread_init(), it is safe to call DBUG_* */
unknown's avatar
unknown committed
1127

unknown's avatar
unknown committed
1128
#if defined(__WIN__)
unknown's avatar
unknown committed
1129
  init_signals();
unknown's avatar
unknown committed
1130
#elif !defined(__NETWARE__)
unknown's avatar
unknown committed
1131 1132 1133 1134
  sigset_t set;
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif
1135
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1136 1137
  if (thd->store_globals())
  {
1138
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
1139
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1140 1141 1142 1143 1144 1145 1146 1147
    end_thread(thd,0);
    return 0;
  }

  do
  {
    int error;
    NET *net= &thd->net;
1148
    Security_context *sctx= thd->security_ctx;
1149
    net->no_send_error= 0;
unknown's avatar
unknown committed
1150

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

unknown's avatar
unknown committed
1170
    thd->version= refresh_version;
1171
    thd->proc_info= 0;
1172
    thd->command= COM_SLEEP;
1173 1174
    thd->set_time();
    thd->init_for_queries();
unknown's avatar
unknown committed
1175

1176
    if (sys_init_connect.value_length && !(sctx->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1177
    {
1178 1179
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
unknown's avatar
unknown committed
1180
	thd->killed= THD::KILL_CONNECTION;
1181 1182 1183
      thd->proc_info=0;
      thd->set_time();
      thd->init_for_queries();
unknown's avatar
unknown committed
1184 1185
    }

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

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

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

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

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

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

  thd->proc_info=0;
  thd->version=refresh_version;
1266 1267
  thd->security_ctx->priv_user=
    thd->security_ctx->user= (char*) my_strdup("boot", MYF(MY_WME));
unknown's avatar
unknown committed
1268
  thd->security_ctx->priv_host[0]=0;
unknown's avatar
unknown committed
1269

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

  /* thd->fatal_error should be set in case something went wrong */
end:
1319 1320 1321 1322 1323 1324
  bootstrap_error= thd->is_fatal_error;

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

unknown's avatar
unknown committed
1325
#ifndef EMBEDDED_LIBRARY
1326 1327 1328
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1329
  (void) pthread_cond_broadcast(&COND_thread_count);
1330 1331
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1332
#endif
1333
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1334 1335
}

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

1338
void free_items(Item *item)
unknown's avatar
unknown committed
1339
{
unknown's avatar
unknown committed
1340
  Item *next;
unknown's avatar
unknown committed
1341
  DBUG_ENTER("free_items");
unknown's avatar
unknown committed
1342 1343 1344
  for (; item ; item=next)
  {
    next=item->next;
1345
    item->delete_self();
unknown's avatar
unknown committed
1346
  }
unknown's avatar
unknown committed
1347
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1348 1349
}

1350 1351 1352 1353
    /* This works because items are allocated with sql_alloc() */

void cleanup_items(Item *item)
{
unknown's avatar
unknown committed
1354
  DBUG_ENTER("cleanup_items");  
1355 1356
  for (; item ; item=item->next)
    item->cleanup();
unknown's avatar
unknown committed
1357
  DBUG_VOID_RETURN;
1358 1359
}

unknown's avatar
unknown committed
1360 1361 1362 1363 1364 1365 1366
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;
1367
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1368
    DBUG_RETURN(1); // out of memory
unknown's avatar
VIEW  
unknown committed
1369
  table_list->db= db;
1370
  table_list->table_name= table_list->alias= tbl_name;
unknown's avatar
VIEW  
unknown committed
1371 1372
  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
1373

1374 1375
  if (!db || check_db_name(db))
  {
1376
    my_error(ER_WRONG_DB_NAME ,MYF(0), db ? db : "NULL");
1377 1378
    goto err;
  }
1379
  if (lower_case_table_names)
1380
    my_casedn_str(files_charset_info, tbl_name);
1381
  remove_escape(table_list->table_name);
1382 1383 1384 1385

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

unknown's avatar
unknown committed
1386
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1387 1388
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1389
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1390
  thd->query = tbl_name;
unknown's avatar
unknown committed
1391
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1392
  {
1393
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1394 1395
    goto err;
  }
unknown's avatar
unknown committed
1396
  net_flush(&thd->net);
1397
  if ((error= table->file->dump(thd,fd)))
1398
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1399

unknown's avatar
unknown committed
1400
err:
unknown's avatar
unknown committed
1401
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1402 1403
}

unknown's avatar
unknown committed
1404 1405 1406 1407
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1408
    end_trans()
unknown's avatar
unknown committed
1409 1410 1411 1412 1413 1414 1415
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1416
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
unknown's avatar
unknown committed
1417 1418 1419
{
  bool do_release= 0;
  int res= 0;
1420
  DBUG_ENTER("end_trans");
unknown's avatar
unknown committed
1421

1422
  if (unlikely(thd->in_sub_stmt))
1423 1424 1425 1426
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
1427 1428 1429 1430 1431 1432
  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
1433 1434 1435 1436 1437 1438 1439 1440
  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;
1441
    res= ha_commit(thd);
1442 1443
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE |
                             OPTION_KEEP_LOG);
unknown's avatar
unknown committed
1444 1445
    break;
  case COMMIT_RELEASE:
unknown's avatar
unknown committed
1446
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1447 1448 1449 1450 1451 1452
  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
1453
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1454 1455 1456 1457
  case ROLLBACK:
  case ROLLBACK_AND_CHAIN:
  {
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
unknown's avatar
unknown committed
1458
    if (ha_rollback(thd))
unknown's avatar
unknown committed
1459
      res= -1;
1460 1461
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE |
                             OPTION_KEEP_LOG);
unknown's avatar
unknown committed
1462 1463 1464 1465 1466 1467 1468 1469 1470
    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
1471

unknown's avatar
unknown committed
1472 1473 1474
  if (res < 0)
    my_error(thd->killed_errno(), MYF(0));
  else if ((res == 0) && do_release)
unknown's avatar
unknown committed
1475 1476
    thd->killed= THD::KILL_CONNECTION;

unknown's avatar
unknown committed
1477 1478
  DBUG_RETURN(res);
}
unknown's avatar
unknown committed
1479

1480
#ifndef EMBEDDED_LIBRARY
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491

/*
  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
1492 1493 1494
bool do_command(THD *thd)
{
  char *packet;
unknown's avatar
unknown committed
1495 1496
  uint old_timeout;
  ulong packet_length;
unknown's avatar
unknown committed
1497 1498 1499 1500 1501
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
unknown's avatar
unknown committed
1502 1503 1504 1505
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1506
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1507 1508

  packet=0;
unknown's avatar
unknown committed
1509
  old_timeout=net->read_timeout;
unknown's avatar
unknown committed
1510
  /* Wait max for 8 hours */
unknown's avatar
unknown committed
1511
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
unknown's avatar
unknown committed
1512
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1513 1514 1515 1516

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1517 1518 1519 1520 1521
    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)
1522 1523
    {
      statistic_increment(aborted_threads,&LOCK_status);
1524
      DBUG_RETURN(TRUE);			// We have to close it.
1525
    }
1526
    net_send_error(thd, net->last_errno, NullS);
1527
    net->error= 0;
1528
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1529 1530 1531 1532 1533
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1534 1535
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
1536 1537 1538
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
1539
  }
unknown's avatar
unknown committed
1540
  net->read_timeout=old_timeout;		// restore it
1541 1542 1543 1544 1545 1546 1547 1548 1549
  /*
    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
1550
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1551
}
1552
#endif  /* EMBEDDED_LIBRARY */
1553

1554

1555 1556
/*
   Perform one connection-level (COM_XXXX) command.
1557

1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
  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
*/
1571

1572 1573 1574 1575
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1576
  bool error= 0;
1577 1578
  DBUG_ENTER("dispatch_command");

1579 1580 1581
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
    thd->killed= THD::NOT_KILLED;

1582
  thd->command=command;
unknown's avatar
unknown committed
1583
  /*
1584 1585
    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
1586
  */
1587
  thd->enable_slow_log= TRUE;
1588
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
unknown's avatar
unknown committed
1589
  thd->set_time();
unknown's avatar
unknown committed
1590 1591 1592
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
1593
    next_query_id();
unknown's avatar
unknown committed
1594
  thread_running++;
1595
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1596
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1597

1598 1599
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1600
  switch (command) {
unknown's avatar
unknown committed
1601
  case COM_INIT_DB:
unknown's avatar
unknown committed
1602 1603
  {
    LEX_STRING tmp;
1604 1605
    statistic_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB],
			&LOCK_status);
unknown's avatar
unknown committed
1606 1607
    thd->convert_string(&tmp, system_charset_info,
			packet, strlen(packet), thd->charset());
1608 1609
    if (!mysql_change_db(thd, tmp.str, FALSE))
    {
unknown's avatar
unknown committed
1610
      general_log_print(thd, command, "%s",thd->db);
1611 1612
      send_ok(thd);
    }
unknown's avatar
unknown committed
1613 1614
    break;
  }
unknown's avatar
unknown committed
1615
#ifdef HAVE_REPLICATION
1616 1617
  case COM_REGISTER_SLAVE:
  {
1618
    if (!register_slave(thd, (uchar*)packet, packet_length))
1619
      send_ok(thd);
1620 1621
    break;
  }
1622
#endif
unknown's avatar
unknown committed
1623
  case COM_TABLE_DUMP:
1624 1625 1626
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
unknown's avatar
unknown committed
1627
    if (db_len >= packet_length || db_len > NAME_LEN)
unknown's avatar
unknown committed
1628
    {
unknown's avatar
unknown committed
1629
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
1630 1631
      break;
    }
1632
    uint tbl_len= *(uchar*) (packet + db_len + 1);
unknown's avatar
unknown committed
1633 1634
    if (db_len+tbl_len+2 > packet_length || tbl_len > NAME_LEN)
    {
unknown's avatar
unknown committed
1635
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
1636 1637
      break;
    }
1638

1639
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1640
    thd->enable_slow_log= opt_log_slow_admin_statements;
1641
    db= thd->alloc(db_len + tbl_len + 2);
1642 1643 1644 1645 1646
    if (!db)
    {
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
      break;
    }
1647 1648
    tbl_name= strmake(db, packet + 1, db_len)+1;
    strmake(tbl_name, packet + db_len + 2, tbl_len);
unknown's avatar
unknown committed
1649
    mysql_table_dump(thd, db, tbl_name, -1);
1650 1651
    break;
  }
unknown's avatar
unknown committed
1652 1653
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1654
    thd->change_user();
1655
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1656

1657
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1658
    char *user= (char*) packet;
unknown's avatar
unknown committed
1659
    char *passwd= strend(user)+1;
1660
    /*
unknown's avatar
unknown committed
1661 1662 1663 1664
      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).
    */
1665
    char db_buff[NAME_LEN+1];                 // buffer to store db in utf8
unknown's avatar
unknown committed
1666
    char *db= passwd;
1667
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
unknown's avatar
unknown committed
1668 1669
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1670
#ifndef EMBEDDED_LIBRARY
1671
    /* Small check for incoming packet */
unknown's avatar
unknown committed
1672
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1673
    {
unknown's avatar
unknown committed
1674
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1675 1676
      break;
    }
1677
#endif
1678
    /* Convert database name to utf8 */
1679
    uint dummy_errors;
1680 1681
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1682
                             thd->charset(), &dummy_errors)]= 0;
1683
    db= db_buff;
unknown's avatar
unknown committed
1684

1685 1686 1687
    /* Save user and privileges */
    uint save_db_length= thd->db_length;
    char *save_db= thd->db;
1688
    Security_context save_security_ctx= *thd->security_ctx;
unknown's avatar
unknown committed
1689
    USER_CONN *save_user_connect= thd->user_connect;
1690 1691

    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
1692
    {
1693
      thd->security_ctx->user= save_security_ctx.user;
unknown's avatar
unknown committed
1694
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1695 1696
      break;
    }
unknown's avatar
unknown committed
1697

unknown's avatar
unknown committed
1698 1699
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1700
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1701

1702 1703
    if (res)
    {
1704
      /* authentication failure, we shall restore old user */
1705
      if (res > 0)
unknown's avatar
unknown committed
1706
        my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1707 1708
      x_free(thd->security_ctx->user);
      *thd->security_ctx= save_security_ctx;
unknown's avatar
unknown committed
1709
      thd->user_connect= save_user_connect;
1710 1711 1712 1713 1714 1715
      thd->db= save_db;
      thd->db_length= save_db_length;
    }
    else
    {
      /* we've authenticated new user */
unknown's avatar
unknown committed
1716 1717
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1718
      x_free((gptr) save_db);
1719
      x_free((gptr)  save_security_ctx.user);
1720
    }
unknown's avatar
unknown committed
1721 1722
    break;
  }
1723
  case COM_STMT_EXECUTE:
unknown's avatar
unknown committed
1724
  {
1725
    mysql_stmt_execute(thd, packet, packet_length);
unknown's avatar
unknown committed
1726 1727
    break;
  }
1728
  case COM_STMT_FETCH:
1729 1730 1731 1732
  {
    mysql_stmt_fetch(thd, packet, packet_length);
    break;
  }
1733
  case COM_STMT_SEND_LONG_DATA:
unknown's avatar
unknown committed
1734
  {
1735
    mysql_stmt_get_longdata(thd, packet, packet_length);
unknown's avatar
unknown committed
1736 1737
    break;
  }
1738
  case COM_STMT_PREPARE:
unknown's avatar
unknown committed
1739
  {
1740
    mysql_stmt_prepare(thd, packet, packet_length);
unknown's avatar
unknown committed
1741 1742
    break;
  }
1743
  case COM_STMT_CLOSE:
unknown's avatar
unknown committed
1744
  {
1745
    mysql_stmt_close(thd, packet);
unknown's avatar
unknown committed
1746 1747
    break;
  }
1748
  case COM_STMT_RESET:
1749 1750 1751 1752
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
unknown's avatar
unknown committed
1753 1754
  case COM_QUERY:
  {
1755 1756
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1757
    char *packet_end= thd->query + thd->query_length;
unknown's avatar
unknown committed
1758
    general_log_print(thd, command, "%.*b", thd->query_length, thd->query);
1759
    DBUG_PRINT("query",("%-.4096s",thd->query));
1760 1761 1762 1763

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

1764
    mysql_parse(thd,thd->query, thd->query_length);
1765

1766
    while (!thd->killed && thd->lex->found_semicolon && !thd->net.report_error)
1767
    {
1768
      char *packet= thd->lex->found_semicolon;
1769
      net->no_send_error= 0;
1770
      /*
1771 1772
        Multiple queries exits, execute them individually
      */
1773 1774
      if (thd->lock || thd->open_tables || thd->derived_tables ||
          thd->prelocked_mode)
1775
        close_thread_tables(thd);
1776
      ulong length= (ulong)(packet_end-packet);
1777

1778
      log_slow_statement(thd);
1779

1780
      /* Remove garbage at start of query */
unknown's avatar
unknown committed
1781
      while (my_isspace(thd->charset(), *packet) && length > 0)
1782 1783 1784 1785
      {
        packet++;
        length--;
      }
unknown's avatar
unknown committed
1786
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1787
      thd->query_length= length;
1788
      thd->query= packet;
1789
      thd->query_id= next_query_id();
1790
      thd->set_time(); /* Reset the query start time. */
1791
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1792
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1793 1794 1795
      mysql_parse(thd, packet, length);
    }

unknown's avatar
unknown committed
1796 1797 1798 1799 1800
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1801
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1802
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
1803 1804
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
unknown's avatar
unknown committed
1805 1806 1807
    break;
#else
  {
1808
    char *fields, *pend;
1809 1810
    /* Locked closure of all tables */
    TABLE_LIST *locked_tables= NULL;
unknown's avatar
unknown committed
1811
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1812
    LEX_STRING conv_name;
1813
    /* Saved variable value */
unknown's avatar
unknown committed
1814 1815 1816
    my_bool old_innodb_table_locks=  thd->variables.innodb_table_locks;


unknown's avatar
unknown committed
1817 1818
    /* used as fields initializator */
    lex_start(thd, 0, 0);
1819

unknown's avatar
unknown committed
1820

1821 1822
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
unknown's avatar
unknown committed
1823 1824 1825
    bzero((char*) &table_list,sizeof(table_list));
    if (!(table_list.db=thd->db))
    {
unknown's avatar
unknown committed
1826
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
unknown's avatar
unknown committed
1827 1828
      break;
    }
1829
    pend= strend(packet);
unknown's avatar
unknown committed
1830 1831
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1832
    table_list.alias= table_list.table_name= conv_name.str;
1833
    packet= pend+1;
1834 1835 1836 1837 1838 1839 1840 1841 1842

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

1843
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
unknown's avatar
unknown committed
1844 1845
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
unknown's avatar
unknown committed
1846
    general_log_print(thd, command, "%s %s", table_list.table_name, fields);
1847
    if (lower_case_table_names)
1848 1849
      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
1850

unknown's avatar
unknown committed
1851
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
1852
		     0, 0, test(table_list.schema_table)))
unknown's avatar
unknown committed
1853
      break;
unknown's avatar
unknown committed
1854 1855
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1856
      break;
1857 1858 1859 1860 1861 1862
    /* 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
1863
    thd->lex->add_to_query_tables(&table_list);
1864

1865 1866
    /* switch on VIEW optimisation: do not fill temporary tables */
    thd->lex->sql_command= SQLCOM_SHOW_FIELDS;
unknown's avatar
unknown committed
1867
    mysqld_list_fields(thd,&table_list,fields);
1868
    thd->lex->unit.cleanup();
1869
    thd->cleanup_after_query();
unknown's avatar
unknown committed
1870 1871 1872 1873
    break;
  }
#endif
  case COM_QUIT:
1874
    /* We don't calculate statistics for this command */
unknown's avatar
unknown committed
1875
    general_log_print(thd, command, NullS);
unknown's avatar
unknown committed
1876 1877 1878 1879
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1880
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1881
    {
unknown's avatar
unknown committed
1882
      char *db=thd->strdup(packet), *alias;
1883
      HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1884

1885 1886
      statistic_increment(thd->status_var.com_stat[SQLCOM_CREATE_DB],
			  &LOCK_status);
1887
      // null test to handle EOM
unknown's avatar
unknown committed
1888
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1889
      {
1890
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1891 1892
	break;
      }
1893
      if (check_access(thd,CREATE_ACL,db,0,1,0,is_schema_db(db)))
unknown's avatar
unknown committed
1894
	break;
unknown's avatar
unknown committed
1895
      general_log_print(thd, command, packet);
1896
      bzero(&create_info, sizeof(create_info));
1897 1898
      mysql_create_db(thd, (lower_case_table_names == 2 ? alias : db),
                      &create_info, 0);
unknown's avatar
unknown committed
1899 1900
      break;
    }
unknown's avatar
unknown committed
1901
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1902
    {
1903 1904
      statistic_increment(thd->status_var.com_stat[SQLCOM_DROP_DB],
			  &LOCK_status);
1905
      char *db=thd->strdup(packet);
unknown's avatar
unknown committed
1906
      /*  null test to handle EOM */
1907
      if (!db || check_db_name(db))
1908
      {
1909
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1910 1911
	break;
      }
1912
      if (check_access(thd,DROP_ACL,db,0,1,0,is_schema_db(db)))
1913
	break;
unknown's avatar
unknown committed
1914 1915
      if (thd->locked_tables || thd->active_transaction())
      {
unknown's avatar
unknown committed
1916 1917
	my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                   ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
unknown's avatar
unknown committed
1918
	break;
unknown's avatar
unknown committed
1919
      }
unknown's avatar
unknown committed
1920
      general_log_print(thd, command, db);
1921
      mysql_rm_db(thd, db, 0, 0);
unknown's avatar
unknown committed
1922 1923
      break;
    }
1924
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1925 1926
  case COM_BINLOG_DUMP:
    {
unknown's avatar
unknown committed
1927 1928 1929 1930
      ulong pos;
      ushort flags;
      uint32 slave_server_id;

1931
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1932
      thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
unknown committed
1933
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1934
	break;
unknown's avatar
unknown committed
1935

1936
      /* TODO: The following has to be changed to an 8 byte integer */
1937 1938
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1939
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1940
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1941
	kill_zombie_dump_threads(slave_server_id);
1942
      thd->server_id = slave_server_id;
unknown's avatar
unknown committed
1943

unknown's avatar
unknown committed
1944
      general_log_print(thd, command, "Log: '%s'  Pos: %ld", packet+10,
unknown's avatar
unknown committed
1945
                      (long) pos);
1946
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1947
      unregister_slave(thd,1,1);
unknown's avatar
unknown committed
1948
      /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
1949 1950
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
1951 1952
      break;
    }
1953
#endif
unknown's avatar
unknown committed
1954
  case COM_REFRESH:
unknown's avatar
unknown committed
1955 1956 1957 1958 1959 1960
  {
    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
1961
      break;
unknown's avatar
unknown committed
1962
    general_log_print(thd, command, NullS);
unknown's avatar
unknown committed
1963 1964 1965 1966
    if (!reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, &not_used))
      send_ok(thd);
    break;
  }
1967
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1968
  case COM_SHUTDOWN:
1969
  {
1970
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
1971
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
1972
      break; /* purecov: inspected */
1973
    /*
1974 1975 1976 1977
      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].
1978
    */
1979 1980
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
1981
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1982 1983 1984 1985 1986 1987 1988
    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;
    }
1989
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
unknown's avatar
unknown committed
1990
    general_log_print(thd, command, NullS);
1991
    send_eof(thd);
unknown's avatar
unknown committed
1992 1993 1994
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
1995
    send_eof(thd);				// This is for 'quit request'
1996
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1997 1998 1999 2000
    close_thread_tables(thd);			// Free before kill
    kill_mysql();
    error=TRUE;
    break;
2001
  }
2002
#endif
unknown's avatar
unknown committed
2003 2004
  case COM_STATISTICS:
  {
unknown's avatar
unknown committed
2005
    general_log_print(thd, command, NullS);
2006 2007
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_STATUS],
			&LOCK_status);
unknown's avatar
unknown committed
2008
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2009
    char buff[200];
unknown's avatar
unknown committed
2010 2011 2012
#else
    char *buff= thd->net.last_error;
#endif
2013 2014 2015 2016

    STATUS_VAR current_global_status_var;
    calc_sum_of_all_status(&current_global_status_var);

2017
    ulong uptime = (ulong) (thd->start_time - start_time);
unknown's avatar
unknown committed
2018
    sprintf((char*) buff,
2019
	    "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
2020
	    uptime,
2021
	    (int) thread_count, (ulong) thd->query_id,
2022
	    current_global_status_var.long_query_count,
2023
	    current_global_status_var.opened_tables, refresh_version, cached_tables(),
2024 2025
	    (uptime ? (ulonglong2double(thd->query_id) / (double) uptime) :
	     (double) 0));
unknown's avatar
unknown committed
2026
#ifdef SAFEMALLOC
2027
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
2028
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
2029 2030
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
2031 2032
#endif
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2033
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
2034
    VOID(net_flush(net));
unknown's avatar
unknown committed
2035
#endif
unknown's avatar
unknown committed
2036 2037 2038
    break;
  }
  case COM_PING:
2039
    statistic_increment(thd->status_var.com_other, &LOCK_status);
2040
    send_ok(thd);				// Tell client we are alive
unknown's avatar
unknown committed
2041 2042
    break;
  case COM_PROCESS_INFO:
2043 2044
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST],
			&LOCK_status);
2045 2046
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd, PROCESS_ACL))
unknown's avatar
unknown committed
2047
      break;
unknown's avatar
unknown committed
2048
    general_log_print(thd, command, NullS);
unknown's avatar
unknown committed
2049
    mysqld_list_processes(thd,
2050 2051
			  thd->security_ctx->master_access & PROCESS_ACL ? 
			  NullS : thd->security_ctx->priv_user, 0);
unknown's avatar
unknown committed
2052 2053 2054
    break;
  case COM_PROCESS_KILL:
  {
2055
    statistic_increment(thd->status_var.com_stat[SQLCOM_KILL], &LOCK_status);
2056
    ulong id=(ulong) uint4korr(packet);
2057
    sql_kill(thd,id,false);
unknown's avatar
unknown committed
2058 2059
    break;
  }
2060 2061
  case COM_SET_OPTION:
  {
2062 2063
    statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
			&LOCK_status);
2064 2065 2066 2067
    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
2068
      send_eof(thd);
2069 2070 2071
      break;
    case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
2072
      send_eof(thd);
2073 2074
      break;
    default:
unknown's avatar
unknown committed
2075
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
2076 2077 2078 2079
      break;
    }
    break;
  }
unknown's avatar
unknown committed
2080
  case COM_DEBUG:
2081
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
2082
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2083
      break;					/* purecov: inspected */
2084
    mysql_print_status();
unknown's avatar
unknown committed
2085
    general_log_print(thd, command, NullS);
2086
    send_eof(thd);
unknown's avatar
unknown committed
2087 2088 2089 2090 2091
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
2092
  case COM_END:
unknown's avatar
unknown committed
2093
  default:
unknown's avatar
unknown committed
2094
    my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
2095 2096
    break;
  }
2097 2098
  if (thd->lock || thd->open_tables || thd->derived_tables ||
      thd->prelocked_mode)
unknown's avatar
unknown committed
2099 2100 2101 2102
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }
2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
  /*
    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())
2113
    thd->transaction.xid_state.xid.null();
unknown's avatar
unknown committed
2114

unknown's avatar
unknown committed
2115 2116 2117
  /* report error issued during command execution */
  if (thd->killed_errno() && !thd->net.report_error)
    thd->send_kill_message();
unknown's avatar
unknown committed
2118
  if (thd->net.report_error)
2119
    net_send_error(thd);
unknown's avatar
unknown committed
2120

2121
  log_slow_statement(thd);
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136

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


2137
void log_slow_statement(THD *thd)
2138
{
2139
  time_t start_of_query;
unknown's avatar
unknown committed
2140
  DBUG_ENTER("log_slow_statement");
2141 2142 2143 2144 2145 2146 2147

  /*
    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))
unknown's avatar
unknown committed
2148
    DBUG_VOID_RETURN;                           // Don't set time for sub stmt
2149 2150

  start_of_query= thd->start_time;
2151
  thd->end_time();				// Set start time
2152

2153 2154 2155 2156 2157
  /*
    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
2158
  {
2159 2160
    thd->proc_info="logging slow query";

2161 2162
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2163 2164
	((thd->server_status &
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2165
	 (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES)))
2166
    {
2167
      thd->status_var.long_query_count++;
unknown's avatar
unknown committed
2168
      slow_log_print(thd, thd->query, thd->query_length, start_of_query);
2169
    }
unknown's avatar
unknown committed
2170
  }
unknown's avatar
unknown committed
2171
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2172 2173
}

2174

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


2298 2299
/*
  Read query from packet and store in thd->query
2300
  Used in COM_QUERY and COM_STMT_PREPARE
2301 2302 2303 2304 2305 2306 2307

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
unknown's avatar
unknown committed
2308 2309
    FALSE ok
    TRUE  error;  In this case thd->fatal_error is set
2310 2311
*/

2312
bool alloc_query(THD *thd, const char *packet, uint packet_length)
2313 2314
{
  packet_length--;				// Remove end null
2315
  /* Remove garbage at start and end of query */
unknown's avatar
unknown committed
2316
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
2317 2318 2319 2320
  {
    packet++;
    packet_length--;
  }
2321
  const char *pos= packet + packet_length;     // Point at end null
unknown's avatar
unknown committed
2322
  while (packet_length > 0 &&
unknown's avatar
unknown committed
2323
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
2324 2325 2326 2327 2328
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
2329
  thd->query_length= 0;                        // Extra safety: Avoid races
2330 2331
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
2332 2333
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
unknown's avatar
unknown committed
2334
    return TRUE;
2335 2336
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
2337 2338 2339 2340

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

unknown's avatar
unknown committed
2342
  return FALSE;
2343 2344
}

2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360
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;
}

2361

unknown's avatar
unknown committed
2362 2363 2364 2365 2366
/****************************************************************************
** mysql_execute_command
** Execute command saved in thd and current_lex->sql_command
****************************************************************************/

unknown's avatar
unknown committed
2367
bool
2368
mysql_execute_command(THD *thd)
unknown's avatar
unknown committed
2369
{
unknown's avatar
unknown committed
2370
  bool	res= FALSE;
unknown's avatar
unknown committed
2371
  int result= 0;
unknown's avatar
unknown committed
2372
  LEX	*lex= thd->lex;
unknown's avatar
unknown committed
2373
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
unknown's avatar
unknown committed
2374
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
2375
  /* first table of first SELECT_LEX */
unknown's avatar
unknown committed
2376
  TABLE_LIST *first_table= (TABLE_LIST*) select_lex->table_list.first;
unknown's avatar
VIEW  
unknown committed
2377 2378 2379
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
2380
  SELECT_LEX_UNIT *unit= &lex->unit;
2381
  /* Saved variable value */
unknown's avatar
unknown committed
2382
  DBUG_ENTER("mysql_execute_command");
2383
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
2384 2385 2386
#ifdef WITH_PARTITION_STORAGE_ENGINE
  thd->work_part_info= 0;
#endif
unknown's avatar
unknown committed
2387

unknown's avatar
VIEW  
unknown committed
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
  /*
    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();
2404
  /* should be assigned after making first tables same */
unknown's avatar
VIEW  
unknown committed
2405
  all_tables= lex->query_tables;
2406 2407 2408 2409
  /* 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
2410

2411 2412 2413 2414 2415
  /*
    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.
2416
    Don't reset warnings when executing a stored routine.
2417
  */
2418
  if ((all_tables || &lex->select_lex != lex->all_selects_list ||
2419
       lex->sroutines.records) && !thd->spcont ||
2420
      lex->time_zone_tables_used)
unknown's avatar
unknown committed
2421
    mysql_reset_errors(thd, 0);
2422

unknown's avatar
SCRUM  
unknown committed
2423
#ifdef HAVE_REPLICATION
2424
  if (unlikely(thd->slave_thread))
2425
  {
unknown's avatar
unknown committed
2426
    /*
unknown's avatar
unknown committed
2427 2428
      Check if statment should be skipped because of slave filtering
      rules
2429 2430

      Exceptions are:
unknown's avatar
unknown committed
2431 2432
      - UPDATE MULTI: For this statement, we want to check the filtering
        rules later in the code
2433
      - SET: we always execute it (Not that many SET commands exists in
unknown's avatar
unknown committed
2434 2435
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
2436 2437
      - 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
2438
    */
unknown's avatar
unknown committed
2439 2440
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
	!(lex->sql_command == SQLCOM_SET_OPTION) &&
2441
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2442
          lex->drop_temporary && lex->drop_if_exists) &&
unknown's avatar
Merge  
unknown committed
2443
        all_tables_not_ok(thd, all_tables))
unknown's avatar
unknown committed
2444 2445
    {
      /* we warn the slave SQL thread */
unknown's avatar
unknown committed
2446
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2447
      reset_one_shot_variables(thd);
2448
      DBUG_RETURN(0);
unknown's avatar
unknown committed
2449
    }
2450
  }
2451
  else
2452
  {
2453
#endif /* HAVE_REPLICATION */
2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
    /*
      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
2472 2473 2474
  if(lex->orig_sql_command == SQLCOM_END)
    statistic_increment(thd->status_var.com_stat[lex->sql_command],
                        &LOCK_status);
2475

2476
#ifdef HAVE_ROW_BASED_REPLICATION
unknown's avatar
unknown committed
2477 2478
  if (lex->binlog_row_based_if_mixed)
    thd->set_current_stmt_binlog_row_based_if_mixed();
2479
#endif /*HAVE_ROW_BASED_REPLICATION*/
unknown's avatar
unknown committed
2480

unknown's avatar
unknown committed
2481 2482 2483
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2484 2485 2486 2487
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
2488 2489
	param->select_limit=
          new Item_int((ulonglong)thd->variables.select_limit);
2490 2491
    }

2492
    select_result *result=lex->result;
unknown's avatar
VIEW  
unknown committed
2493
    if (all_tables)
unknown's avatar
unknown committed
2494
    {
2495
      if (lex->orig_sql_command != SQLCOM_SHOW_STATUS_PROC &&
unknown's avatar
unknown committed
2496 2497
          lex->orig_sql_command != SQLCOM_SHOW_STATUS_FUNC &&
          lex->orig_sql_command != SQLCOM_SHOW_EVENTS)
2498 2499 2500 2501
        res= check_table_access(thd,
                                lex->exchange ? SELECT_ACL | FILE_ACL :
                                SELECT_ACL,
                                all_tables, 0);
unknown's avatar
unknown committed
2502 2503 2504
      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
2505 2506
    }
    else
unknown's avatar
VIEW  
unknown committed
2507 2508
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
2509
			any_db, 0, 0, 0, 0);
unknown's avatar
unknown committed
2510
    if (res)
unknown's avatar
unknown committed
2511
      goto error;
unknown's avatar
unknown committed
2512

unknown's avatar
VIEW  
unknown committed
2513
    if (!(res= open_and_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
2514
    {
unknown's avatar
unknown committed
2515
      if (lex->describe)
unknown's avatar
unknown committed
2516
      {
2517 2518 2519 2520 2521 2522
        /*
          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.
        */
2523
	if (!(result= new select_send()))
2524
	  goto error;
2525 2526
	else
	  thd->send_explain_fields(result);
unknown's avatar
unknown committed
2527
	res= mysql_explain_union(thd, &thd->lex->unit, result);
unknown's avatar
unknown committed
2528 2529 2530 2531 2532
	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
2533
	  thd->lex->unit.print(&str);
unknown's avatar
unknown committed
2534 2535 2536 2537
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2538
	result->send_eof();
2539
        delete result;
unknown's avatar
unknown committed
2540 2541 2542
      }
      else
      {
2543
	if (!result && !(result= new select_send()))
unknown's avatar
unknown committed
2544
          goto error;
unknown's avatar
VIEW  
unknown committed
2545
	query_cache_store_query(thd, all_tables);
2546
	res= handle_select(thd, lex, result, 0);
2547 2548
        if (result != lex->result)
          delete result;
unknown's avatar
unknown committed
2549
      }
unknown's avatar
unknown committed
2550
    }
unknown's avatar
unknown committed
2551 2552
    break;
  }
unknown's avatar
unknown committed
2553
  case SQLCOM_PREPARE:
2554
  {
2555
    mysql_sql_stmt_prepare(thd);
unknown's avatar
unknown committed
2556 2557 2558 2559
    break;
  }
  case SQLCOM_EXECUTE:
  {
2560
    mysql_sql_stmt_execute(thd);
unknown's avatar
unknown committed
2561 2562 2563 2564
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2565
    mysql_sql_stmt_close(thd);
unknown's avatar
unknown committed
2566 2567
    break;
  }
unknown's avatar
unknown committed
2568
  case SQLCOM_DO:
2569 2570
    if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
        open_and_lock_tables(thd, all_tables))
unknown's avatar
unknown committed
2571
      goto error;
unknown's avatar
unknown committed
2572 2573

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

2576
  case SQLCOM_EMPTY_QUERY:
2577
    send_ok(thd);
2578 2579
    break;

unknown's avatar
unknown committed
2580 2581 2582 2583
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2584
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2585
  case SQLCOM_PURGE:
2586
  {
unknown's avatar
unknown committed
2587
    if (check_global_access(thd, SUPER_ACL))
2588
      goto error;
unknown's avatar
unknown committed
2589
    /* PURGE MASTER LOGS TO 'file' */
2590 2591 2592
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2593 2594
  case SQLCOM_PURGE_BEFORE:
  {
2595 2596
    Item *it;

2597 2598
    if (check_global_access(thd, SUPER_ACL))
      goto error;
unknown's avatar
unknown committed
2599
    /* PURGE MASTER LOGS BEFORE 'data' */
2600
    it= (Item *)lex->value_list.head();
2601
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
unknown's avatar
unknown committed
2602
        it->check_cols(1))
2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613
    {
      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());
2614 2615
    break;
  }
2616
#endif
unknown's avatar
unknown committed
2617 2618
  case SQLCOM_SHOW_WARNS:
  {
2619 2620
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2621 2622 2623
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
unknown's avatar
unknown committed
2624 2625 2626 2627
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2628 2629
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
unknown's avatar
unknown committed
2630 2631
    break;
  }
unknown's avatar
unknown committed
2632 2633
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
2634
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2635
      goto error;
2636
    /* This query don't work now. See comment in repl_failsafe.cc */
unknown's avatar
unknown committed
2637
#ifndef WORKING_NEW_MASTER
unknown's avatar
unknown committed
2638 2639
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "SHOW NEW MASTER");
    goto error;
unknown's avatar
unknown committed
2640
#else
unknown's avatar
unknown committed
2641 2642
    res = show_new_master(thd);
    break;
unknown's avatar
unknown committed
2643
#endif
unknown's avatar
unknown committed
2644
  }
2645

unknown's avatar
unknown committed
2646
#ifdef HAVE_REPLICATION
2647 2648
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2649
    if (check_global_access(thd, REPL_SLAVE_ACL))
2650 2651 2652 2653
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2654 2655
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2656
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2657
      goto error;
2658
    res = mysql_show_binlog_events(thd);
unknown's avatar
unknown committed
2659 2660
    break;
  }
2661 2662
#endif

unknown's avatar
unknown committed
2663
  case SQLCOM_BACKUP_TABLE:
2664
  {
unknown's avatar
VIEW  
unknown committed
2665 2666 2667
    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
2668
	check_global_access(thd, FILE_ACL))
2669
      goto error; /* purecov: inspected */
2670
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2671
    res = mysql_backup_table(thd, first_table);
2672
    select_lex->table_list.first= (byte*) first_table;
2673
    lex->query_tables=all_tables;
2674 2675
    break;
  }
unknown's avatar
unknown committed
2676
  case SQLCOM_RESTORE_TABLE:
2677
  {
unknown's avatar
VIEW  
unknown committed
2678 2679 2680
    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
2681
	check_global_access(thd, FILE_ACL))
2682
      goto error; /* purecov: inspected */
2683
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2684
    res = mysql_restore_table(thd, first_table);
2685
    select_lex->table_list.first= (byte*) first_table;
2686
    lex->query_tables=all_tables;
2687 2688
    break;
  }
unknown's avatar
unknown committed
2689 2690
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
unknown's avatar
VIEW  
unknown committed
2691 2692 2693
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
2694 2695
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2696
      goto error;
2697
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
unknown's avatar
unknown committed
2698 2699
    break;
  }
unknown's avatar
unknown committed
2700 2701
  case SQLCOM_PRELOAD_KEYS:
  {
unknown's avatar
VIEW  
unknown committed
2702 2703 2704
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
2705 2706
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
2707
      goto error;
unknown's avatar
VIEW  
unknown committed
2708
    res = mysql_preload_keys(thd, first_table);
unknown's avatar
unknown committed
2709 2710
    break;
  }
unknown's avatar
unknown committed
2711
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2712
  case SQLCOM_CHANGE_MASTER:
2713
  {
unknown's avatar
unknown committed
2714
    if (check_global_access(thd, SUPER_ACL))
2715
      goto error;
2716
    pthread_mutex_lock(&LOCK_active_mi);
2717
    res = change_master(thd,active_mi);
2718
    pthread_mutex_unlock(&LOCK_active_mi);
2719 2720
    break;
  }
unknown's avatar
unknown committed
2721
  case SQLCOM_SHOW_SLAVE_STAT:
2722
  {
2723 2724
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2725
      goto error;
2726
    pthread_mutex_lock(&LOCK_active_mi);
2727
    res = show_master_info(thd,active_mi);
2728
    pthread_mutex_unlock(&LOCK_active_mi);
2729 2730
    break;
  }
unknown's avatar
unknown committed
2731
  case SQLCOM_SHOW_MASTER_STAT:
2732
  {
2733 2734
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2735 2736 2737 2738
      goto error;
    res = show_binlog_info(thd);
    break;
  }
unknown's avatar
unknown committed
2739

2740
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
2741
    if (check_global_access(thd, SUPER_ACL))
2742
      goto error;
2743
    if (end_active_trans(thd))
unknown's avatar
unknown committed
2744
      goto error;
2745
    res = load_master_data(thd);
2746
    break;
unknown's avatar
unknown committed
2747
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
2748
  case SQLCOM_SHOW_ENGINE_STATUS:
unknown's avatar
unknown committed
2749
    {
2750
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2751 2752
        goto error;
      res = ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_STATUS);
unknown's avatar
unknown committed
2753 2754
      break;
    }
unknown's avatar
unknown committed
2755
  case SQLCOM_SHOW_ENGINE_MUTEX:
unknown's avatar
unknown committed
2756 2757
    {
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2758
        goto error;
unknown's avatar
unknown committed
2759
      res = ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_MUTEX);
unknown's avatar
unknown committed
2760 2761
      break;
    }
unknown's avatar
unknown committed
2762
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2763
  case SQLCOM_LOAD_MASTER_TABLE:
2764
  {
unknown's avatar
VIEW  
unknown committed
2765 2766 2767 2768
    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,
2769 2770
		     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2771 2772 2773 2774
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
unknown's avatar
VIEW  
unknown committed
2775
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2776
	goto error;
unknown's avatar
unknown committed
2777
    }
2778
    if (strlen(first_table->table_name) > NAME_LEN)
unknown's avatar
unknown committed
2779
    {
2780
      my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name);
unknown's avatar
unknown committed
2781 2782
      break;
    }
2783
    pthread_mutex_lock(&LOCK_active_mi);
2784 2785 2786 2787
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2788
    if (!fetch_master_table(thd, first_table->db, first_table->table_name,
2789
			    active_mi, 0, 0))
2790
    {
2791
      send_ok(thd);
2792
    }
2793
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2794
    break;
2795
  }
unknown's avatar
unknown committed
2796
#endif /* HAVE_REPLICATION */
2797

unknown's avatar
unknown committed
2798
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
2799
  {
2800
    /* If CREATE TABLE of non-temporary table, do implicit commit */
2801 2802 2803 2804 2805 2806 2807 2808
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
    {
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
unknown's avatar
VIEW  
unknown committed
2809 2810 2811 2812 2813
    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
2814

unknown's avatar
VIEW  
unknown committed
2815
    if ((res= create_table_precheck(thd, select_tables, create_table)))
unknown's avatar
unknown committed
2816
      goto end_with_restore_list;
unknown's avatar
unknown committed
2817

2818 2819 2820
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
2821
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
2822
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
2823
			   create_table->table_name) ||
unknown's avatar
VIEW  
unknown committed
2824
	append_file_to_dir(thd, &lex->create_info.index_file_name,
2825
			   create_table->table_name))
unknown's avatar
unknown committed
2826
      goto end_with_restore_list;
2827
#endif
2828
    /*
2829
      If we are using SET CHARSET without DEFAULT, add an implicit
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840
      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;
    }
2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855
    /*
      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
2856 2857
      res= 1;
      goto end_with_restore_list;
2858
    }
2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869
#ifdef WITH_PARTITION_STORAGE_ENGINE
    {
      partition_info *part_info= thd->lex->part_info;
      if (part_info && !(part_info= thd->lex->part_info->get_clone()))
      {
        res= -1;
        goto end_with_restore_list;
      }
      thd->work_part_info= part_info;
    }
#endif
2870
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
2871 2872
    {
      select_result *result;
2873

2874
      select_lex->options|= SELECT_NO_UNLOCK;
2875
      unit->set_limit(select_lex);
2876

unknown's avatar
VIEW  
unknown committed
2877
      if (!(res= open_and_lock_tables(thd, select_tables)))
2878
      {
2879 2880 2881 2882
        /*
          Is table which we are changing used somewhere in other parts
          of query
        */
2883
        if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
2884
        {
2885
          TABLE_LIST *duplicate;
2886
          if ((duplicate= unique_table(thd, create_table, select_tables)))
2887 2888 2889 2890 2891
          {
            update_non_unique_table_error(create_table, "CREATE", duplicate);
            res= 1;
            goto end_with_restart_wait;
          }
2892
        }
unknown's avatar
unknown committed
2893 2894 2895 2896 2897 2898 2899 2900
        /* 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)
          {
2901
            TABLE_LIST *duplicate;
2902
            if ((duplicate= unique_table(thd, tab, select_tables)))
unknown's avatar
unknown committed
2903
            {
2904
              update_non_unique_table_error(tab, "CREATE", duplicate);
unknown's avatar
unknown committed
2905 2906
              res= 1;
              goto end_with_restart_wait;
unknown's avatar
unknown committed
2907 2908 2909
            }
          }
        }
2910

unknown's avatar
VIEW  
unknown committed
2911 2912 2913 2914 2915
        if ((result= new select_create(create_table,
				       &lex->create_info,
				       lex->create_list,
				       lex->key_list,
				       select_lex->item_list,
2916 2917
				       lex->duplicates,
				       lex->ignore)))
2918 2919 2920 2921 2922
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
2923
          res= handle_select(thd, lex, result, 0);
2924
          delete result;
2925
        }
unknown's avatar
unknown committed
2926
	/* reset for PS */
2927 2928
	lex->create_list.empty();
	lex->key_list.empty();
2929 2930
      }
    }
unknown's avatar
unknown committed
2931
    else
unknown's avatar
unknown committed
2932
    {
2933 2934 2935
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
      if (lex->create_info.options & HA_LEX_CREATE_TMP_TABLE)
        thd->options|= OPTION_KEEP_LOG;
unknown's avatar
unknown committed
2936
      /* regular create */
unknown's avatar
unknown committed
2937
      if (lex->like_name)
unknown's avatar
unknown committed
2938
        res= mysql_create_like_table(thd, create_table, &lex->create_info, 
unknown's avatar
unknown committed
2939
                                     lex->like_name); 
unknown's avatar
unknown committed
2940
      else
2941
      {
unknown's avatar
VIEW  
unknown committed
2942
        res= mysql_create_table(thd, create_table->db,
2943
				create_table->table_name, &lex->create_info,
unknown's avatar
VIEW  
unknown committed
2944
				lex->create_list,
unknown's avatar
unknown committed
2945
				lex->key_list, 0, 0);
2946
      }
unknown's avatar
unknown committed
2947
      if (!res)
2948
	send_ok(thd);
unknown's avatar
unknown committed
2949
    }
2950

unknown's avatar
unknown committed
2951
end_with_restart_wait:
2952 2953 2954 2955 2956 2957
    /*
      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
2958
    /* put tables back for PS rexecuting */
unknown's avatar
unknown committed
2959
end_with_restore_list:
unknown's avatar
VIEW  
unknown committed
2960
    lex->link_first_table_back(create_table, link_to_local);
unknown's avatar
unknown committed
2961
    break;
unknown's avatar
unknown committed
2962
  }
unknown's avatar
unknown committed
2963
  case SQLCOM_CREATE_INDEX:
unknown's avatar
VIEW  
unknown committed
2964 2965
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
unknown's avatar
unknown committed
2966
      goto error; /* purecov: inspected */
2967
    thd->enable_slow_log= opt_log_slow_admin_statements;
2968
    if (end_active_trans(thd))
unknown's avatar
unknown committed
2969
      goto error;
2970
    res= mysql_create_index(thd, first_table, lex->key_list);
unknown's avatar
unknown committed
2971 2972
    break;

unknown's avatar
unknown committed
2973
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2974
  case SQLCOM_SLAVE_START:
2975
  {
2976
    pthread_mutex_lock(&LOCK_active_mi);
2977
    start_slave(thd,active_mi,1 /* net report*/);
2978
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2979
    break;
2980
  }
unknown's avatar
unknown committed
2981
  case SQLCOM_SLAVE_STOP:
2982 2983 2984 2985 2986 2987
  /*
    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,
2988
      so it waits for the client thread because t is locked by it.
2989
    - then the client thread does SLAVE STOP.
2990 2991
      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.
2992 2993 2994
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
2995
  if (thd->locked_tables || thd->active_transaction() || thd->global_read_lock)
2996
  {
2997 2998
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
2999
    goto error;
3000
  }
3001
  {
3002
    pthread_mutex_lock(&LOCK_active_mi);
3003
    stop_slave(thd,active_mi,1/* net report*/);
3004
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
3005
    break;
3006
  }
unknown's avatar
unknown committed
3007
#endif /* HAVE_REPLICATION */
3008

unknown's avatar
unknown committed
3009
  case SQLCOM_ALTER_TABLE:
unknown's avatar
VIEW  
unknown committed
3010
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3011
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
3012 3013
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3014
    goto error;
unknown's avatar
unknown committed
3015 3016
#else
    {
unknown's avatar
unknown committed
3017
      ulong priv=0;
unknown's avatar
unknown committed
3018 3019 3020 3021 3022
      ulong priv_needed= ALTER_ACL;
      /* We also require DROP priv for ALTER TABLE ... DROP PARTITION */
      if (lex->alter_info.flags & ALTER_DROP_PARTITION)
        priv_needed|= DROP_ACL;

unknown's avatar
unknown committed
3023
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
unknown's avatar
unknown committed
3024
      {
3025
	my_error(ER_WRONG_TABLE_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3026
        goto error;
unknown's avatar
unknown committed
3027
      }
3028
      if (!select_lex->db)
3029 3030 3031 3032 3033 3034 3035 3036 3037 3038
      {
        /*
          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
3039
            my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
3040 3041 3042 3043 3044
            goto error;
          }
          select_lex->db= thd->db;
        }
        else
3045
          select_lex->db= first_table->db;
3046
      }
unknown's avatar
unknown committed
3047
      if (check_access(thd, priv_needed, first_table->db,
3048 3049 3050 3051
		       &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
3052
	  check_merge_table_access(thd, first_table->db,
3053 3054 3055
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
3056 3057
      if (grant_option)
      {
unknown's avatar
unknown committed
3058
	if (check_grant(thd, priv_needed, all_tables, 0, UINT_MAX, 0))
unknown's avatar
unknown committed
3059 3060 3061 3062 3063
	  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));
3064
	  tmp_table.table_name=lex->name;
3065
	  tmp_table.db=select_lex->db;
unknown's avatar
unknown committed
3066
	  tmp_table.grant.privilege=priv;
unknown's avatar
unknown committed
3067 3068
	  if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0,
			  UINT_MAX, 0))
unknown's avatar
unknown committed
3069 3070 3071
	    goto error;
	}
      }
3072 3073
      /* 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
3074
      /* ALTER TABLE ends previous transaction */
3075
      if (end_active_trans(thd))
unknown's avatar
unknown committed
3076
	goto error;
3077 3078 3079 3080 3081 3082 3083 3084 3085 3086

      thd->enable_slow_log= opt_log_slow_admin_statements;
      res= mysql_alter_table(thd, select_lex->db, lex->name,
                             &lex->create_info,
                             first_table, lex->create_list,
                             lex->key_list,
                             select_lex->order_list.elements,
                             (ORDER *) select_lex->order_list.first,
                             lex->duplicates, lex->ignore, &lex->alter_info,
                             1);
unknown's avatar
unknown committed
3087 3088
      break;
    }
unknown's avatar
unknown committed
3089
#endif /*DONT_ALLOW_SHOW_COMMANDS*/
unknown's avatar
unknown committed
3090
  case SQLCOM_RENAME_TABLE:
unknown's avatar
unknown committed
3091
  {
unknown's avatar
VIEW  
unknown committed
3092
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3093
    TABLE_LIST *table;
unknown's avatar
VIEW  
unknown committed
3094
    if (check_db_used(thd, all_tables))
unknown's avatar
unknown committed
3095
      goto error;
unknown's avatar
VIEW  
unknown committed
3096
    for (table= first_table; table; table= table->next_local->next_local)
unknown's avatar
unknown committed
3097
    {
unknown's avatar
unknown committed
3098
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
3099
		       &table->grant.privilege,0,0, test(table->schema_table)) ||
unknown's avatar
VIEW  
unknown committed
3100
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next_local->db,
3101 3102
		       &table->next_local->grant.privilege, 0, 0,
                       test(table->next_local->schema_table)))
unknown's avatar
unknown committed
3103 3104 3105
	goto error;
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
3106
	TABLE_LIST old_list, new_list;
unknown's avatar
unknown committed
3107 3108 3109 3110
	/*
	  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
3111 3112 3113 3114
	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,
3115
			    INSERT_ACL | CREATE_ACL) &&
unknown's avatar
VIEW  
unknown committed
3116
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0, 1, 0)))
unknown's avatar
unknown committed
3117 3118 3119
	  goto error;
      }
    }
unknown's avatar
VIEW  
unknown committed
3120
    query_cache_invalidate3(thd, first_table, 0);
unknown's avatar
unknown committed
3121
    if (end_active_trans(thd) || mysql_rename_tables(thd, first_table, 0))
unknown's avatar
unknown committed
3122
      goto error;
unknown's avatar
unknown committed
3123
    break;
unknown's avatar
unknown committed
3124
  }
3125
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3126 3127
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3128 3129
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3130
    goto error;
unknown's avatar
unknown committed
3131 3132
#else
    {
unknown's avatar
unknown committed
3133
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
3134 3135 3136 3137
	goto error;
      res = show_binlogs(thd);
      break;
    }
unknown's avatar
unknown committed
3138
#endif
3139
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
3140
  case SQLCOM_SHOW_CREATE:
unknown's avatar
VIEW  
unknown committed
3141
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3142
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3143 3144
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3145
    goto error;
unknown's avatar
unknown committed
3146
#else
unknown's avatar
unknown committed
3147
    {
3148 3149 3150 3151
      /* Ignore temporary tables if this is "SHOW CREATE VIEW" */
      if (lex->only_view)
        first_table->skip_temporary= 1;

unknown's avatar
VIEW  
unknown committed
3152 3153
      if (check_db_used(thd, all_tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, first_table->db,
3154 3155
		       &first_table->grant.privilege, 0, 0, 
                       test(first_table->schema_table)))
unknown's avatar
unknown committed
3156
	goto error;
unknown's avatar
unknown committed
3157
      if (grant_option && check_grant(thd, SELECT_ACL, all_tables, 2, UINT_MAX, 0))
3158
	goto error;
unknown's avatar
unknown committed
3159
      res= mysqld_show_create(thd, first_table);
unknown's avatar
unknown committed
3160 3161
      break;
    }
unknown's avatar
unknown committed
3162
#endif
3163 3164
  case SQLCOM_CHECKSUM:
  {
unknown's avatar
VIEW  
unknown committed
3165 3166 3167
    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))
3168
      goto error; /* purecov: inspected */
unknown's avatar
VIEW  
unknown committed
3169
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
3170 3171
    break;
  }
unknown's avatar
unknown committed
3172
  case SQLCOM_REPAIR:
3173
  {
unknown's avatar
VIEW  
unknown committed
3174 3175 3176
    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))
3177
      goto error; /* purecov: inspected */
3178
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3179
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
3180 3181 3182 3183 3184
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3185
	thd->clear_error(); // No binlog error generated
unknown's avatar
unknown committed
3186 3187
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          thd->query, thd->query_length, 0, FALSE);
3188 3189
      }
    }
3190
    select_lex->table_list.first= (byte*) first_table;
3191
    lex->query_tables=all_tables;
3192 3193
    break;
  }
unknown's avatar
unknown committed
3194
  case SQLCOM_CHECK:
3195
  {
unknown's avatar
VIEW  
unknown committed
3196 3197 3198
    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))
3199
      goto error; /* purecov: inspected */
3200
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3201
    res = mysql_check_table(thd, first_table, &lex->check_opt);
3202
    select_lex->table_list.first= (byte*) first_table;
3203
    lex->query_tables=all_tables;
3204 3205
    break;
  }
unknown's avatar
unknown committed
3206 3207
  case SQLCOM_ANALYZE:
  {
unknown's avatar
VIEW  
unknown committed
3208 3209 3210
    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
3211
      goto error; /* purecov: inspected */
3212
    thd->enable_slow_log= opt_log_slow_admin_statements;
3213
    res= mysql_analyze_table(thd, first_table, &lex->check_opt);
3214 3215 3216 3217 3218
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3219
	thd->clear_error(); // No binlog error generated
unknown's avatar
unknown committed
3220 3221
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          thd->query, thd->query_length, 0, FALSE);
3222 3223
      }
    }
3224
    select_lex->table_list.first= (byte*) first_table;
3225
    lex->query_tables=all_tables;
unknown's avatar
unknown committed
3226
    break;
unknown's avatar
unknown committed
3227
  }
3228

unknown's avatar
unknown committed
3229 3230
  case SQLCOM_OPTIMIZE:
  {
unknown's avatar
VIEW  
unknown committed
3231 3232 3233
    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
3234
      goto error; /* purecov: inspected */
3235
    thd->enable_slow_log= opt_log_slow_admin_statements;
3236
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
unknown's avatar
VIEW  
unknown committed
3237 3238
      mysql_recreate_table(thd, first_table, 1) :
      mysql_optimize_table(thd, first_table, &lex->check_opt);
3239 3240 3241 3242 3243
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3244
	thd->clear_error(); // No binlog error generated
unknown's avatar
unknown committed
3245 3246
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          thd->query, thd->query_length, 0, FALSE);
3247 3248
      }
    }
3249
    select_lex->table_list.first= (byte*) first_table;
3250
    lex->query_tables=all_tables;
unknown's avatar
unknown committed
3251 3252 3253
    break;
  }
  case SQLCOM_UPDATE:
unknown's avatar
VIEW  
unknown committed
3254 3255
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (update_precheck(thd, all_tables))
unknown's avatar
unknown committed
3256
      break;
3257 3258
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
unknown's avatar
unknown committed
3259 3260 3261 3262 3263 3264
    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,
3265
                               unit->select_limit_cnt,
3266
                               lex->duplicates, lex->ignore));
3267
    /* mysql_update return 2 if we need to switch to multi-update */
unknown's avatar
unknown committed
3268
    if (result != 2)
3269
      break;
3270
  case SQLCOM_UPDATE_MULTI:
unknown's avatar
unknown committed
3271 3272 3273 3274
  {
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    /* if we switched from normal update, rights are checked */
    if (result != 2)
3275
    {
unknown's avatar
unknown committed
3276 3277 3278 3279 3280
      if ((res= multi_update_precheck(thd, all_tables)))
        break;
    }
    else
      res= 0;
unknown's avatar
unknown committed
3281

3282
    res= mysql_multi_update_prepare(thd);
unknown's avatar
unknown committed
3283

3284
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3285
    /* Check slave filtering rules */
3286
    if (unlikely(thd->slave_thread))
unknown's avatar
unknown committed
3287
    {
3288 3289
      if (all_tables_not_ok(thd, all_tables))
      {
3290 3291 3292 3293 3294
        if (res!= 0)
        {
          res= 0;             /* don't care of prev failure  */
          thd->clear_error(); /* filters are of highest prior */
        }
3295 3296 3297 3298
        /* we warn the slave SQL thread */
        my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
        break;
      }
3299 3300
      if (res)
        break;
unknown's avatar
unknown committed
3301
    }
3302 3303
    else
    {
3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316
#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
3317

unknown's avatar
unknown committed
3318 3319 3320 3321 3322 3323
    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
3324
    break;
unknown's avatar
unknown committed
3325
  }
unknown's avatar
unknown committed
3326
  case SQLCOM_REPLACE:
3327 3328
  case SQLCOM_INSERT:
  {
unknown's avatar
VIEW  
unknown committed
3329
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3330
    if ((res= insert_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3331
      break;
3332 3333
    /* 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
3334
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
unknown's avatar
unknown committed
3335
		      lex->update_list, lex->value_list,
3336
                      lex->duplicates, lex->ignore);
unknown's avatar
VIEW  
unknown committed
3337 3338
    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
3339
    break;
3340
  }
unknown's avatar
unknown committed
3341 3342 3343
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
unknown's avatar
unknown committed
3344
    select_result *result;
unknown's avatar
VIEW  
unknown committed
3345
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3346
    if ((res= insert_precheck(thd, all_tables)))
3347
      break;
unknown's avatar
unknown committed
3348

3349
    /* Fix lock for first table */
unknown's avatar
VIEW  
unknown committed
3350 3351
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
3352

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

3356
    unit->set_limit(select_lex);
unknown's avatar
VIEW  
unknown committed
3357
    if (!(res= open_and_lock_tables(thd, all_tables)))
3358
    {
3359
      /* Skip first table, which is the table we are inserting in */
unknown's avatar
unknown committed
3360 3361
      TABLE_LIST *second_table= first_table->next_local;
      select_lex->table_list.first= (byte*) second_table;
3362 3363
      select_lex->context.table_list= 
        select_lex->context.first_name_resolution_table= second_table;
3364 3365 3366
      res= mysql_insert_select_prepare(thd);
      if (!res && (result= new select_insert(first_table, first_table->table,
                                             &lex->field_list,
3367 3368
                                             &lex->update_list,
                                             &lex->value_list,
3369
                                             lex->duplicates, lex->ignore)))
3370
      {
unknown's avatar
unknown committed
3371 3372 3373 3374 3375 3376 3377
        /*
          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.
        */
3378 3379
        select_lex->context.table_list= 
          select_lex->context.first_name_resolution_table= second_table;
3380
	res= handle_select(thd, lex, result, OPTION_SETUP_TABLES_DONE);
3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393
        /*
          Invalidate the table in the query cache if something changed
          after unlocking when changes become visible.
          TODO: this is workaround. right way will be move invalidating in
          the unlock procedure.
        */
        if (first_table->lock_type ==  TL_WRITE_CONCURRENT_INSERT &&
            thd->lock)
        {
          mysql_unlock_tables(thd, thd->lock);
          query_cache_invalidate3(thd, first_table, 1);
          thd->lock=0;
        }
3394 3395
        delete result;
      }
3396
      /* revert changes for SP */
unknown's avatar
unknown committed
3397
      select_lex->table_list.first= (byte*) first_table;
3398
    }
unknown's avatar
VIEW  
unknown committed
3399 3400 3401

    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
3402 3403
    break;
  }
3404
  case SQLCOM_TRUNCATE:
3405 3406 3407 3408 3409
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
VIEW  
unknown committed
3410 3411
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
unknown's avatar
unknown committed
3412
      goto error;
3413 3414 3415 3416
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
3417
    if (thd->locked_tables || thd->active_transaction())
3418
    {
unknown's avatar
unknown committed
3419 3420
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3421 3422
      goto error;
    }
unknown's avatar
VIEW  
unknown committed
3423

unknown's avatar
unknown committed
3424
    res= mysql_truncate(thd, first_table, 0);
3425
    break;
unknown's avatar
unknown committed
3426
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
3427
  {
unknown's avatar
VIEW  
unknown committed
3428 3429
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= delete_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3430
      break;
3431 3432
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
unknown's avatar
VIEW  
unknown committed
3433
    res = mysql_delete(thd, all_tables, select_lex->where,
3434
                       &select_lex->order_list,
unknown's avatar
unknown committed
3435 3436
                       unit->select_limit_cnt, select_lex->options,
                       FALSE);
unknown's avatar
unknown committed
3437 3438
    break;
  }
3439
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
3440
  {
unknown's avatar
VIEW  
unknown committed
3441
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3442 3443
    TABLE_LIST *aux_tables=
      (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
unknown's avatar
unknown committed
3444
    multi_delete *result;
unknown's avatar
unknown committed
3445

3446
    if ((res= multi_delete_precheck(thd, all_tables)))
3447
      break;
unknown's avatar
unknown committed
3448

unknown's avatar
unknown committed
3449
    /* condition will be TRUE on SP re-excuting */
3450 3451
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
unknown's avatar
unknown committed
3452
    if (add_item_to_list(thd, new Item_null()))
unknown's avatar
unknown committed
3453
      goto error;
3454

unknown's avatar
unknown committed
3455
    thd->proc_info="init";
unknown's avatar
VIEW  
unknown committed
3456 3457 3458 3459
    if ((res= open_and_lock_tables(thd, all_tables)))
      break;

    if ((res= mysql_multi_delete_prepare(thd)))
unknown's avatar
unknown committed
3460
      goto error;
3461

3462
    if (!thd->is_fatal_error && (result= new multi_delete(aux_tables,
3463
							  lex->table_count)))
unknown's avatar
unknown committed
3464
    {
3465 3466 3467
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3468
			select_lex->item_list,
unknown's avatar
unknown committed
3469
			select_lex->where,
3470
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
unknown's avatar
unknown committed
3471 3472
			(ORDER *)NULL,
			select_lex->options | thd->options |
3473 3474
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                        OPTION_SETUP_TABLES_DONE,
3475
			result, unit, select_lex);
3476
      delete result;
unknown's avatar
unknown committed
3477 3478
    }
    else
3479
      res= TRUE;                                // Error
unknown's avatar
unknown committed
3480 3481
    break;
  }
unknown's avatar
unknown committed
3482
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
3483
  {
unknown's avatar
VIEW  
unknown committed
3484
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3485 3486
    if (!lex->drop_temporary)
    {
unknown's avatar
VIEW  
unknown committed
3487
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
3488 3489
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
unknown's avatar
unknown committed
3490
        goto error;
3491
    }
unknown's avatar
unknown committed
3492
    else
unknown's avatar
unknown committed
3493 3494 3495 3496 3497 3498
    {
      /*
	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
3499 3500
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
unknown's avatar
unknown committed
3501 3502 3503
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
3504

unknown's avatar
unknown committed
3505
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
3506
      thd->options|= OPTION_KEEP_LOG;
unknown's avatar
unknown committed
3507
    }
unknown's avatar
VIEW  
unknown committed
3508 3509
    res= mysql_rm_table(thd, first_table, lex->drop_if_exists,
			lex->drop_temporary);
unknown's avatar
unknown committed
3510 3511
  }
  break;
unknown's avatar
unknown committed
3512
  case SQLCOM_DROP_INDEX:
unknown's avatar
VIEW  
unknown committed
3513 3514
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
unknown's avatar
unknown committed
3515
      goto error;				/* purecov: inspected */
3516
    if (end_active_trans(thd))
unknown's avatar
unknown committed
3517
      goto error;
3518
    res= mysql_drop_index(thd, first_table, &lex->alter_info);
unknown's avatar
unknown committed
3519 3520
    break;
  case SQLCOM_SHOW_PROCESSLIST:
3521 3522
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
3523
      break;
unknown's avatar
unknown committed
3524
    mysqld_list_processes(thd,
3525 3526 3527 3528
			  (thd->security_ctx->master_access & PROCESS_ACL ?
                           NullS :
                           thd->security_ctx->priv_user),
                          lex->verbose);
unknown's avatar
unknown committed
3529
    break;
unknown's avatar
unknown committed
3530 3531
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
unknown's avatar
unknown committed
3532
    break;
unknown's avatar
unknown committed
3533 3534 3535
  case SQLCOM_SHOW_AUTHORS:
    res= mysqld_show_authors(thd);
    break;
3536 3537 3538
  case SQLCOM_SHOW_CONTRIBUTORS:
    res= mysqld_show_contributors(thd);
    break;
unknown's avatar
unknown committed
3539 3540 3541 3542 3543 3544
  case SQLCOM_SHOW_PRIVILEGES:
    res= mysqld_show_privileges(thd);
    break;
  case SQLCOM_SHOW_COLUMN_TYPES:
    res= mysqld_show_column_types(thd);
    break;
unknown's avatar
unknown committed
3545
  case SQLCOM_SHOW_ENGINE_LOGS:
unknown's avatar
unknown committed
3546
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3547 3548
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
3549
    goto error;
unknown's avatar
unknown committed
3550 3551
#else
    {
3552
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0,0))
unknown's avatar
unknown committed
3553
	goto error;
unknown's avatar
unknown committed
3554
      res= ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_LOGS);
unknown's avatar
unknown committed
3555 3556
      break;
    }
unknown's avatar
unknown committed
3557 3558
#endif
  case SQLCOM_CHANGE_DB:
3559 3560
    if (!mysql_change_db(thd,select_lex->db,FALSE))
      send_ok(thd);
unknown's avatar
unknown committed
3561
    break;
3562

unknown's avatar
unknown committed
3563 3564
  case SQLCOM_LOAD:
  {
unknown's avatar
VIEW  
unknown committed
3565
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3566
    uint privilege= (lex->duplicates == DUP_REPLACE ?
unknown's avatar
unknown committed
3567 3568
		     INSERT_ACL | DELETE_ACL : INSERT_ACL) |
                    (lex->local_file ? 0 : FILE_ACL);
3569

unknown's avatar
unknown committed
3570
    if (lex->local_file)
unknown's avatar
unknown committed
3571
    {
3572
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
3573
          !opt_local_infile)
3574
      {
unknown's avatar
unknown committed
3575
	my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
3576 3577
	goto error;
      }
unknown's avatar
unknown committed
3578
    }
unknown's avatar
unknown committed
3579 3580 3581 3582

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

unknown's avatar
VIEW  
unknown committed
3583
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
unknown's avatar
unknown committed
3584
                    lex->update_list, lex->value_list, lex->duplicates,
3585
                    lex->ignore, (bool) lex->local_file);
unknown's avatar
unknown committed
3586 3587
    break;
  }
3588

unknown's avatar
unknown committed
3589
  case SQLCOM_SET_OPTION:
3590 3591
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
3592
    if ((check_table_access(thd, SELECT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
3593 3594
	 open_and_lock_tables(thd, all_tables)))
      goto error;
3595 3596
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
unknown's avatar
unknown committed
3597 3598
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
      goto error;
3599 3600 3601 3602 3603 3604 3605 3606
    }
    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;
3607
      send_ok(thd);
3608
    }
unknown's avatar
unknown committed
3609
    break;
3610
  }
unknown's avatar
unknown committed
3611

unknown's avatar
unknown committed
3612
  case SQLCOM_UNLOCK_TABLES:
3613 3614 3615 3616 3617 3618
    /*
      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
3619
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
3620 3621
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
3622
      end_active_trans(thd);
unknown's avatar
unknown committed
3623
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3624 3625
    }
    if (thd->global_read_lock)
3626
      unlock_global_read_lock(thd);
3627
    send_ok(thd);
unknown's avatar
unknown committed
3628 3629
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
3630
    unlock_locked_tables(thd);
unknown's avatar
VIEW  
unknown committed
3631
    if (check_db_used(thd, all_tables) || end_active_trans(thd))
unknown's avatar
unknown committed
3632
      goto error;
unknown's avatar
VIEW  
unknown committed
3633
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3634
      goto error;
unknown's avatar
unknown committed
3635
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
3636
    thd->options|= OPTION_TABLE_LOCK;
unknown's avatar
VIEW  
unknown committed
3637

3638
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
3639
    {
3640 3641
#ifdef HAVE_QUERY_CACHE
      if (thd->variables.query_cache_wlock_invalidate)
unknown's avatar
VIEW  
unknown committed
3642
	query_cache.invalidate_locked_for_write(first_table);
3643
#endif /*HAVE_QUERY_CACHE*/
unknown's avatar
unknown committed
3644 3645
      thd->locked_tables=thd->lock;
      thd->lock=0;
3646
      send_ok(thd);
unknown's avatar
unknown committed
3647
    }
unknown's avatar
unknown committed
3648 3649
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3650 3651 3652
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3653
  {
3654 3655 3656 3657 3658
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
unknown committed
3659
    char *alias;
unknown's avatar
unknown committed
3660
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3661
    {
3662
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3663 3664
      break;
    }
3665 3666 3667
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
3668
      For that reason, db_ok() in sql/slave.cc did not check the
3669 3670 3671
      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.
    */
3672
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3673 3674 3675
    if (thd->slave_thread && 
	(!rpl_filter->db_ok(lex->name) ||
	 !rpl_filter->db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3676
    {
unknown's avatar
unknown committed
3677
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3678
      break;
unknown's avatar
unknown committed
3679
    }
3680
#endif
3681
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3682
      break;
unknown's avatar
unknown committed
3683
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
unknown's avatar
unknown committed
3684
			 &lex->create_info, 0);
3685 3686
    break;
  }
unknown's avatar
unknown committed
3687
  case SQLCOM_DROP_DB:
3688
  {
3689 3690 3691 3692 3693
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3694
    if (check_db_name(lex->name))
unknown's avatar
unknown committed
3695
    {
3696
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3697 3698
      break;
    }
3699 3700 3701 3702 3703 3704 3705
    /*
      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.
    */
3706
#ifdef HAVE_REPLICATION
3707
    if (thd->slave_thread && 
unknown's avatar
unknown committed
3708 3709
	(!rpl_filter->db_ok(lex->name) ||
	 !rpl_filter->db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3710
    {
unknown's avatar
unknown committed
3711
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3712
      break;
unknown's avatar
unknown committed
3713
    }
3714
#endif
3715
    if (check_access(thd,DROP_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3716
      break;
3717 3718
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
3719 3720
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3721 3722
      goto error;
    }
3723
    res= mysql_rm_db(thd, lex->name, lex->drop_if_exists, 0);
3724 3725
    break;
  }
unknown's avatar
unknown committed
3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767
  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;
  }
3768 3769
  case SQLCOM_ALTER_DB:
  {
3770 3771
    char *db= lex->name ? lex->name : thd->db;
    if (!db)
3772
    {
unknown's avatar
unknown committed
3773 3774
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      break;
3775 3776
    }
    if (!strip_sp(db) || check_db_name(db))
3777
    {
unknown's avatar
unknown committed
3778
      my_error(ER_WRONG_DB_NAME, MYF(0), db);
3779 3780
      break;
    }
unknown's avatar
unknown committed
3781 3782 3783
    /*
      If in a slave thread :
      ALTER DATABASE DB may not be preceded by USE DB.
3784
      For that reason, maybe db_ok() in sql/slave.cc did not check the
unknown's avatar
unknown committed
3785 3786 3787 3788
      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
3789
    if (thd->slave_thread &&
unknown's avatar
unknown committed
3790 3791
	(!rpl_filter->db_ok(db) ||
	 !rpl_filter->db_ok_with_wild_table(db)))
unknown's avatar
unknown committed
3792
    {
unknown's avatar
unknown committed
3793
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
unknown's avatar
unknown committed
3794 3795 3796
      break;
    }
#endif
3797
    if (check_access(thd, ALTER_ACL, db, 0, 1, 0, is_schema_db(db)))
3798 3799 3800
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
3801 3802
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3803 3804
      goto error;
    }
3805
    res= mysql_alter_db(thd, db, &lex->create_info);
3806 3807
    break;
  }
unknown's avatar
unknown committed
3808 3809 3810 3811
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3812
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3813 3814
      break;
    }
unknown's avatar
unknown committed
3815
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
unknown's avatar
unknown committed
3816 3817
    break;
  }
unknown's avatar
unknown committed
3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843
  case SQLCOM_CREATE_EVENT:
  case SQLCOM_ALTER_EVENT:
  case SQLCOM_DROP_EVENT:
  {
    uint rows_affected= 1;
    DBUG_ASSERT(lex->et);
    do {
      if (! lex->et->dbname.str)
      {
        my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
        res= true;
        break;
      }

      if (check_access(thd, EVENT_ACL, lex->et->dbname.str, 0, 0, 0,
                       is_schema_db(lex->et->dbname.str)))
        break;

      if (end_active_trans(thd))
      {
        res= -1;
        break;
      }

      switch (lex->sql_command) {
      case SQLCOM_CREATE_EVENT:
3844
        res= Events::create_event(thd, lex->et,
3845 3846
                                  (uint) lex->create_info.options,
                                  &rows_affected);
unknown's avatar
unknown committed
3847 3848
        break;
      case SQLCOM_ALTER_EVENT:
3849
        res= Events::update_event(thd, lex->et, lex->spname,
3850
                                  &rows_affected);
unknown's avatar
unknown committed
3851 3852
        break;
      case SQLCOM_DROP_EVENT:
3853
        res= Events::drop_event(thd, lex->et, lex->drop_if_exists,
3854
                                &rows_affected);
unknown's avatar
unknown committed
3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891
      default:;
      }
      DBUG_PRINT("info", ("CREATE/ALTER/DROP returned error code=%d af_rows=%d",
                  res, rows_affected));
      if (!res)
        send_ok(thd, rows_affected);

      /* lex->unit.cleanup() is called outside, no need to call it here */
    } while (0);
    if (!thd->spcont)
    {
      lex->et->free_sphead_on_delete= true;
      lex->et->free_sp();
      lex->et->deinit_mutexes();
    }
    
    break;
  }
  case SQLCOM_SHOW_CREATE_EVENT:
  {
    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;
    }
    if (check_access(thd, EVENT_ACL, lex->spname->m_db.str, 0, 0, 0,
                     is_schema_db(lex->spname->m_db.str)))
      break;

    if (lex->spname->m_name.length > NAME_LEN)
    {
      my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
      goto error;
    }
3892
    res= Events::show_create_event(thd, lex->spname);
unknown's avatar
unknown committed
3893 3894
    break;
  }
3895 3896 3897 3898 3899 3900 3901
#ifndef DBUG_OFF
  case SQLCOM_SHOW_SCHEDULER_STATUS:
  {
    res= Events::dump_internal_status(thd);
    break;
  }
#endif
unknown's avatar
unknown committed
3902
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
unknown's avatar
unknown committed
3903
  {
3904
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0))
unknown's avatar
unknown committed
3905
      break;
unknown's avatar
unknown committed
3906
#ifdef HAVE_DLOPEN
3907 3908
    if (sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                        &thd->sp_func_cache, FALSE))
unknown's avatar
unknown committed
3909
    {
3910
      my_error(ER_UDF_EXISTS, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
3911 3912
      goto error;
    }
3913
    if (!(res = mysql_create_function(thd, &lex->udf)))
unknown's avatar
unknown committed
3914
      send_ok(thd);
unknown's avatar
unknown committed
3915
#else
unknown's avatar
unknown committed
3916
    my_error(ER_CANT_OPEN_LIBRARY, MYF(0), lex->udf.dl, 0, "feature disabled");
unknown's avatar
unknown committed
3917
    res= TRUE;
unknown's avatar
unknown committed
3918 3919
#endif
    break;
unknown's avatar
unknown committed
3920
  }
unknown's avatar
unknown committed
3921
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3922 3923
  case SQLCOM_CREATE_USER:
  {
3924
    if (check_access(thd, INSERT_ACL, "mysql", 0, 1, 1, 0) &&
3925
        check_global_access(thd,CREATE_USER_ACL))
3926
      break;
3927 3928
    if (end_active_trans(thd))
      goto error;
3929 3930 3931
    if (!(res= mysql_create_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
unknown's avatar
unknown committed
3932 3933
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3934 3935 3936 3937
      send_ok(thd);
    }
    break;
  }
3938 3939
  case SQLCOM_DROP_USER:
  {
3940
    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 1, 0) &&
3941
        check_global_access(thd,CREATE_USER_ACL))
3942
      break;
3943 3944
    if (end_active_trans(thd))
      goto error;
3945 3946 3947 3948
    if (!(res= mysql_drop_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3949 3950
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3951 3952 3953 3954 3955 3956 3957
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_RENAME_USER:
  {
3958
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
3959
        check_global_access(thd,CREATE_USER_ACL))
3960
      break;
3961 3962
    if (end_active_trans(thd))
      goto error;
3963 3964 3965 3966
    if (!(res= mysql_rename_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3967 3968
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3969 3970 3971 3972 3973 3974 3975
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
3976
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
3977
        check_global_access(thd,CREATE_USER_ACL))
3978 3979 3980 3981 3982
      break;
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3983 3984
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3985 3986 3987 3988 3989
      }
      send_ok(thd);
    }
    break;
  }
3990 3991 3992 3993
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
unknown's avatar
unknown committed
3994
		     first_table ?  first_table->db : select_lex->db,
unknown's avatar
VIEW  
unknown committed
3995
		     first_table ? &first_table->grant.privilege : 0,
3996 3997 3998
		     first_table ? 0 : 1, 0,
                     first_table ? (bool) first_table->schema_table :
                     select_lex->db ? is_schema_db(select_lex->db) : 0))
3999 4000
      goto error;

4001
    if (thd->security_ctx->user)              // If not replication
unknown's avatar
unknown committed
4002 4003
    {
      LEX_USER *user;
4004

unknown's avatar
unknown committed
4005
      List_iterator <LEX_USER> user_list(lex->users_list);
4006
      while ((user= user_list++))
unknown's avatar
unknown committed
4007
      {
4008 4009 4010 4011 4012 4013 4014 4015
        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);
4016
        if (strcmp(thd->security_ctx->user, user->user.str) ||
4017
            my_strcasecmp(system_charset_info,
4018
                          user->host.str, thd->security_ctx->host_or_ip))
4019 4020
        {
          // TODO: use check_change_password()
4021 4022
          if (is_acl_user(user->host.str, user->user.str) &&
              user->password.str &&
4023
              check_access(thd, UPDATE_ACL,"mysql",0,1,1,0))
4024 4025 4026 4027 4028 4029
          {
            my_message(ER_PASSWORD_NOT_ALLOWED,
                       ER(ER_PASSWORD_NOT_ALLOWED), MYF(0));
            goto error;
          }
        }
unknown's avatar
SCRUM  
unknown committed
4030 4031
      }
    }
unknown's avatar
VIEW  
unknown committed
4032
    if (first_table)
4033
    {
4034 4035
      if (lex->type == TYPE_ENUM_PROCEDURE ||
          lex->type == TYPE_ENUM_FUNCTION)
4036 4037 4038 4039 4040
      {
        uint grants= lex->all_privileges 
		   ? (PROC_ACLS & ~GRANT_ACL) | (lex->grant & GRANT_ACL)
		   : lex->grant;
        if (grant_option && 
4041 4042
	    check_grant_routine(thd, grants | GRANT_ACL, all_tables,
                                lex->type == TYPE_ENUM_PROCEDURE, 0))
4043
	  goto error;
4044 4045 4046 4047
        res= mysql_routine_grant(thd, all_tables,
                                 lex->type == TYPE_ENUM_PROCEDURE, 
                                 lex->users_list, grants,
                                 lex->sql_command == SQLCOM_REVOKE, 0);
4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060
      }
      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())
4061
      {
unknown's avatar
unknown committed
4062
        thd->clear_error();
unknown's avatar
unknown committed
4063 4064
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
4065 4066 4067 4068
      }
    }
    else
    {
4069
      if (lex->columns.elements || lex->type)
4070
      {
unknown's avatar
unknown committed
4071 4072
	my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE),
                   MYF(0));
unknown's avatar
unknown committed
4073
        goto error;
4074 4075 4076 4077 4078 4079 4080 4081
      }
      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
4082
          thd->clear_error();
unknown's avatar
unknown committed
4083 4084
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
4085
	}
4086
	if (lex->sql_command == SQLCOM_GRANT)
4087
	{
unknown's avatar
unknown committed
4088 4089 4090
	  List_iterator <LEX_USER> str_list(lex->users_list);
	  LEX_USER *user;
	  while ((user=str_list++))
unknown's avatar
unknown committed
4091
	    reset_mqh(user);
4092
	}
4093 4094 4095 4096
      }
    }
    break;
  }
unknown's avatar
SCRUM  
unknown committed
4097
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
unknown's avatar
unknown committed
4098
  case SQLCOM_RESET:
4099 4100 4101
    /*
      RESET commands are never written to the binary log, so we have to
      initialize this variable because RESET shares the same code as FLUSH
4102 4103 4104 4105
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
unknown's avatar
unknown committed
4106
    bool write_to_binlog;
unknown's avatar
VIEW  
unknown committed
4107
    if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, all_tables))
unknown's avatar
unknown committed
4108
      goto error;
4109 4110 4111 4112
    /*
      reload_acl_and_cache() will tell us if we are allowed to write to the
      binlog or not.
    */
unknown's avatar
unknown committed
4113
    if (!reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
4114 4115 4116 4117 4118 4119 4120 4121 4122
    {
      /*
        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())
        {
unknown's avatar
unknown committed
4123 4124
          thd->binlog_query(THD::STMT_QUERY_TYPE,
                            thd->query, thd->query_length, 0, FALSE);
4125 4126 4127 4128
        }
      }
      send_ok(thd);
    }
unknown's avatar
unknown committed
4129
    break;
4130
  }
unknown's avatar
unknown committed
4131
  case SQLCOM_KILL:
4132 4133 4134
  {
    Item *it= (Item *)lex->value_list.head();

4135
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) || it->check_cols(1))
4136 4137 4138 4139 4140
    {
      my_message(ER_SET_CONSTANTS_ONLY, ER(ER_SET_CONSTANTS_ONLY),
		 MYF(0));
      goto error;
    }
4141
    sql_kill(thd, (ulong)it->val_int(), lex->type & ONLY_KILL_QUERY);
unknown's avatar
unknown committed
4142
    break;
4143
  }
unknown's avatar
unknown committed
4144
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
4145
  case SQLCOM_SHOW_GRANTS:
4146 4147
    if ((thd->security_ctx->priv_user &&
	 !strcmp(thd->security_ctx->priv_user, lex->grant_user->user.str)) ||
4148
	!check_access(thd, SELECT_ACL, "mysql",0,1,0,0))
unknown's avatar
unknown committed
4149 4150 4151 4152
    {
      res = mysql_show_grants(thd,lex->grant_user);
    }
    break;
unknown's avatar
unknown committed
4153
#endif
4154
  case SQLCOM_HA_OPEN:
unknown's avatar
VIEW  
unknown committed
4155 4156 4157
    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))
4158
      goto error;
unknown's avatar
unknown committed
4159
    res= mysql_ha_open(thd, first_table, 0);
4160 4161
    break;
  case SQLCOM_HA_CLOSE:
unknown's avatar
VIEW  
unknown committed
4162 4163
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables))
4164
      goto error;
unknown's avatar
VIEW  
unknown committed
4165
    res= mysql_ha_close(thd, first_table);
4166 4167
    break;
  case SQLCOM_HA_READ:
unknown's avatar
VIEW  
unknown committed
4168
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
4169 4170 4171 4172 4173
    /*
      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
4174
    if (check_db_used(thd, all_tables))
4175
      goto error;
4176
    unit->set_limit(select_lex);
4177
    res= mysql_ha_read(thd, first_table, lex->ha_read_mode, lex->ident.str,
unknown's avatar
VIEW  
unknown committed
4178
                       lex->insert_list, lex->ha_rkey_mode, select_lex->where,
4179
                       unit->select_limit_cnt, unit->offset_limit_cnt);
4180 4181
    break;

unknown's avatar
unknown committed
4182
  case SQLCOM_BEGIN:
4183 4184 4185 4186 4187 4188
    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
4189
    if (begin_trans(thd))
unknown's avatar
unknown committed
4190
      goto error;
unknown's avatar
unknown committed
4191
    send_ok(thd);
unknown's avatar
unknown committed
4192 4193
    break;
  case SQLCOM_COMMIT:
4194
    if (end_trans(thd, lex->tx_release ? COMMIT_RELEASE :
unknown's avatar
unknown committed
4195
                              lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
unknown's avatar
unknown committed
4196
      goto error;
4197
    send_ok(thd);
unknown's avatar
unknown committed
4198 4199
    break;
  case SQLCOM_ROLLBACK:
4200
    if (end_trans(thd, lex->tx_release ? ROLLBACK_RELEASE :
unknown's avatar
unknown committed
4201
                              lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
unknown's avatar
unknown committed
4202
      goto error;
4203
    send_ok(thd);
unknown's avatar
unknown committed
4204
    break;
unknown's avatar
unknown committed
4205
  case SQLCOM_RELEASE_SAVEPOINT:
unknown's avatar
unknown committed
4206
  {
4207 4208
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
unknown's avatar
unknown committed
4209 4210 4211
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4212
                       (uchar *)sv->name, sv->length) == 0)
unknown's avatar
unknown committed
4213 4214
        break;
    }
4215
    if (sv)
unknown's avatar
unknown committed
4216
    {
4217
      if (ha_release_savepoint(thd, sv))
unknown's avatar
unknown committed
4218
        res= TRUE; // cannot happen
unknown's avatar
unknown committed
4219 4220
      else
        send_ok(thd);
4221
      thd->transaction.savepoints=sv->prev;
unknown's avatar
unknown committed
4222
    }
4223
    else
unknown's avatar
unknown committed
4224
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
4225
    break;
unknown's avatar
unknown committed
4226
  }
unknown's avatar
unknown committed
4227
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
unknown's avatar
unknown committed
4228
  {
4229 4230
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
4231 4232 4233
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4234
                       (uchar *)sv->name, sv->length) == 0)
4235 4236
        break;
    }
4237
    if (sv)
4238
    {
4239
      if (ha_rollback_to_savepoint(thd, sv))
4240 4241
        res= TRUE; // cannot happen
      else
unknown's avatar
unknown committed
4242
      {
4243 4244
        if ((thd->options &
             (OPTION_STATUS_NO_TRANS_UPDATE | OPTION_KEEP_LOG)) &&
unknown's avatar
unknown committed
4245 4246 4247 4248 4249 4250
            !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);
      }
4251
      thd->transaction.savepoints=sv;
unknown's avatar
unknown committed
4252 4253
    }
    else
4254
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
4255
    break;
4256
  }
4257
  case SQLCOM_SAVEPOINT:
4258 4259
    if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN) ||
          thd->in_sub_stmt) || !opt_using_transactions)
unknown's avatar
unknown committed
4260
      send_ok(thd);
unknown's avatar
unknown committed
4261
    else
4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299
    {
      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
4300
    break;
4301 4302
  case SQLCOM_CREATE_PROCEDURE:
  case SQLCOM_CREATE_SPFUNCTION:
unknown's avatar
unknown committed
4303
  {
4304
    uint namelen;
4305
    char *name, *db;
unknown's avatar
unknown committed
4306
    int result;
4307

4308
    DBUG_ASSERT(lex->sphead != 0);
4309

4310 4311
    if (!lex->sphead->m_db.str || !lex->sphead->m_db.str[0])
    {
4312
      if (!thd->db)
4313 4314 4315 4316 4317 4318 4319 4320 4321 4322
      {
        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;
    }

4323 4324
    if (check_access(thd, CREATE_PROC_ACL, lex->sphead->m_db.str, 0, 0, 0,
                     is_schema_db(lex->sphead->m_db.str)))
4325 4326 4327 4328 4329 4330
    {
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
    }

4331
    if (end_active_trans(thd)) 
4332
    {
4333 4334 4335
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
4336
    }
4337 4338

    name= lex->sphead->name(&namelen);
4339
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
4340 4341 4342
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
4343

unknown's avatar
unknown committed
4344
      if (udf)
4345
      {
4346
	my_error(ER_UDF_EXISTS, MYF(0), name);
unknown's avatar
unknown committed
4347
	delete lex->sphead;
4348
	lex->sphead= 0;
4349
	goto error;
4350
      }
unknown's avatar
unknown committed
4351 4352 4353
    }
#endif

4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437
    /*
      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 */

4438 4439 4440 4441 4442
    /*
      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.
    */
4443
    name= thd->strdup(name); 
4444 4445
    lex->sphead->m_db.str= db= thd->strmake(lex->sphead->m_db.str,
                                            lex->sphead->m_db.length);
unknown's avatar
unknown committed
4446
    res= (result= lex->sphead->create(thd));
unknown's avatar
unknown committed
4447 4448
    if (result == SP_OK)
    {
4449 4450 4451
      /*
        We must cleanup the unit and the lex here because
        sp_grant_privileges calls (indirectly) db_find_routine,
4452
        which in turn may call MYSQLparse with THD::lex.
4453 4454
        TODO: fix db_find_routine to use a temporary lex.
      */
4455
      lex->unit.cleanup();
unknown's avatar
unknown committed
4456 4457
      delete lex->sphead;
      lex->sphead= 0;
unknown's avatar
unknown committed
4458
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4459
      /* only add privileges if really neccessary */
4460
      if (sp_automatic_privileges && !opt_noacl &&
4461 4462 4463
          check_routine_access(thd, DEFAULT_CREATE_PROC_ACLS,
      			       db, name,
                               lex->sql_command == SQLCOM_CREATE_PROCEDURE, 1))
4464
      {
4465 4466
        if (sp_grant_privileges(thd, db, name, 
                                lex->sql_command == SQLCOM_CREATE_PROCEDURE))
4467 4468 4469
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
	  	       ER_PROC_AUTO_GRANT_FAIL,
		       ER(ER_PROC_AUTO_GRANT_FAIL));
unknown's avatar
unknown committed
4470
        close_thread_tables(thd);
4471
      }
unknown's avatar
unknown committed
4472
#endif
4473
      send_ok(thd);
unknown's avatar
unknown committed
4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493
    }
    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;
      }
4494
      lex->unit.cleanup();
unknown's avatar
unknown committed
4495 4496 4497
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
4498
    }
unknown's avatar
unknown committed
4499 4500
    break;
  }
4501 4502 4503 4504
  case SQLCOM_CALL:
    {
      sp_head *sp;

4505 4506 4507 4508 4509 4510 4511 4512 4513
      /*
        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;

      /*
4514 4515
        By this moment all needed SPs should be in cache so no need to look 
        into DB. 
4516
      */
4517 4518
      if (!(sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                                &thd->sp_proc_cache, TRUE)))
4519
      {
4520
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PROCEDURE",
unknown's avatar
unknown committed
4521
                 lex->spname->m_qname.str);
4522
	goto error;
4523 4524 4525
      }
      else
      {
4526
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4527
	Security_context *save_ctx;
4528
#endif
unknown's avatar
unknown committed
4529
	ha_rows select_limit;
unknown's avatar
unknown committed
4530 4531
        /* bits that should be cleared in thd->server_status */
	uint bits_to_be_cleared= 0;
4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543
        /*
          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;
        }
4544

4545 4546
	my_bool nsok= thd->net.no_send_ok;
	thd->net.no_send_ok= TRUE;
4547
	if (sp->m_flags & sp_head::MULTI_RESULTS)
4548
	{
4549
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
4550
	  {
4551 4552 4553 4554
            /*
              The client does not support multiple result sets being sent
              back
            */
4555
	    my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str);
4556 4557 4558
	    thd->net.no_send_ok= nsok;
	    goto error;
	  }
unknown's avatar
unknown committed
4559 4560 4561 4562 4563 4564 4565
          /*
            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;
4566 4567
	}

4568
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4569 4570 4571
	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))
4572 4573 4574 4575
	{
	  thd->net.no_send_ok= nsok;
	  goto error;
	}
4576 4577 4578
	if (save_ctx &&
            check_routine_access(thd, EXECUTE_ACL,
                                 sp->m_db.str, sp->m_name.str, TRUE, 0))
4579 4580
	{
	  thd->net.no_send_ok= nsok;
4581
	  sp_restore_security_context(thd, save_ctx);
4582 4583 4584
	  goto error;
	}

4585
#endif
unknown's avatar
unknown committed
4586 4587
	select_limit= thd->variables.select_limit;
	thd->variables.select_limit= HA_POS_ERROR;
4588

4589
        thd->row_count_func= 0;
4590 4591
        
        /* 
4592
          We never write CALL statements into binlog:
4593 4594 4595 4596 4597
           - 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.
4598
        */
4599
	res= sp->execute_procedure(thd, &lex->value_list);
4600 4601 4602
	/*
          If warnings have been cleared, we have to clear total_warn_count
          too, otherwise the clients get confused.
4603 4604 4605 4606
	 */
	if (thd->warn_list.is_empty())
	  thd->total_warn_count= 0;

unknown's avatar
unknown committed
4607
	thd->variables.select_limit= select_limit;
4608
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4609
	sp_restore_security_context(thd, save_ctx);
4610
#endif
4611

4612
	thd->net.no_send_ok= nsok;
unknown's avatar
unknown committed
4613
        thd->server_status&= ~bits_to_be_cleared;
4614

unknown's avatar
unknown committed
4615
	if (!res)
unknown's avatar
unknown committed
4616 4617
	  send_ok(thd, (ulong) (thd->row_count_func < 0 ? 0 :
                                thd->row_count_func));
4618 4619
	else
	  goto error;		// Substatement should already have sent error
4620
      }
4621
      break;
4622 4623
    }
  case SQLCOM_ALTER_PROCEDURE:
4624
  case SQLCOM_ALTER_FUNCTION:
4625
    {
unknown's avatar
unknown committed
4626
      int result;
4627 4628 4629 4630
      sp_head *sp;
      st_sp_chistics chistics;

      memcpy(&chistics, &lex->sp_chistics, sizeof(chistics));
unknown's avatar
unknown committed
4631
      if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4632 4633
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
4634
      else
4635 4636
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
unknown's avatar
unknown committed
4637
      mysql_reset_errors(thd, 0);
4638
      if (! sp)
4639 4640 4641 4642 4643 4644 4645 4646 4647
      {
	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;
	}
      }
4648 4649
      else
      {
4650 4651 4652
        if (check_routine_access(thd, ALTER_PROC_ACL, sp->m_db.str, 
				 sp->m_name.str,
                                 lex->sql_command == SQLCOM_ALTER_PROCEDURE, 0))
4653
	  goto error;
4654 4655 4656

        if (end_active_trans(thd)) 
          goto error;
4657
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
4658 4659
        if ((sp->m_type == TYPE_ENUM_FUNCTION) &&
            !trust_function_creators &&  mysql_bin_log.is_open() &&
4660 4661 4662 4663 4664 4665 4666 4667 4668 4669
            !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
        {
4670 4671 4672 4673 4674 4675
          /*
            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.
          */
4676 4677 4678 4679 4680
          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);
        }
4681
      }
unknown's avatar
unknown committed
4682
      switch (result)
4683
      {
unknown's avatar
unknown committed
4684
      case SP_OK:
4685 4686 4687
        if (mysql_bin_log.is_open())
        {
          thd->clear_error();
unknown's avatar
unknown committed
4688 4689
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
4690
        }
4691
	send_ok(thd);
unknown's avatar
unknown committed
4692 4693
	break;
      case SP_KEY_NOT_FOUND:
4694 4695
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4696 4697
	goto error;
      default:
4698 4699
	my_error(ER_SP_CANT_ALTER, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4700
	goto error;
4701
      }
4702
      break;
4703 4704
    }
  case SQLCOM_DROP_PROCEDURE:
4705
  case SQLCOM_DROP_FUNCTION:
4706
    {
unknown's avatar
unknown committed
4707
      int result;
4708 4709
      int type= (lex->sql_command == SQLCOM_DROP_PROCEDURE ?
                 TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION);
4710

4711
      result= sp_routine_exists_in_table(thd, type, lex->spname);
unknown's avatar
unknown committed
4712
      mysql_reset_errors(thd, 0);
4713
      if (result == SP_OK)
4714
      {
4715 4716 4717
        char *db= lex->spname->m_db.str;
	char *name= lex->spname->m_name.str;

4718 4719
	if (check_routine_access(thd, ALTER_PROC_ACL, db, name,
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE, 0))
unknown's avatar
merge  
unknown committed
4720
          goto error;
4721 4722 4723

        if (end_active_trans(thd)) 
          goto error;
unknown's avatar
unknown committed
4724
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4725
	if (sp_automatic_privileges && !opt_noacl &&
4726 4727
	    sp_revoke_privileges(thd, db, name, 
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE))
4728 4729 4730 4731 4732
	{
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
		       ER_PROC_AUTO_REVOKE_FAIL,
		       ER(ER_PROC_AUTO_REVOKE_FAIL));
	}
unknown's avatar
unknown committed
4733
#endif
4734
	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
unknown's avatar
merge  
unknown committed
4735
	  result= sp_drop_procedure(thd, lex->spname);
4736
	else
unknown's avatar
merge  
unknown committed
4737
	  result= sp_drop_function(thd, lex->spname);
4738 4739 4740
      }
      else
      {
4741
#ifdef HAVE_DLOPEN
4742 4743 4744 4745 4746 4747
	if (lex->sql_command == SQLCOM_DROP_FUNCTION)
	{
          udf_func *udf = find_udf(lex->spname->m_name.str,
                                   lex->spname->m_name.length);
          if (udf)
          {
4748
	    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 0, 0))
4749 4750
	      goto error;
	    if (!(res = mysql_drop_function(thd, &lex->spname->m_name)))
4751
	    {
4752 4753
	      send_ok(thd);
	      break;
4754 4755
	    }
	  }
4756
	}
4757
#endif
4758 4759 4760 4761 4762 4763 4764
	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;
	}
4765
      }
unknown's avatar
unknown committed
4766 4767
      res= result;
      switch (result)
4768 4769
      {
      case SP_OK:
4770 4771 4772
        if (mysql_bin_log.is_open())
        {
          thd->clear_error();
unknown's avatar
unknown committed
4773 4774
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
4775
        }
4776
	send_ok(thd);
4777 4778
	break;
      case SP_KEY_NOT_FOUND:
4779 4780
	if (lex->drop_if_exists)
	{
4781
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
4782
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
4783
			      SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4784
	  res= FALSE;
4785 4786 4787
	  send_ok(thd);
	  break;
	}
4788 4789
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4790 4791
	goto error;
      default:
4792 4793
	my_error(ER_SP_DROP_FAILED, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4794
	goto error;
4795
      }
4796
      break;
4797
    }
unknown's avatar
unknown committed
4798 4799
  case SQLCOM_SHOW_CREATE_PROC:
    {
4800
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4801
      {
4802
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4803 4804
	goto error;
      }
unknown's avatar
unknown committed
4805
      if (sp_show_create_procedure(thd, lex->spname) != SP_OK)
4806
      {			/* We don't distinguish between errors for now */
4807 4808
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4809 4810 4811 4812 4813 4814
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
4815
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4816
      {
4817
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4818 4819
	goto error;
      }
unknown's avatar
unknown committed
4820
      if (sp_show_create_function(thd, lex->spname) != SP_OK)
4821
      {			/* We don't distinguish between errors for now */
4822 4823
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4824 4825 4826 4827 4828 4829
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
4830
      res= sp_show_status_procedure(thd, (lex->wild ?
unknown's avatar
unknown committed
4831 4832 4833 4834 4835
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
4836
      res= sp_show_status_function(thd, (lex->wild ? 
unknown's avatar
unknown committed
4837 4838 4839
					 lex->wild->ptr() : NullS));
      break;
    }
unknown's avatar
unknown committed
4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851
#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
4852 4853
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
unknown's avatar
unknown committed
4854
      else
unknown's avatar
unknown committed
4855 4856
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
4857
      if (!sp || sp->show_routine_code(thd))
4858 4859
      {
        /* We don't distinguish between errors for now */
unknown's avatar
unknown committed
4860 4861 4862 4863 4864 4865 4866
        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
4867 4868
  case SQLCOM_CREATE_VIEW:
    {
4869 4870 4871
      if (end_active_trans(thd))
        goto error;

4872 4873 4874
      if (!(res= mysql_create_view(thd, thd->lex->create_view_mode)) &&
          mysql_bin_log.is_open())
      {
4875
        String buff;
unknown's avatar
unknown committed
4876 4877 4878 4879
        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
4880
        thd->clear_error();
4881 4882 4883 4884

        buff.append(command[thd->lex->create_view_mode].str,
                    command[thd->lex->create_view_mode].length);
        view_store_options(thd, first_table, &buff);
4885
        buff.append(STRING_WITH_LEN("VIEW "));
4886 4887
        /* Test if user supplied a db (ie: we did not use thd->db) */
        if (first_table->db != thd->db && first_table->db[0])
4888 4889 4890 4891 4892 4893 4894
        {
          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);
4895
        buff.append(STRING_WITH_LEN(" AS "));
4896 4897
        buff.append(first_table->source.str, first_table->source.length);

unknown's avatar
unknown committed
4898 4899
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          buff.ptr(), buff.length(), FALSE, FALSE);
4900
      }
unknown's avatar
VIEW  
unknown committed
4901 4902 4903 4904
      break;
    }
  case SQLCOM_DROP_VIEW:
    {
unknown's avatar
unknown committed
4905 4906 4907
      if (check_table_access(thd, DROP_ACL, all_tables, 0) ||
          end_active_trans(thd))
        goto error;
4908 4909 4910
      if (!(res= mysql_drop_view(thd, first_table, thd->lex->drop_mode)) &&
          mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
4911
        thd->clear_error();
unknown's avatar
unknown committed
4912 4913
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
4914
      }
unknown's avatar
VIEW  
unknown committed
4915 4916
      break;
    }
4917 4918
  case SQLCOM_CREATE_TRIGGER:
  {
4919 4920 4921
    if (end_active_trans(thd))
      goto error;

4922 4923 4924
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

    /* We don't care about trigger body after this point */
4925 4926 4927 4928 4929 4930
    delete lex->sphead;
    lex->sphead= 0;
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
4931 4932 4933
    if (end_active_trans(thd))
      goto error;

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

end:
unknown's avatar
unknown committed
5143
  thd->proc_info="query end";
5144 5145

  /*
unknown's avatar
unknown committed
5146
    Binlog-related cleanup:
5147 5148 5149 5150 5151 5152 5153 5154 5155 5156
    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);
5157
#ifdef HAVE_ROW_BASED_REPLICATION
unknown's avatar
unknown committed
5158
  thd->reset_current_stmt_binlog_row_based();
5159
#endif /*HAVE_ROW_BASED_REPLICATION*/
5160

5161
  /*
5162 5163 5164 5165 5166 5167
    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.
5168
   */
5169 5170
  if (lex->sql_command != SQLCOM_CALL && lex->sql_command != SQLCOM_EXECUTE &&
      uc_update_queries[lex->sql_command]<2)
5171
    thd->row_count_func= -1;
unknown's avatar
unknown committed
5172
  DBUG_RETURN(res || thd->net.report_error);
unknown's avatar
unknown committed
5173 5174

error:
unknown's avatar
unknown committed
5175 5176
  res= 1;           // would be better to set res=1 before "goto error"
  goto end;
unknown's avatar
unknown committed
5177 5178 5179
}


unknown's avatar
unknown committed
5180 5181
/*
  Check grants for commands which work only with one table and all other
5182
  tables belonging to subselects or implicitly opened tables.
unknown's avatar
unknown committed
5183

5184
  SYNOPSIS
unknown's avatar
unknown committed
5185 5186
    check_one_table_access()
    thd			Thread handler
5187
    privilege		requested privilege
unknown's avatar
VIEW  
unknown committed
5188
    all_tables		global table list of query
unknown's avatar
unknown committed
5189 5190 5191

  RETURN
    0 - OK
unknown's avatar
unknown committed
5192
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
5193 5194
*/

5195
bool check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *all_tables)
unknown's avatar
unknown committed
5196
{
5197 5198 5199 5200 5201 5202
  Security_context * backup_ctx= thd->security_ctx;

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

unknown's avatar
VIEW  
unknown committed
5203
  if (check_access(thd, privilege, all_tables->db,
5204 5205
		   &all_tables->grant.privilege, 0, 0,
                   test(all_tables->schema_table)))
5206
    goto deny;
unknown's avatar
unknown committed
5207

unknown's avatar
unknown committed
5208
  /* Show only 1 table for check_grant */
unknown's avatar
VIEW  
unknown committed
5209
  if (grant_option && check_grant(thd, privilege, all_tables, 0, 1, 0))
5210 5211 5212
    goto deny;

  thd->security_ctx= backup_ctx;
unknown's avatar
unknown committed
5213

5214
  /* Check rights on tables of subselects and implictly opened tables */
unknown's avatar
unknown committed
5215
  TABLE_LIST *subselects_tables;
unknown's avatar
VIEW  
unknown committed
5216
  if ((subselects_tables= all_tables->next_global))
unknown's avatar
unknown committed
5217
  {
unknown's avatar
VIEW  
unknown committed
5218
    if ((check_table_access(thd, SELECT_ACL, subselects_tables, 0)))
5219
      goto deny;
unknown's avatar
unknown committed
5220 5221
  }
  return 0;
5222 5223 5224 5225

deny:
  thd->security_ctx= backup_ctx;
  return 1;
unknown's avatar
unknown committed
5226 5227 5228
}


unknown's avatar
unknown committed
5229
/****************************************************************************
unknown's avatar
unknown committed
5230
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243

  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
5244 5245
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
5246 5247 5248
****************************************************************************/

bool
unknown's avatar
unknown committed
5249
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
5250
	     bool dont_check_global_grants, bool no_errors, bool schema_db)
unknown's avatar
unknown committed
5251
{
5252
  Security_context *sctx= thd->security_ctx;
unknown's avatar
unknown committed
5253 5254
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
unknown's avatar
unknown committed
5255
  bool  db_is_pattern= test(want_access & GRANT_ACL);
unknown's avatar
unknown committed
5256 5257
#endif
  ulong dummy;
5258 5259
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
5260
                      db ? db : "", want_access, sctx->master_access));
unknown's avatar
unknown committed
5261 5262 5263 5264 5265
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

5266
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
5267
  {
5268
    DBUG_PRINT("error",("No database"));
5269
    if (!no_errors)
unknown's avatar
unknown committed
5270 5271
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                 MYF(0));                       /* purecov: tested */
unknown's avatar
unknown committed
5272
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5273 5274
  }

5275 5276 5277 5278 5279
  if (schema_db)
  {
    if (want_access & ~(SELECT_ACL | EXTRA_ACL))
    {
      if (!no_errors)
5280 5281
      {
        const char *db_name= db ? db : thd->db;
5282
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5283 5284
                 sctx->priv_user, sctx->priv_host, db_name);
      }
5285 5286 5287 5288 5289 5290 5291 5292 5293
      DBUG_RETURN(TRUE);
    }
    else
    {
      *save_priv= SELECT_ACL;
      DBUG_RETURN(FALSE);
    }
  }

unknown's avatar
unknown committed
5294 5295 5296
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
5297
  if ((sctx->master_access & want_access) == want_access)
unknown's avatar
unknown committed
5298
  {
5299 5300 5301 5302 5303
    /*
      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
    */
5304 5305
    db_access= sctx->db_access;
    if (!(sctx->master_access & SELECT_ACL) &&
unknown's avatar
unknown committed
5306
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
5307 5308 5309
      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
5310
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
5311
  }
5312
  if (((want_access & ~sctx->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
5313
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
5314
  {						// We can never grant this
5315
    DBUG_PRINT("error",("No possible access"));
5316
    if (!no_errors)
5317
      my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
5318 5319
               sctx->priv_user,
               sctx->priv_host,
5320 5321 5322
               (thd->password ?
                ER(ER_YES) :
                ER(ER_NO)));                    /* purecov: tested */
unknown's avatar
unknown committed
5323
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5324 5325 5326
  }

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

unknown's avatar
unknown committed
5329
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
5330 5331
    db_access= acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                       db_is_pattern);
unknown's avatar
unknown committed
5332
  else
5333
    db_access= sctx->db_access;
5334
  DBUG_PRINT("info",("db_access: %lu", db_access));
unknown's avatar
unknown committed
5335
  /* Remove SHOW attribute and access rights we already have */
5336
  want_access &= ~(sctx->master_access | EXTRA_ACL);
5337 5338
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
5339
  db_access= ((*save_priv=(db_access | sctx->master_access)) & want_access);
5340 5341

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
5342
  if (db_access == want_access ||
5343
      (grant_option && !dont_check_global_grants &&
5344
       !(want_access & ~(db_access | TABLE_ACLS | PROC_ACLS))))
unknown's avatar
unknown committed
5345
    DBUG_RETURN(FALSE);				/* Ok */
5346 5347

  DBUG_PRINT("error",("Access denied"));
5348
  if (!no_errors)
5349
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5350
             sctx->priv_user, sctx->priv_host,
5351 5352 5353
             (db ? db : (thd->db ?
                         thd->db :
                         "unknown")));          /* purecov: tested */
unknown's avatar
unknown committed
5354
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5355
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
5356 5357 5358
}


5359 5360 5361 5362 5363 5364 5365 5366 5367
/*
  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
5368
    One gets access right if one has ANY of the rights in want_access
5369 5370 5371 5372 5373 5374 5375 5376
    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
5377 5378

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
5379
{
unknown's avatar
unknown committed
5380 5381 5382
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
5383
  char command[128];
5384
  if ((thd->security_ctx->master_access & want_access))
unknown's avatar
unknown committed
5385 5386
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
5387
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
unknown's avatar
unknown committed
5388
  return 1;
unknown's avatar
unknown committed
5389
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
5390 5391 5392
}


unknown's avatar
unknown committed
5393
/*
unknown's avatar
unknown committed
5394 5395
  Check the privilege for all used tables.  Table privileges are cached
  in the table list for GRANT checking
unknown's avatar
unknown committed
5396 5397
*/

5398
bool
unknown's avatar
unknown committed
5399
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
5400
		   bool no_errors)
unknown's avatar
unknown committed
5401
{
unknown's avatar
unknown committed
5402 5403
  uint found=0;
  ulong found_access=0;
5404 5405
  TABLE_LIST *org_tables= tables;
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
5406
  Security_context *sctx= thd->security_ctx, *backup_ctx= thd->security_ctx;
5407
  /*
unknown's avatar
unknown committed
5408 5409 5410
    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.
5411
  */
unknown's avatar
unknown committed
5412
  for (; tables != first_not_own_table; tables= tables->next_global)
unknown's avatar
unknown committed
5413
  {
5414 5415 5416 5417 5418
    if (tables->security_ctx)
      sctx= tables->security_ctx;
    else
      sctx= backup_ctx;

5419
    if (tables->schema_table && 
5420
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5421 5422 5423
    {
      if (!no_errors)
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5424
                 sctx->priv_user, sctx->priv_host,
5425 5426 5427
                 information_schema_name.str);
      return TRUE;
    }
5428 5429 5430 5431 5432
    /*
       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);
5433
    if (tables->derived || tables->schema_table ||
5434
        (tables->table && (int)tables->table->s->tmp_table) ||
5435 5436
        my_tz_check_n_skip_implicit_tables(&tables,
                                           thd->lex->time_zone_tables_used))
unknown's avatar
unknown committed
5437
      continue;
5438 5439
    thd->security_ctx= sctx;
    if ((sctx->master_access & want_access) ==
5440
        (want_access & ~EXTRA_ACL) &&
unknown's avatar
unknown committed
5441
	thd->db)
unknown's avatar
unknown committed
5442
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
5443
    else if (tables->db && tables->db == thd->db)
unknown's avatar
unknown committed
5444 5445 5446 5447 5448
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
5449
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5450
			 0, no_errors, test(tables->schema_table)))
5451
	  goto deny;                            // Access denied
unknown's avatar
unknown committed
5452
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
5453
	found=1;
unknown's avatar
unknown committed
5454 5455
      }
    }
5456
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5457
			  0, no_errors, test(tables->schema_table)))
5458
      goto deny;
unknown's avatar
unknown committed
5459
  }
5460
  thd->security_ctx= backup_ctx;
unknown's avatar
unknown committed
5461
  if (grant_option)
5462
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
unknown's avatar
unknown committed
5463
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
unknown's avatar
unknown committed
5464
  return FALSE;
5465 5466 5467
deny:
  thd->security_ctx= backup_ctx;
  return TRUE;
unknown's avatar
unknown committed
5468 5469
}

5470

5471
bool
5472 5473
check_routine_access(THD *thd, ulong want_access,char *db, char *name,
		     bool is_proc, bool no_errors)
5474 5475 5476 5477 5478
{
  TABLE_LIST tables[1];
  
  bzero((char *)tables, sizeof(TABLE_LIST));
  tables->db= db;
5479
  tables->table_name= tables->alias= name;
5480
  
unknown's avatar
unknown committed
5481 5482 5483 5484 5485 5486 5487
  /*
    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)
5488 5489
    tables->grant.privilege= want_access;
  else if (check_access(thd,want_access,db,&tables->grant.privilege,
unknown's avatar
unknown committed
5490
			0, no_errors, 0))
5491 5492
    return TRUE;
  
unknown's avatar
unknown committed
5493
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5494
  if (grant_option)
5495
    return check_grant_routine(thd, want_access, tables, is_proc, no_errors);
unknown's avatar
unknown committed
5496
#endif
5497 5498 5499 5500

  return FALSE;
}

5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515

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

5516 5517
bool check_some_routine_access(THD *thd, const char *db, const char *name,
                               bool is_proc)
5518 5519
{
  ulong save_priv;
5520
  if (thd->security_ctx->master_access & SHOW_PROC_ACLS)
5521
    return FALSE;
5522 5523 5524 5525 5526
  /*
    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) ||
5527 5528
      (save_priv & SHOW_PROC_ACLS))
    return FALSE;
5529
  return check_routine_level_acl(thd, db, name, is_proc);
5530 5531 5532
}


5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557
/*
  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,
5558 5559
                        &table->grant.privilege, 0, 1,
                        test(table->schema_table)) &&
5560 5561 5562 5563 5564 5565 5566 5567 5568
          !grant_option || !check_grant(thd, access, table, 0, 1, 1))
        DBUG_RETURN(0);
    }
  }
  DBUG_PRINT("exit",("no matching access rights"));
  DBUG_RETURN(1);
}


5569 5570
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
5571 5572 5573 5574
{
  int error=0;
  if (table_list)
  {
5575
    /* Check that all tables use the current database */
5576
    TABLE_LIST *tmp;
unknown's avatar
VIEW  
unknown committed
5577
    for (tmp= table_list; tmp; tmp= tmp->next_local)
5578 5579 5580 5581
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
5582
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
unknown's avatar
unknown committed
5583
			     table_list,0);
5584 5585 5586 5587
  }
  return error;
}

unknown's avatar
unknown committed
5588 5589 5590

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
unknown's avatar
VIEW  
unknown committed
5591
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
5592 5593 5594 5595 5596
  {
    if (!tables->db)
    {
      if (!(tables->db=thd->db))
      {
unknown's avatar
unknown committed
5597 5598
	my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                   MYF(0));                     /* purecov: tested */
unknown's avatar
unknown committed
5599 5600 5601 5602 5603 5604
	return TRUE;				/* purecov: tested */
      }
    }
  }
  return FALSE;
}
5605

5606

unknown's avatar
unknown committed
5607 5608 5609 5610 5611 5612 5613 5614 5615 5616
/****************************************************************************
	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
5617 5618 5619 5620
#ifndef DBUG_OFF
long max_stack_used;
#endif

5621
#ifndef EMBEDDED_LIBRARY
5622 5623 5624 5625 5626 5627 5628 5629
/*
  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
5630 5631
{
  long stack_used;
5632
  DBUG_ASSERT(thd == current_thd);
unknown's avatar
unknown committed
5633
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
unknown's avatar
unknown committed
5634
      (long) (thread_stack - margin))
unknown's avatar
unknown committed
5635
  {
5636 5637 5638
    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));
5639
    thd->fatal_error();
unknown's avatar
unknown committed
5640 5641
    return 1;
  }
unknown's avatar
unknown committed
5642 5643 5644
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
unknown's avatar
unknown committed
5645 5646
  return 0;
}
5647
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
5648 5649 5650 5651

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

5652
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
unknown's avatar
unknown committed
5653 5654
{
  LEX	*lex=current_lex;
5655
  ulong old_info=0;
unknown's avatar
unknown committed
5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681
  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;
}


/****************************************************************************
5682
  Initialize global thd variables needed for query
unknown's avatar
unknown committed
5683 5684
****************************************************************************/

5685
void
unknown's avatar
unknown committed
5686
mysql_init_query(THD *thd, uchar *buf, uint length)
unknown's avatar
unknown committed
5687 5688
{
  DBUG_ENTER("mysql_init_query");
unknown's avatar
unknown committed
5689
  lex_start(thd, buf, length);
5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710
  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");
5711
  thd->free_list= 0;
5712
  thd->select_number= 1;
unknown's avatar
unknown committed
5713
  thd->last_insert_id_used= thd->query_start_used= thd->insert_id_used=0;
5714
  thd->is_fatal_error= thd->time_zone_used= 0;
unknown's avatar
unknown committed
5715
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
unknown's avatar
unknown committed
5716 5717
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
5718 5719 5720 5721 5722 5723 5724 5725
  /*
    If in autocommit mode and not in a transaction, reset
    OPTION_STATUS_NO_TRANS_UPDATE | OPTION_KEEP_LOG to not get warnings
    in ha_rollback_trans() about some tables couldn't be rolled back.
  */
  if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))
    thd->options&= ~(OPTION_STATUS_NO_TRANS_UPDATE | OPTION_KEEP_LOG);

5726
  DBUG_ASSERT(thd->security_ctx== &thd->main_security_ctx);
unknown's avatar
unknown committed
5727
  thd->tmp_table_used= 0;
5728 5729
  if (!thd->in_sub_stmt)
  {
5730
    if (opt_bin_log)
5731
    {
5732
      reset_dynamic(&thd->user_var_events);
5733 5734
      thd->user_var_events_alloc= thd->mem_root;
    }
5735
    thd->clear_error();
5736 5737 5738 5739
    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
5740 5741 5742
  DBUG_VOID_RETURN;
}

5743

5744 5745 5746
void
mysql_init_select(LEX *lex)
{
unknown's avatar
unknown committed
5747
  SELECT_LEX *select_lex= lex->current_select;
unknown's avatar
unknown committed
5748
  select_lex->init_select();
5749
  lex->wild= 0;
5750 5751
  if (select_lex == &lex->select_lex)
  {
5752
    DBUG_ASSERT(lex->result == 0);
5753 5754
    lex->exchange= 0;
  }
5755 5756
}

5757

unknown's avatar
unknown committed
5758
bool
unknown's avatar
unknown committed
5759
mysql_new_select(LEX *lex, bool move_down)
5760
{
unknown's avatar
unknown committed
5761
  SELECT_LEX *select_lex;
5762
  THD *thd= lex->thd;
unknown's avatar
unknown committed
5763 5764
  DBUG_ENTER("mysql_new_select");

5765
  if (!(select_lex= new (thd->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
5766
    DBUG_RETURN(1);
5767
  select_lex->select_number= ++thd->select_number;
unknown's avatar
unknown committed
5768
  select_lex->parent_lex= lex; /* Used in init_query. */
unknown's avatar
unknown committed
5769 5770
  select_lex->init_query();
  select_lex->init_select();
unknown's avatar
unknown committed
5771 5772
  lex->nest_level++;
  select_lex->nest_level= lex->nest_level;
5773 5774 5775 5776 5777
  /*
    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
5778
  if (thd->stmt_arena->is_stmt_prepare())
5779
    select_lex->uncacheable|= UNCACHEABLE_PREPARE;
unknown's avatar
unknown committed
5780 5781
  if (move_down)
  {
unknown's avatar
unknown committed
5782
    SELECT_LEX_UNIT *unit;
5783
    lex->subqueries= TRUE;
unknown's avatar
unknown committed
5784
    /* first select_lex of subselect or derived table */
5785
    if (!(unit= new (thd->mem_root) SELECT_LEX_UNIT()))
unknown's avatar
unknown committed
5786
      DBUG_RETURN(1);
unknown's avatar
unknown committed
5787

unknown's avatar
unknown committed
5788 5789
    unit->init_query();
    unit->init_select();
5790
    unit->thd= thd;
unknown's avatar
unknown committed
5791
    unit->include_down(lex->current_select);
unknown's avatar
unknown committed
5792 5793
    unit->link_next= 0;
    unit->link_prev= 0;
5794
    unit->return_to= lex->current_select;
unknown's avatar
unknown committed
5795
    select_lex->include_down(unit);
5796 5797 5798 5799 5800
    /*
      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
5801 5802
  }
  else
unknown's avatar
unknown committed
5803
  {
unknown's avatar
VIEW  
unknown committed
5804 5805
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
unknown's avatar
unknown committed
5806
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
unknown's avatar
unknown committed
5807
      DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
5808
    }
5809
    select_lex->include_neighbour(lex->current_select);
5810 5811 5812 5813 5814
    SELECT_LEX_UNIT *unit= select_lex->master_unit();                              
    if (!unit->fake_select_lex && unit->add_fake_select_lex(lex->thd))
      DBUG_RETURN(1);
    select_lex->context.outer_context= 
                unit->first_select()->context.outer_context;
unknown's avatar
unknown committed
5815
  }
unknown's avatar
unknown committed
5816

5817
  select_lex->master_unit()->global_parameters= select_lex;
5818
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
5819
  lex->current_select= select_lex;
5820 5821 5822 5823 5824
  /*
    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
5825
  DBUG_RETURN(0);
5826
}
unknown's avatar
unknown committed
5827

5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842
/*
  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)
{
5843
  THD *thd;
5844
  LEX *lex;
5845
  LEX_STRING tmp, null_lex_string;
5846 5847
  Item *var;
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
5848
  DBUG_ENTER("create_select_for_variable");
5849 5850

  thd= current_thd;
unknown's avatar
unknown committed
5851
  lex= thd->lex;
5852 5853 5854 5855
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
5856
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
5857 5858 5859 5860
  /*
    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
5861 5862 5863 5864 5865 5866
  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);
  }
5867 5868 5869
  DBUG_VOID_RETURN;
}

5870

unknown's avatar
unknown committed
5871 5872
void mysql_init_multi_delete(LEX *lex)
{
unknown's avatar
unknown committed
5873
  lex->sql_command=  SQLCOM_DELETE_MULTI;
unknown's avatar
unknown committed
5874
  mysql_init_select(lex);
5875 5876
  lex->select_lex.select_limit= 0;
  lex->unit.select_limit_cnt= HA_POS_ERROR;
unknown's avatar
unknown committed
5877
  lex->select_lex.table_list.save_and_clear(&lex->auxilliary_table_list);
5878
  lex->lock_option= using_update_log ? TL_READ_NO_INSERT : TL_READ;
unknown's avatar
VIEW  
unknown committed
5879 5880
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
unknown's avatar
unknown committed
5881
}
unknown's avatar
unknown committed
5882

5883 5884 5885 5886
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
5887

5888
void mysql_parse(THD *thd, char *inBuf, uint length)
unknown's avatar
unknown committed
5889 5890
{
  DBUG_ENTER("mysql_parse");
unknown's avatar
unknown committed
5891
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
5892
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
unknown's avatar
unknown committed
5893
  {
unknown's avatar
unknown committed
5894
    LEX *lex= thd->lex;
5895
    
5896 5897
    sp_cache_flush_obsolete(&thd->sp_proc_cache);
    sp_cache_flush_obsolete(&thd->sp_func_cache);
5898
    
5899
    if (!MYSQLparse((void *)thd) && ! thd->is_fatal_error)
unknown's avatar
unknown committed
5900
    {
unknown's avatar
unknown committed
5901
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5902
      if (mqh_used && thd->user_connect &&
5903
	  check_mqh(thd, lex->sql_command))
5904 5905 5906 5907
      {
	thd->net.error = 0;
      }
      else
unknown's avatar
unknown committed
5908
#endif
5909
      {
unknown's avatar
unknown committed
5910
	if (thd->net.report_error)
5911
	{
unknown's avatar
unknown committed
5912 5913 5914 5915 5916 5917 5918 5919 5920 5921
          delete lex->sphead;
          lex->sphead= NULL;
          if (lex->et)
          {
            lex->et->free_sphead_on_delete= true;
            /* alloced on thd->mem_root so no real memory free but dtor call */
            lex->et->free_sp();
            lex->et->deinit_mutexes();
            lex->et= NULL;
          }
5922
	}
unknown's avatar
unknown committed
5923 5924
	else
	{
5925 5926 5927 5928 5929 5930 5931 5932 5933 5934
          /*
            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
5935 5936
          if (lex->found_semicolon &&
              (thd->query_length= (ulong)(lex->found_semicolon - thd->query)))
5937 5938
            thd->query_length--;
          /* Actually execute the query */
unknown's avatar
unknown committed
5939
	  mysql_execute_command(thd);
unknown's avatar
SCRUM  
unknown committed
5940
	  query_cache_end_of_result(thd);
unknown's avatar
unknown committed
5941
	}
5942
      }
5943
      lex->unit.cleanup();
unknown's avatar
unknown committed
5944 5945
    }
    else
5946
    {
5947
      DBUG_ASSERT(thd->net.report_error);
5948
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
5949
			 thd->is_fatal_error));
unknown's avatar
unknown committed
5950
      query_cache_abort(&thd->net);
5951
      lex->unit.cleanup();
unknown's avatar
unknown committed
5952
      if (lex->sphead)
5953
      {
unknown's avatar
unknown committed
5954
	/* Clean up after failed stored procedure/function */
unknown's avatar
unknown committed
5955 5956 5957 5958 5959 5960 5961 5962 5963
	delete lex->sphead;
	lex->sphead= NULL;
      }
      if (lex->et)
      {
        lex->et->free_sphead_on_delete= true;
        lex->et->free_sp();
        lex->et->deinit_mutexes();
        lex->et= NULL;
5964
      }
5965
    }
unknown's avatar
unknown committed
5966
    thd->proc_info="freeing items";
5967
    thd->end_statement();
5968
    thd->cleanup_after_query();
5969
    DBUG_ASSERT(thd->change_list.is_empty());
unknown's avatar
unknown committed
5970
  }
unknown's avatar
unknown committed
5971 5972 5973 5974
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
5975
#ifdef HAVE_REPLICATION
5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986
/*
  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
5987
  LEX *lex= thd->lex;
5988
  bool error= 0;
unknown's avatar
unknown committed
5989
  DBUG_ENTER("mysql_test_parse_for_slave");
5990

unknown's avatar
unknown committed
5991
  mysql_init_query(thd, (uchar*) inBuf, length);
5992
  if (!MYSQLparse((void*) thd) && ! thd->is_fatal_error &&
5993
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
unknown's avatar
unknown committed
5994
    error= 1;                  /* Ignore question */
5995
  thd->end_statement();
5996
  thd->cleanup_after_query();
unknown's avatar
unknown committed
5997
  DBUG_RETURN(error);
5998
}
unknown's avatar
unknown committed
5999
#endif
unknown's avatar
unknown committed
6000

6001

unknown's avatar
unknown committed
6002

unknown's avatar
unknown committed
6003 6004 6005 6006 6007
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

unknown's avatar
unknown committed
6008
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
unknown's avatar
unknown committed
6009
		       char *length, char *decimals,
6010
		       uint type_modifier,
6011 6012
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
6013 6014
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
unknown's avatar
unknown committed
6015
		       uint uint_geom_type)
unknown's avatar
unknown committed
6016 6017
{
  register create_field *new_field;
unknown's avatar
unknown committed
6018
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
6019 6020 6021 6022
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
6023
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
unknown's avatar
unknown committed
6024 6025 6026 6027 6028
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
6029 6030
    lex->key_list.push_back(new Key(Key::PRIMARY, NullS,
                                    &default_key_create_info,
6031
				    0, lex->col_list));
unknown's avatar
unknown committed
6032 6033 6034 6035 6036
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
6037 6038
    lex->key_list.push_back(new Key(Key::UNIQUE, NullS,
                                    &default_key_create_info, 0,
unknown's avatar
unknown committed
6039 6040 6041 6042
				    lex->col_list));
    lex->col_list.empty();
  }

6043
  if (default_value)
unknown's avatar
unknown committed
6044
  {
6045
    /* 
unknown's avatar
unknown committed
6046 6047
      Default value should be literal => basic constants =>
      no need fix_fields()
6048 6049 6050
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
6051
    */
6052 6053 6054
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
6055
    {
6056
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
6057 6058 6059
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
unknown's avatar
unknown committed
6060
    {
6061
      default_value= 0;
6062 6063 6064
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
6065
	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
6066 6067 6068 6069 6070
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
6071
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
unknown's avatar
unknown committed
6072 6073 6074
      DBUG_RETURN(1);
    }
  }
6075 6076 6077

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
6078
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
6079 6080
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
6081

6082 6083 6084 6085 6086 6087
  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
6088
    char buf[32];
6089
    my_snprintf(buf, sizeof(buf), "TIMESTAMP(%s)", length);
unknown's avatar
unknown committed
6090
    WARN_DEPRECATED(thd, "5.2", buf, "'TIMESTAMP'");
6091 6092
  }

6093 6094 6095 6096
  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
6097
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6098 6099 6100 6101 6102 6103

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

6104

unknown's avatar
unknown committed
6105 6106 6107 6108 6109 6110 6111 6112
/* 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
6113
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
6114 6115 6116 6117
{
  ORDER *order;
  Item	**item_ptr;

unknown's avatar
unknown committed
6118
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
unknown's avatar
unknown committed
6119 6120 6121 6122 6123
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
unknown's avatar
unknown committed
6124
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
6125 6126 6127 6128 6129 6130 6131 6132
  return 0;
}


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

static void remove_escape(char *name)
{
6133 6134
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
6135 6136
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
6137
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
6138 6139 6140 6141 6142
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
6143 6144
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
unknown's avatar
unknown committed
6145 6146 6147 6148 6149 6150 6151 6152
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
6153
      name++;					// Skip '\\'
unknown's avatar
unknown committed
6154 6155 6156 6157 6158 6159 6160 6161 6162 6163
    *to++= *name;
  }
  *to=0;
}

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


unknown's avatar
unknown committed
6164
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
unknown's avatar
unknown committed
6165 6166 6167
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
unknown's avatar
unknown committed
6168
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
unknown's avatar
unknown committed
6169
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6170 6171
  order->item_ptr= item;
  order->item= &order->item_ptr;
unknown's avatar
unknown committed
6172 6173 6174
  order->asc = asc;
  order->free_me=0;
  order->used=0;
6175
  order->counter_used= 0;
unknown's avatar
unknown committed
6176
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
6177 6178 6179 6180
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199
/*
  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
6200 6201
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
6202
					     LEX_STRING *alias,
unknown's avatar
unknown committed
6203 6204
					     ulong table_options,
					     thr_lock_type lock_type,
6205 6206
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
unknown's avatar
unknown committed
6207
                                             LEX_STRING *option)
unknown's avatar
unknown committed
6208 6209
{
  register TABLE_LIST *ptr;
unknown's avatar
unknown committed
6210
  TABLE_LIST *previous_table_ref; /* The table preceding the current one. */
unknown's avatar
unknown committed
6211
  char *alias_str;
6212
  LEX *lex= thd->lex;
unknown's avatar
unknown committed
6213
  DBUG_ENTER("add_table_to_list");
6214
  LINT_INIT(previous_table_ref);
unknown's avatar
unknown committed
6215 6216 6217 6218

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
unknown's avatar
unknown committed
6219
  if (check_table_name(table->table.str,table->table.length))
unknown's avatar
unknown committed
6220
  {
6221
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
unknown's avatar
unknown committed
6222 6223
    DBUG_RETURN(0);
  }
unknown's avatar
unknown committed
6224 6225 6226 6227 6228
  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
6229 6230

  if (!alias)					/* Alias is case sensitive */
6231 6232 6233
  {
    if (table->sel)
    {
unknown's avatar
unknown committed
6234 6235
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
6236 6237
      DBUG_RETURN(0);
    }
6238
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
6239
      DBUG_RETURN(0);
6240
  }
unknown's avatar
unknown committed
6241
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
6242
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
6243
  if (table->db.str)
6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254
  {
    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
  {
6255 6256
    /* The following can't be "" as we may do 'casedn_str()' on it */
    ptr->db= empty_c_string;
6257 6258
    ptr->db_length= 0;
  }
unknown's avatar
unknown committed
6259
  if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
6260
    ptr->db= thd->strdup(ptr->db);
unknown's avatar
unknown committed
6261

6262
  ptr->alias= alias_str;
6263 6264
  if (lower_case_table_names && table->table.length)
    my_casedn_str(files_charset_info, table->table.str);
6265 6266
  ptr->table_name=table->table.str;
  ptr->table_name_length=table->table.length;
6267
  ptr->lock_type=   lock_type;
unknown's avatar
unknown committed
6268 6269
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
6270
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
6271
  ptr->derived=	    table->sel;
6272 6273
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
                                      information_schema_name.str))
6274
  {
6275
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
6276 6277 6278
    if (!schema_table ||
        (schema_table->hidden && 
         lex->orig_sql_command == SQLCOM_END))  // not a 'show' command
6279
    {
unknown's avatar
unknown committed
6280
      my_error(ER_UNKNOWN_TABLE, MYF(0),
6281
               ptr->table_name, information_schema_name.str);
6282 6283
      DBUG_RETURN(0);
    }
6284
    ptr->schema_table_name= ptr->table_name;
6285 6286
    ptr->schema_table= schema_table;
  }
6287
  ptr->select_lex=  lex->current_select;
unknown's avatar
unknown committed
6288
  ptr->cacheable_table= 1;
6289 6290 6291 6292 6293 6294
  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
6295
  ptr->option= option ? option->str : 0;
unknown's avatar
unknown committed
6296
  /* check that used name is unique */
6297
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
6298
  {
unknown's avatar
unknown committed
6299 6300 6301 6302
    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
6303
	 tables ;
unknown's avatar
VIEW  
unknown committed
6304
	 tables=tables->next_local)
unknown's avatar
unknown committed
6305
    {
6306 6307
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
6308
      {
6309
	my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
unknown's avatar
unknown committed
6310 6311
	DBUG_RETURN(0);				/* purecov: tested */
      }
unknown's avatar
unknown committed
6312 6313
    }
  }
unknown's avatar
unknown committed
6314 6315 6316
  /* Store the table reference preceding the current one. */
  if (table_list.elements > 0)
  {
6317 6318 6319
    /*
      table_list.next points to the last inserted TABLE_LIST->next_local'
      element
6320
      We don't use the offsetof() macro here to avoid warnings from gcc
6321
    */
6322 6323 6324
    previous_table_ref= (TABLE_LIST*) ((char*) table_list.next -
                                       ((char*) &(ptr->next_local) -
                                        (char*) ptr));
6325 6326 6327 6328 6329 6330 6331 6332
    /*
      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
6333
  }
6334

unknown's avatar
unknown committed
6335 6336 6337 6338 6339 6340
  /*
    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
6341
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
unknown's avatar
unknown committed
6342
  ptr->next_name_resolution_table= NULL;
6343
  /* Link table in global list (all used tables) */
6344
  lex->add_to_query_tables(ptr);
unknown's avatar
unknown committed
6345 6346 6347
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
6348

6349 6350 6351 6352
/*
  Initialize a new table list for a nested join

  SYNOPSIS
unknown's avatar
unknown committed
6353
    init_nested_join()
6354
    thd         current thread
6355

6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374
  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");
6375

6376 6377
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6378
    DBUG_RETURN(1);
6379 6380 6381
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401
  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
6402
    moves it one level up, eliminating the nest.
6403 6404 6405 6406 6407 6408 6409 6410 6411

  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;
6412
  NESTED_JOIN *nested_join;
6413
  DBUG_ENTER("end_nested_join");
6414

unknown's avatar
unknown committed
6415
  DBUG_ASSERT(embedding);
6416 6417 6418
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
6419
  nested_join= ptr->nested_join;
6420 6421 6422 6423 6424 6425 6426 6427 6428
  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;
  }
6429
  else if (nested_join->join_list.elements == 0)
unknown's avatar
unknown committed
6430 6431
  {
    join_list->pop();
6432
    ptr= 0;                                     // return value
unknown's avatar
unknown committed
6433
  }
6434 6435 6436 6437 6438 6439 6440 6441
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
6442
    nest_last_join()
6443 6444 6445 6446 6447 6448
    thd         current thread

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

  RETURN VALUE
6449 6450 6451
    0  Error
    #  Pointer to TABLE_LIST element created for the new nested join

6452 6453 6454 6455 6456 6457
*/

TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
6458
  List<TABLE_LIST> *embedded_list;
6459
  DBUG_ENTER("nest_last_join");
6460

6461 6462
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6463
    DBUG_RETURN(0);
6464 6465 6466
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6467 6468
  ptr->embedding= embedding;
  ptr->join_list= join_list;
6469
  embedded_list= &nested_join->join_list;
6470
  embedded_list->empty();
6471 6472

  for (uint i=0; i < 2; i++)
6473 6474 6475 6476 6477
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
unknown's avatar
unknown committed
6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490
    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;
      }
    }
6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530
  }
  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
6531 6532 6533

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556
    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
*/

6557
TABLE_LIST *st_select_lex::convert_right_join()
6558 6559
{
  TABLE_LIST *tab2= join_list->pop();
6560
  TABLE_LIST *tab1= join_list->pop();
6561 6562 6563 6564 6565 6566 6567 6568 6569
  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
6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582
/*
  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
6583
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
unknown's avatar
unknown committed
6584 6585 6586 6587 6588 6589
{
  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
6590 6591 6592
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
unknown's avatar
unknown committed
6593 6594 6595 6596 6597 6598 6599
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
6600

unknown's avatar
unknown committed
6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629
/*
  Create a fake SELECT_LEX for a unit

  SYNOPSIS:
    add_fake_select_lex()
    thd			   thread handle

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

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

bool st_select_lex_unit::add_fake_select_lex(THD *thd)
{
  SELECT_LEX *first_sl= first_select();
  DBUG_ENTER("add_fake_select_lex");
  DBUG_ASSERT(!fake_select_lex);
unknown's avatar
unknown committed
6630

unknown's avatar
unknown committed
6631 6632 6633 6634 6635
  if (!(fake_select_lex= new (thd->mem_root) SELECT_LEX()))
      DBUG_RETURN(1);
  fake_select_lex->include_standalone(this, 
                                      (SELECT_LEX_NODE**)&fake_select_lex);
  fake_select_lex->select_number= INT_MAX;
unknown's avatar
unknown committed
6636
  fake_select_lex->parent_lex= thd->lex; /* Used in init_query. */
unknown's avatar
unknown committed
6637 6638
  fake_select_lex->make_empty_select();
  fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
6639 6640
  fake_select_lex->select_limit= 0;

unknown's avatar
unknown committed
6641
  fake_select_lex->context.outer_context=first_sl->context.outer_context;
6642 6643 6644
  /* allow item list resolving in fake select for ORDER BY */
  fake_select_lex->context.resolve_in_select_list= TRUE;
  fake_select_lex->context.select_lex= fake_select_lex;
unknown's avatar
unknown committed
6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657

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

6662

unknown's avatar
unknown committed
6663
/*
6664 6665
  Push a new name resolution context for a JOIN ... ON clause to the
  context stack of a query block.
unknown's avatar
unknown committed
6666 6667

  SYNOPSIS
6668
    push_new_name_resolution_context()
unknown's avatar
unknown committed
6669
    thd       pointer to current thread
unknown's avatar
unknown committed
6670
    left_op   left  operand of the JOIN
unknown's avatar
unknown committed
6671 6672 6673 6674
    right_op  rigth operand of the JOIN

  DESCRIPTION
    Create a new name resolution context for a JOIN ... ON clause,
6675 6676 6677
    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
6678 6679

  RETURN
6680 6681
    FALSE  if all is OK
    TRUE   if a memory allocation error occured
unknown's avatar
unknown committed
6682 6683
*/

6684 6685 6686
bool
push_new_name_resolution_context(THD *thd,
                                 TABLE_LIST *left_op, TABLE_LIST *right_op)
unknown's avatar
unknown committed
6687 6688
{
  Name_resolution_context *on_context;
6689
  if (!(on_context= new (thd->mem_root) Name_resolution_context))
6690
    return TRUE;
unknown's avatar
unknown committed
6691 6692 6693 6694 6695
  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();
6696
  return thd->lex->push_context(on_context);
unknown's avatar
unknown committed
6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716
}


/*
  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
6717
{
6718
  if (expr)
6719
  {
6720
    if (!b->on_expr)
unknown's avatar
unknown committed
6721
      b->on_expr= expr;
6722 6723
    else
    {
unknown's avatar
unknown committed
6724 6725 6726 6727 6728 6729
      /*
        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);
6730 6731
    }
    b->on_expr->top_level_item();
6732
  }
unknown's avatar
unknown committed
6733 6734 6735
}


6736
/*
unknown's avatar
unknown committed
6737 6738
  Mark that there is a NATURAL JOIN or JOIN ... USING between two
  tables.
6739 6740 6741

  SYNOPSIS
    add_join_natural()
unknown's avatar
unknown committed
6742 6743 6744 6745
    a			Left join argument
    b			Right join argument
    using_fields        Field names from USING clause
  
6746
  IMPLEMENTATION
unknown's avatar
unknown committed
6747 6748 6749 6750 6751 6752 6753 6754 6755 6756
    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
6757 6758 6759
    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
6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770

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

unknown's avatar
unknown committed
6773
void add_join_natural(TABLE_LIST *a, TABLE_LIST *b, List<String> *using_fields)
unknown's avatar
unknown committed
6774
{
unknown's avatar
unknown committed
6775 6776
  b->natural_join= a;
  b->join_using_fields= using_fields;
unknown's avatar
unknown committed
6777 6778
}

unknown's avatar
unknown committed
6779

6780
/*
6781 6782 6783 6784
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
6785
    thd			Thread handler (can be NULL!)
6786 6787 6788 6789 6790
    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
6791 6792 6793
                        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.
6794 6795 6796

  RETURN
    0	 ok
unknown's avatar
unknown committed
6797
    !=0  error.  thd->killed or thd->net.report_error is set
6798 6799
*/

6800 6801
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
unknown's avatar
unknown committed
6802 6803 6804
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
6805
  bool tmp_write_to_binlog= 1;
6806

6807
  if (thd && thd->in_sub_stmt)
6808 6809 6810 6811 6812
  {
    my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "FLUSH");
    return 1;
  }

unknown's avatar
SCRUM  
unknown committed
6813
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
6814 6815
  if (options & REFRESH_GRANT)
  {
6816 6817 6818 6819 6820 6821
    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)))
6822 6823
    {
      thd->thread_stack= (char*) &tmp_thd;
6824
      thd->store_globals();
6825
    }
6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837
    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;
    }
6838
    reset_mqh((LEX_USER *)NULL, TRUE);
unknown's avatar
unknown committed
6839
  }
unknown's avatar
SCRUM  
unknown committed
6840
#endif
unknown's avatar
unknown committed
6841 6842
  if (options & REFRESH_LOG)
  {
6843
    /*
unknown's avatar
unknown committed
6844
      Flush the normal query log, the update log, the binary log,
unknown's avatar
unknown committed
6845 6846
      the slow query log, the relay log (if it exists) and the log
      tables.
6847
    */
unknown's avatar
unknown committed
6848

6849
    /*
unknown's avatar
unknown committed
6850 6851 6852 6853
      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)
6854 6855
    */
    tmp_write_to_binlog= 0;
6856
    mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
unknown's avatar
unknown committed
6857
#ifdef HAVE_REPLICATION
6858
    pthread_mutex_lock(&LOCK_active_mi);
6859
    rotate_relay_log(active_mi);
6860
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
6861
#endif
unknown's avatar
unknown committed
6862 6863 6864 6865 6866

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

    if (ha_flush_logs(NULL))
unknown's avatar
unknown committed
6867
      result=1;
unknown's avatar
unknown committed
6868 6869
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
6870
  }
unknown's avatar
unknown committed
6871
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
6872 6873
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
6874
    query_cache.pack();				// FLUSH QUERY CACHE
6875
    options &= ~REFRESH_QUERY_CACHE;    // Don't flush cache, just free memory
unknown's avatar
unknown committed
6876 6877 6878
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
6879
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
6880
  }
unknown's avatar
unknown committed
6881
#endif /*HAVE_QUERY_CACHE*/
6882 6883 6884 6885 6886
  /*
    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
6887
  {
6888
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
6889
    {
6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900
      /*
        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
6901
        {
6902 6903 6904 6905 6906
          if ((*lock_p)->type == TL_WRITE)
          {
            my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
            return 1;
          }
unknown's avatar
unknown committed
6907
        }
6908
      }
unknown's avatar
unknown committed
6909 6910 6911 6912
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
6913
      tmp_write_to_binlog= 0;
6914
      if (lock_global_read_lock(thd))
unknown's avatar
unknown committed
6915
	return 1;                               // Killed
6916 6917
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
unknown's avatar
unknown committed
6918
      if (make_global_read_lock_block_commit(thd)) // Killed
6919 6920 6921 6922 6923
      {
        /* Don't leave things in a half-locked state */
        unlock_global_read_lock(thd);
        return 1;
      }
unknown's avatar
unknown committed
6924
    }
6925 6926
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
6927
    my_dbopt_cleanup();
unknown's avatar
unknown committed
6928 6929 6930
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
unknown's avatar
unknown committed
6931
  if (thd && (options & REFRESH_STATUS))
unknown's avatar
unknown committed
6932
    refresh_status(thd);
unknown's avatar
unknown committed
6933 6934
  if (options & REFRESH_THREADS)
    flush_thread_cache();
unknown's avatar
unknown committed
6935
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
6936
  if (options & REFRESH_MASTER)
6937
  {
6938
    DBUG_ASSERT(thd);
6939
    tmp_write_to_binlog= 0;
6940
    if (reset_master(thd))
unknown's avatar
unknown committed
6941
    {
6942
      result=1;
unknown's avatar
unknown committed
6943 6944
      thd->fatal_error();                       // Ensure client get error
    }
6945
  }
6946
#endif
unknown's avatar
unknown committed
6947
#ifdef OPENSSL
6948 6949 6950 6951 6952 6953
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
unknown's avatar
unknown committed
6954
#ifdef HAVE_REPLICATION
6955 6956
 if (options & REFRESH_SLAVE)
 {
6957
   tmp_write_to_binlog= 0;
6958
   pthread_mutex_lock(&LOCK_active_mi);
6959
   if (reset_slave(thd, active_mi))
6960
     result=1;
6961
   pthread_mutex_unlock(&LOCK_active_mi);
6962
 }
6963
#endif
6964
 if (options & REFRESH_USER_RESOURCES)
unknown's avatar
unknown committed
6965
   reset_mqh((LEX_USER *) NULL);
unknown's avatar
unknown committed
6966
 *write_to_binlog= tmp_write_to_binlog;
6967
 return result;
unknown's avatar
unknown committed
6968 6969
}

6970

6971
/*
6972
  kills a thread
6973 6974 6975 6976 6977

  SYNOPSIS
    kill_one_thread()
    thd			Thread class
    id			Thread id
6978
    only_kill_query     Should it kill the query or the connection
6979 6980 6981 6982 6983

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

6984
uint kill_one_thread(THD *thd, ulong id, bool only_kill_query)
unknown's avatar
unknown committed
6985 6986 6987
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
6988 6989
  DBUG_ENTER("kill_one_thread");
  DBUG_PRINT("enter", ("id=%lu only_kill=%d", id, only_kill_query));
6990 6991
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
6992 6993
  while ((tmp=it++))
  {
unknown's avatar
unknown committed
6994 6995
    if (tmp->command == COM_DAEMON)
      continue;
unknown's avatar
unknown committed
6996 6997
    if (tmp->thread_id == id)
    {
6998 6999
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
7000 7001 7002
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
7003 7004
  if (tmp)
  {
7005 7006
    if ((thd->security_ctx->master_access & SUPER_ACL) ||
	!strcmp(thd->security_ctx->user, tmp->security_ctx->user))
7007
    {
unknown's avatar
SCRUM  
unknown committed
7008
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
7009 7010 7011 7012 7013 7014
      error=0;
    }
    else
      error=ER_KILL_DENIED_ERROR;
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }
7015 7016 7017 7018
  DBUG_PRINT("exit", ("%d", error));
  DBUG_RETURN(error);
}

7019

7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033
/*
  kills a thread and sends response

  SYNOPSIS
    sql_kill()
    thd			Thread class
    id			Thread id
    only_kill_query     Should it kill the query or the connection
*/

void sql_kill(THD *thd, ulong id, bool only_kill_query)
{
  uint error;
  if (!(error= kill_one_thread(thd, id, only_kill_query)))
7034
    send_ok(thd);
unknown's avatar
unknown committed
7035
  else
unknown's avatar
unknown committed
7036
    my_error(error, MYF(0), id);
unknown's avatar
unknown committed
7037 7038
}

unknown's avatar
unknown committed
7039

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

unknown's avatar
unknown committed
7042 7043
bool append_file_to_dir(THD *thd, const char **filename_ptr,
                        const char *table_name)
7044
{
7045
  char buff[FN_REFLEN],*ptr, *end;
7046 7047 7048 7049 7050 7051 7052
  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))
  {
7053
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
7054 7055 7056 7057
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
7058
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
7059
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
7060 7061
    return 1;					// End of memory
  *filename_ptr=ptr;
7062
  strxmov(ptr,buff,table_name,NullS);
7063 7064
  return 0;
}
7065

7066

7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080
/*
  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;
7081 7082
  LEX *lex= thd->lex;
  if (lex->current_select != &lex->select_lex)
7083 7084
  {
    char command[80];
7085 7086
    strmake(command, lex->yylval->symbol.str,
	    min(lex->yylval->symbol.length, sizeof(command)-1));
7087
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
7088 7089 7090 7091
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
7092

unknown's avatar
unknown committed
7093

unknown's avatar
unknown committed
7094
Comp_creator *comp_eq_creator(bool invert)
unknown's avatar
unknown committed
7095
{
unknown's avatar
unknown committed
7096
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
unknown's avatar
unknown committed
7097 7098
}

unknown's avatar
unknown committed
7099

unknown's avatar
unknown committed
7100
Comp_creator *comp_ge_creator(bool invert)
unknown's avatar
unknown committed
7101
{
unknown's avatar
unknown committed
7102
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
unknown's avatar
unknown committed
7103 7104
}

unknown's avatar
unknown committed
7105

unknown's avatar
unknown committed
7106
Comp_creator *comp_gt_creator(bool invert)
unknown's avatar
unknown committed
7107
{
unknown's avatar
unknown committed
7108
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
unknown's avatar
unknown committed
7109 7110
}

unknown's avatar
unknown committed
7111

unknown's avatar
unknown committed
7112
Comp_creator *comp_le_creator(bool invert)
unknown's avatar
unknown committed
7113
{
unknown's avatar
unknown committed
7114
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
unknown's avatar
unknown committed
7115 7116
}

unknown's avatar
unknown committed
7117

unknown's avatar
unknown committed
7118
Comp_creator *comp_lt_creator(bool invert)
unknown's avatar
unknown committed
7119
{
unknown's avatar
unknown committed
7120
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
unknown's avatar
unknown committed
7121 7122
}

unknown's avatar
unknown committed
7123

unknown's avatar
unknown committed
7124
Comp_creator *comp_ne_creator(bool invert)
unknown's avatar
unknown committed
7125
{
unknown's avatar
unknown committed
7126
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
unknown's avatar
unknown committed
7127
}
unknown's avatar
unknown committed
7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147


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

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

  Item_allany_subselect *it=
7155
    new Item_allany_subselect(left_expr, (*cmp)(all), select_lex, all);
unknown's avatar
unknown committed
7156
  if (all)
7157
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
unknown's avatar
unknown committed
7158

7159
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
unknown's avatar
unknown committed
7160
}
7161 7162


7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174
/*
  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
7175
bool mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
7176 7177
{
  List<create_field> fields;
7178 7179
  ALTER_INFO alter_info;
  alter_info.flags= ALTER_ADD_INDEX;
7180 7181 7182
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_create_index");
  bzero((char*) &create_info,sizeof(create_info));
unknown's avatar
unknown committed
7183
  create_info.db_type= 0;
7184
  create_info.default_table_charset= thd->variables.collation_database;
7185
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
7186
				&create_info, table_list,
7187
				fields, keys, 0, (ORDER*)0,
unknown's avatar
unknown committed
7188
				DUP_ERROR, 0, &alter_info, 1));
7189 7190 7191
}


unknown's avatar
unknown committed
7192
bool mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
7193 7194 7195 7196 7197 7198
{
  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
7199
  create_info.db_type= 0;
7200
  create_info.default_table_charset= thd->variables.collation_database;
7201 7202
  alter_info->clear();
  alter_info->flags= ALTER_DROP_INDEX;
7203
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
7204
				&create_info, table_list,
7205
				fields, keys, 0, (ORDER*)0,
unknown's avatar
unknown committed
7206
				DUP_ERROR, 0, alter_info, 1));
7207
}
unknown's avatar
merge  
unknown committed
7208 7209


7210 7211 7212 7213 7214
/*
  Multi update query pre-check

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

unknown's avatar
unknown committed
7218
  RETURN VALUE
unknown's avatar
unknown committed
7219 7220
    FALSE OK
    TRUE  Error
7221
*/
unknown's avatar
unknown committed
7222

unknown's avatar
unknown committed
7223
bool multi_update_precheck(THD *thd, TABLE_LIST *tables)
7224 7225 7226 7227 7228
{
  const char *msg= 0;
  TABLE_LIST *table;
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
7229
  DBUG_ENTER("multi_update_precheck");
7230 7231 7232

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
7233
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7234
    DBUG_RETURN(TRUE);
7235 7236 7237 7238 7239
  }
  /*
    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
7240
  for (table= tables; table; table= table->next_local)
7241
  {
7242 7243 7244
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
7245 7246
                           &table->grant.privilege, 0, 1,
                           test(table->schema_table)) ||
7247 7248
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
unknown's avatar
unknown committed
7249
             (check_access(thd, SELECT_ACL, table->db,
7250 7251
                           &table->grant.privilege, 0, 0,
                           test(table->schema_table)) ||
unknown's avatar
unknown committed
7252
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
unknown's avatar
unknown committed
7253
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7254

unknown's avatar
VIEW  
unknown committed
7255
    table->table_in_first_from_clause= 1;
7256
  }
unknown's avatar
unknown committed
7257 7258 7259
  /*
    Is there tables of subqueries?
  */
7260
  if (&lex->select_lex != lex->all_selects_list || lex->time_zone_tables_used)
7261
  {
7262
    DBUG_PRINT("info",("Checking sub query list"));
unknown's avatar
VIEW  
unknown committed
7263
    for (table= tables; table; table= table->next_global)
7264
    {
unknown's avatar
unknown committed
7265 7266 7267
      if (!my_tz_check_n_skip_implicit_tables(&table,
                                              lex->time_zone_tables_used) &&
          !table->table_in_first_from_clause)
7268 7269
      {
	if (check_access(thd, SELECT_ACL, table->db,
7270 7271
			 &table->grant.privilege, 0, 0,
                         test(table->schema_table)) ||
unknown's avatar
unknown committed
7272
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
unknown's avatar
unknown committed
7273
	  DBUG_RETURN(TRUE);
7274 7275 7276 7277 7278 7279
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
7280
  else if (select_lex->select_limit)
7281 7282 7283 7284
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
unknown's avatar
unknown committed
7285
    DBUG_RETURN(TRUE);
7286
  }
unknown's avatar
unknown committed
7287
  DBUG_RETURN(FALSE);
7288 7289 7290 7291 7292 7293 7294
}

/*
  Multi delete query pre-check

  SYNOPSIS
    multi_delete_precheck()
unknown's avatar
unknown committed
7295
    thd			Thread handler
unknown's avatar
VIEW  
unknown committed
7296
    tables		Global/local table list
7297

unknown's avatar
unknown committed
7298
  RETURN VALUE
unknown's avatar
unknown committed
7299 7300
    FALSE OK
    TRUE  error
7301
*/
unknown's avatar
unknown committed
7302

7303
bool multi_delete_precheck(THD *thd, TABLE_LIST *tables)
7304 7305 7306 7307
{
  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
7308
  DBUG_ENTER("multi_delete_precheck");
unknown's avatar
unknown committed
7309

7310 7311 7312 7313 7314
  /* 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
7315
    DBUG_RETURN(TRUE);
7316 7317
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
unknown's avatar
unknown committed
7318 7319
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
unknown's avatar
unknown committed
7320
    DBUG_RETURN(TRUE);
7321
  }
7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348
  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)
7349
  {
7350
    lex->table_count++;
7351 7352
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
unknown's avatar
VIEW  
unknown committed
7353
    for (walk= tables; walk; walk= walk->next_local)
7354
    {
unknown's avatar
unknown committed
7355 7356 7357
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
7358 7359 7360 7361
	break;
    }
    if (!walk)
    {
7362
      my_error(ER_UNKNOWN_TABLE, MYF(0),
7363
               target_tbl->table_name, "MULTI DELETE");
unknown's avatar
unknown committed
7364
      DBUG_RETURN(TRUE);
7365
    }
unknown's avatar
unknown committed
7366 7367 7368 7369 7370
    if (!walk->derived)
    {
      target_tbl->table_name= walk->table_name;
      target_tbl->table_name_length= walk->table_name_length;
    }
unknown's avatar
unknown committed
7371
    walk->updating= target_tbl->updating;
unknown's avatar
unknown committed
7372
    walk->lock_type= target_tbl->lock_type;
unknown's avatar
VIEW  
unknown committed
7373
    target_tbl->correspondent_table= walk;	// Remember corresponding table
7374
  }
unknown's avatar
unknown committed
7375
  DBUG_RETURN(FALSE);
7376 7377 7378
}


unknown's avatar
unknown committed
7379 7380 7381 7382 7383
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
unknown's avatar
unknown committed
7384 7385
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7386 7387

  RETURN VALUE
unknown's avatar
unknown committed
7388 7389
    FALSE OK
    TRUE  Error
unknown's avatar
unknown committed
7390
*/
unknown's avatar
unknown committed
7391

unknown's avatar
unknown committed
7392
bool update_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7393 7394 7395 7396
{
  DBUG_ENTER("update_precheck");
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
  {
unknown's avatar
unknown committed
7397
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7398
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7399
  }
unknown's avatar
unknown committed
7400 7401
  DBUG_RETURN(check_db_used(thd, tables) ||
	       check_one_table_access(thd, UPDATE_ACL, tables));
unknown's avatar
unknown committed
7402 7403 7404 7405 7406 7407 7408 7409
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
unknown's avatar
unknown committed
7410 7411
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7412 7413

  RETURN VALUE
unknown's avatar
unknown committed
7414 7415
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
7416
*/
unknown's avatar
unknown committed
7417

unknown's avatar
unknown committed
7418
bool delete_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7419 7420 7421
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
unknown's avatar
unknown committed
7422
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7423
  /* Set privilege for the WHERE clause */
unknown's avatar
unknown committed
7424
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
unknown's avatar
unknown committed
7425
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
7426 7427 7428 7429 7430 7431 7432 7433
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
unknown's avatar
unknown committed
7434 7435
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7436 7437

  RETURN VALUE
unknown's avatar
unknown committed
7438 7439
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
7440
*/
unknown's avatar
unknown committed
7441

unknown's avatar
merge  
unknown committed
7442
bool insert_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7443 7444 7445 7446
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

unknown's avatar
unknown committed
7447 7448 7449 7450
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
unknown's avatar
unknown committed
7451 7452 7453
  ulong privilege= (INSERT_ACL |
                    (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                    (lex->value_list.elements ? UPDATE_ACL : 0));
unknown's avatar
unknown committed
7454 7455

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

unknown's avatar
unknown committed
7458
  if (lex->update_list.elements != lex->value_list.elements)
unknown's avatar
unknown committed
7459
  {
unknown's avatar
unknown committed
7460
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7461
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7462
  }
unknown's avatar
unknown committed
7463
  DBUG_RETURN(FALSE);
7464
}
unknown's avatar
unknown committed
7465 7466 7467 7468 7469 7470 7471


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
unknown's avatar
unknown committed
7472 7473 7474
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
unknown's avatar
unknown committed
7475 7476

  RETURN VALUE
unknown's avatar
unknown committed
7477 7478
    FALSE   OK
    TRUE   Error
unknown's avatar
unknown committed
7479
*/
unknown's avatar
unknown committed
7480

unknown's avatar
unknown committed
7481 7482
bool create_table_precheck(THD *thd, TABLE_LIST *tables,
                           TABLE_LIST *create_table)
unknown's avatar
unknown committed
7483 7484
{
  LEX *lex= thd->lex;
7485 7486
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
unknown's avatar
merge  
unknown committed
7487
  bool error= TRUE;                                 // Error message is given
unknown's avatar
unknown committed
7488
  DBUG_ENTER("create_table_precheck");
7489 7490 7491

  want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
              CREATE_TMP_ACL : CREATE_ACL);
unknown's avatar
unknown committed
7492 7493
  lex->create_info.alias= create_table->alias;
  if (check_access(thd, want_priv, create_table->db,
7494 7495
		   &create_table->grant.privilege, 0, 0,
                   test(create_table->schema_table)) ||
unknown's avatar
unknown committed
7496 7497 7498
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
7499 7500
    goto err;
  if (grant_option && want_priv != CREATE_TMP_ACL &&
7501
      check_grant(thd, want_priv, create_table, 0, 1, 0))
7502 7503 7504 7505 7506 7507
    goto err;

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

7508 7509
#ifdef NOT_NECESSARY_TO_CHECK_CREATE_TABLE_EXIST_WHEN_PREPARING_STATEMENT
    /* This code throws an ill error for CREATE TABLE t1 SELECT * FROM t1 */
7510
    /*
unknown's avatar
unknown committed
7511 7512 7513
      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).
7514
    */
unknown's avatar
unknown committed
7515
    if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
7516
    {
unknown's avatar
unknown committed
7517 7518 7519 7520
      /*
        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
7521
          find_table_in_global_list(tables, create_table->db,
7522
                                    create_table->table_name))
unknown's avatar
unknown committed
7523
      {
7524
	error= FALSE;
unknown's avatar
unknown committed
7525 7526 7527
        goto err;
      }
    }
7528
#endif
7529 7530 7531
    if (tables && check_table_access(thd, SELECT_ACL, tables,0))
      goto err;
  }
unknown's avatar
merge  
unknown committed
7532
  error= FALSE;
7533 7534 7535

err:
  DBUG_RETURN(error);
unknown's avatar
unknown committed
7536
}
unknown's avatar
unknown committed
7537 7538 7539 7540 7541 7542 7543


/*
  negate given expression

  SYNOPSIS
    negate_expression()
7544
    thd  thread handler
unknown's avatar
unknown committed
7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572
    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);
}
7573

7574 7575
/*
  Set the specified definer to the default value, which is the current user in
7576
  the thread.
7577 7578 7579 7580 7581 7582 7583
 
  SYNOPSIS
    get_default_definer()
    thd       [in] thread handler
    definer   [out] definer
*/
 
7584
void get_default_definer(THD *thd, LEX_USER *definer)
7585 7586 7587 7588 7589 7590 7591 7592 7593 7594
{
  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);
}

7595

7596
/*
7597
  Create default definer for the specified THD.
7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615

  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;

7616
  get_default_definer(thd, definer);
7617 7618 7619 7620 7621

  return definer;
}


7622
/*
7623
  Create definer with the given user and host names.
7624 7625

  SYNOPSIS
7626 7627 7628 7629
    create_definer()
    thd         [in] thread handler
    user_name   [in] user name
    host_name   [in] host name
7630 7631

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

7637
LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name)
7638
{
7639 7640 7641 7642
  LEX_USER *definer;

  /* Create and initialize. */

unknown's avatar
unknown committed
7643
  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
7644 7645 7646 7647 7648 7649
    return 0;

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

  return definer;
7650
}