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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unknown's avatar
unknown committed
96
#ifndef EMBEDDED_LIBRARY
97
static bool do_command(THD *thd);
unknown's avatar
unknown committed
98
#endif // EMBEDDED_LIBRARY
99

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

unknown's avatar
unknown committed
119 120 121 122 123
static void unlock_locked_tables(THD *thd)
{
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
124
    thd->locked_tables=0;			// Will be automatically closed
unknown's avatar
unknown committed
125 126 127 128
    close_thread_tables(thd);			// Free tables
  }
}

129

unknown's avatar
unknown committed
130
static bool end_active_trans(THD *thd)
131
{
unknown's avatar
unknown committed
132
  int error=0;
133
  DBUG_ENTER("end_active_trans");
134
  if (unlikely(thd->in_sub_stmt))
135 136 137 138
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
139 140 141 142 143 144
  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
145
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
unknown's avatar
unknown committed
146
		      OPTION_TABLE_LOCK))
147
  {
148 149 150 151
    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;
152
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
153
    if (ha_commit(thd))
unknown's avatar
unknown committed
154
      error=1;
155
    thd->options&= ~(ulong) OPTION_BEGIN;
unknown's avatar
unknown committed
156
    thd->transaction.all.modified_non_trans_table= FALSE;
157
  }
158
  DBUG_RETURN(error);
159 160
}

unknown's avatar
unknown committed
161 162 163
static bool begin_trans(THD *thd)
{
  int error=0;
164
  if (unlikely(thd->in_sub_stmt))
165 166 167 168
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    return 1;
  }
unknown's avatar
unknown committed
169 170 171 172 173 174 175 176 177 178
  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
  {
179
    LEX *lex= thd->lex;
unknown's avatar
unknown committed
180
    thd->transaction.all.modified_non_trans_table= FALSE;
181
    thd->options|= (ulong) OPTION_BEGIN;
unknown's avatar
unknown committed
182 183
    thd->server_status|= SERVER_STATUS_IN_TRANS;
    if (lex->start_transaction_opt & MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT)
unknown's avatar
unknown committed
184
      error= ha_start_consistent_snapshot(thd);
unknown's avatar
unknown committed
185 186 187
  }
  return error;
}
188

unknown's avatar
unknown committed
189
#ifdef HAVE_REPLICATION
190 191 192
/*
  Returns true if all tables should be ignored
*/
193 194
inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables)
{
unknown's avatar
unknown committed
195
  return table_rules_on && tables && !tables_ok(thd,tables);
196
}
unknown's avatar
unknown committed
197
#endif
198 199


200 201 202 203 204 205 206 207 208 209 210 211
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;
}

212
#ifndef NO_EMBEDDED_ACCESS_CHECKS
213 214
static HASH hash_user_connections;

unknown's avatar
unknown committed
215 216
static int get_or_create_user_conn(THD *thd, const char *user,
				   const char *host,
unknown's avatar
unknown committed
217
				   USER_RESOURCES *mqh)
218
{
219
  int return_val= 0;
unknown's avatar
unknown committed
220
  uint temp_len, user_len;
221
  char temp_user[USER_HOST_BUFF_SIZE];
222 223 224 225 226
  struct  user_conn *uc;

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

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

263
}
264
#endif /* !NO_EMBEDDED_ACCESS_CHECKS */
265 266 267


/*
268 269
  Check if user exist and password supplied is correct. 

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

281
    Note, that host, user and passwd may point to communication buffer.
282
    Current implementation does not depend on that, but future changes
283 284 285
    should be done with this in mind; 'thd' is INOUT, all other params
    are 'IN'.

286
  RETURN VALUE
287 288
    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
289 290
   -1  access denied or handshake error; error is sent to client;
   >0  error, not sent to client
unknown's avatar
unknown committed
291 292
*/

unknown's avatar
unknown committed
293 294 295
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
296
{
297
  DBUG_ENTER("check_user");
298 299
  LEX_STRING db_str= { (char *) db, db ? strlen(db) : 0 };

unknown's avatar
unknown committed
300
#ifdef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
301
  thd->main_security_ctx.master_access= GLOBAL_ACLS;       // Full rights
302
  /* Change database if necessary */
303 304
  if (db && db[0])
  {
305 306 307 308
    /*
      thd->db is saved in caller and needs to be freed by caller if this
      function returns 0
    */
unknown's avatar
unknown committed
309
    thd->reset_db(NULL, 0);
310
    if (mysql_change_db(thd, &db_str, FALSE))
311
    {
312 313
      /* Send the error to the client */
      net_send_error(thd);
314
      DBUG_RETURN(-1);
unknown's avatar
unknown committed
315
    }
316
  }
317
  send_ok(thd);
318
  DBUG_RETURN(0);
unknown's avatar
unknown committed
319 320
#else

321 322 323 324 325
  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);
  
326
  /*
327 328
    If the server is running in secure auth mode, short scrambles are 
    forbidden.
329
  */
330
  if (opt_secure_auth_local && passwd_len == SCRAMBLE_LENGTH_323)
unknown's avatar
unknown committed
331
  {
332
    net_printf_error(thd, ER_NOT_SUPPORTED_AUTH_MODE);
333 334
    mysql_log.write(thd, COM_CONNECT, ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
335
  }
unknown's avatar
unknown committed
336 337 338 339
  if (passwd_len != 0 &&
      passwd_len != SCRAMBLE_LENGTH &&
      passwd_len != SCRAMBLE_LENGTH_323)
    DBUG_RETURN(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
340

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

349
  USER_RESOURCES ur;
350
  int res= acl_getroot(thd, &ur, passwd, passwd_len);
unknown's avatar
unknown committed
351
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
352
  if (res == -1)
unknown's avatar
unknown committed
353
  {
unknown's avatar
unknown committed
354 355 356 357 358 359
    /*
      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.
    */
360
    NET *net= &thd->net;
361
    if (opt_secure_auth_local)
362
    {
363
      net_printf_error(thd, ER_SERVER_IS_IN_SECURE_AUTH_MODE,
364 365
                       thd->main_security_ctx.user,
                       thd->main_security_ctx.host_or_ip);
366
      mysql_log.write(thd, COM_CONNECT, ER(ER_SERVER_IS_IN_SECURE_AUTH_MODE),
367 368
                      thd->main_security_ctx.user,
                      thd->main_security_ctx.host_or_ip);
369 370
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
371
    /* We have to read very specific packet size */
372
    if (send_old_password_request(thd) ||
unknown's avatar
unknown committed
373
        my_net_read(net) != SCRAMBLE_LENGTH_323 + 1)
374
    {
unknown's avatar
unknown committed
375 376 377 378 379
      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 */
380
    res= acl_getroot(thd, &ur, (char *) net->read_pos, SCRAMBLE_LENGTH_323);
unknown's avatar
unknown committed
381
  }
unknown's avatar
unknown committed
382
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
383 384
  /* here res is always >= 0 */
  if (res == 0)
unknown's avatar
unknown committed
385
  {
386 387
    if (!(thd->main_security_ctx.master_access &
          NO_ACCESS)) // authentication is OK
388
    {
unknown's avatar
unknown committed
389
      DBUG_PRINT("info",
unknown's avatar
unknown committed
390
                 ("Capabilities: %lu  packet_length: %ld  Host: '%s'  "
unknown's avatar
unknown committed
391
                  "Login user: '%s' Priv_user: '%s'  Using password: %s "
unknown's avatar
unknown committed
392
                  "Access: %lu  db: '%s'",
393 394 395 396 397
                  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
398
                  passwd_len ? "yes": "no",
399 400
                  thd->main_security_ctx.master_access,
                  (thd->db ? thd->db : "*none*")));
unknown's avatar
unknown committed
401 402

      if (check_count)
403
      {
unknown's avatar
unknown committed
404
        VOID(pthread_mutex_lock(&LOCK_thread_count));
unknown's avatar
unknown committed
405
        bool count_ok= thread_count <= max_connections + delayed_insert_threads
406
                       || (thd->main_security_ctx.master_access & SUPER_ACL);
unknown's avatar
unknown committed
407 408
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
        if (!count_ok)
unknown's avatar
unknown committed
409
        {                                         // too many connections
410
          net_send_error(thd, ER_CON_COUNT_ERROR);
unknown's avatar
unknown committed
411 412
          DBUG_RETURN(-1);
        }
413
      }
unknown's avatar
unknown committed
414

unknown's avatar
unknown committed
415
      /* Why logging is performed before all checks've passed? */
416
      mysql_log.write(thd, command,
417 418
                      (thd->main_security_ctx.priv_user ==
                       thd->main_security_ctx.user ?
unknown's avatar
unknown committed
419 420
                       (char*) "%s@%s on %s" :
                       (char*) "%s@%s as anonymous on %s"),
421 422
                      thd->main_security_ctx.user,
                      thd->main_security_ctx.host_or_ip,
unknown's avatar
unknown committed
423 424
                      db ? db : (char*) "");

425
      /*
426 427 428
        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.
429
      */
430
      thd->main_security_ctx.db_access=0;
unknown's avatar
unknown committed
431 432

      /* Don't allow user to connect if he has done too many queries */
433
      if ((ur.questions || ur.updates || ur.conn_per_hour || ur.user_conn ||
unknown's avatar
unknown committed
434
	   max_user_connections) &&
435
	  get_or_create_user_conn(thd,
436 437 438 439
            (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),
440
            &ur))
unknown's avatar
unknown committed
441 442
	DBUG_RETURN(-1);
      if (thd->user_connect &&
443 444
	  (thd->user_connect->user_resources.conn_per_hour ||
	   thd->user_connect->user_resources.user_conn ||
unknown's avatar
unknown committed
445 446 447
	   max_user_connections) &&
	  check_for_max_user_connections(thd, thd->user_connect))
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
448

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

unknown's avatar
unknown committed
485
/*
unknown's avatar
unknown committed
486 487
  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
488 489
*/

490 491
extern "C" byte *get_key_conn(user_conn *buff, uint *length,
			      my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
492 493 494 495 496
{
  *length=buff->len;
  return (byte*) buff->user;
}

497
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
498 499 500 501
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
502
void init_max_user_conn(void)
unknown's avatar
unknown committed
503
{
504
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
505 506
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
507
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
508
		   0);
509
#endif
unknown's avatar
unknown committed
510 511 512
}


unknown's avatar
unknown committed
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
/*
  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
530 531
#ifndef NO_EMBEDDED_ACCESS_CHECKS

532
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
533
{
534
  int error=0;
535
  DBUG_ENTER("check_for_max_user_connections");
unknown's avatar
unknown committed
536

537
  (void) pthread_mutex_lock(&LOCK_user_conn);
538
  if (max_user_connections && !uc->user_resources.user_conn &&
unknown's avatar
unknown committed
539
      max_user_connections < (uint) uc->connections)
unknown's avatar
unknown committed
540
  {
541
    net_printf_error(thd, ER_TOO_MANY_USER_CONNECTIONS, uc->user);
542 543
    error=1;
    goto end;
unknown's avatar
unknown committed
544
  }
545
  time_out_user_resource_limits(thd, uc);
546 547 548 549 550 551 552 553 554 555 556
  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)
557
  {
558
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user,
unknown's avatar
unknown committed
559
                     "max_connections_per_hour",
560
                     (long) uc->user_resources.conn_per_hour);
561 562 563
    error=1;
    goto end;
  }
564
  uc->conn_per_hour++;
unknown's avatar
unknown committed
565 566

  end:
567 568
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
569
  (void) pthread_mutex_unlock(&LOCK_user_conn);
570
  DBUG_RETURN(error);
unknown's avatar
unknown committed
571 572
}

unknown's avatar
unknown committed
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
/*
  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.
*/

591
static void decrease_user_connections(USER_CONN *uc)
unknown's avatar
unknown committed
592
{
593
  DBUG_ENTER("decrease_user_connections");
594 595 596
  (void) pthread_mutex_lock(&LOCK_user_conn);
  DBUG_ASSERT(uc->connections);
  if (!--uc->connections && !mqh_used)
unknown's avatar
unknown committed
597 598
  {
    /* Last connection for user; Delete it */
unknown's avatar
unknown committed
599
    (void) hash_delete(&hash_user_connections,(byte*) uc);
unknown's avatar
unknown committed
600
  }
601
  (void) pthread_mutex_unlock(&LOCK_user_conn);
602
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
603 604
}

605 606
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

607

unknown's avatar
unknown committed
608 609
void free_max_user_conn(void)
{
610
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
611
  hash_free(&hash_user_connections);
612
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
613 614
}

unknown's avatar
unknown committed
615

616

617 618 619
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
unknown's avatar
unknown committed
620 621 622

  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
623 624 625 626 627 628

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

unknown's avatar
unknown committed
631
char  uc_update_queries[SQLCOM_END+1];
632 633 634

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

637 638 639
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
640 641 642 643 644 645
  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;
646 647 648 649 650
  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;
651 652
  uc_update_queries[SQLCOM_REPLACE]=2;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=2;
653 654 655 656
  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
657 658
  uc_update_queries[SQLCOM_CREATE_VIEW]=1;
  uc_update_queries[SQLCOM_DROP_VIEW]=1;
659 660
}

unknown's avatar
unknown committed
661 662
bool is_update_query(enum enum_sql_command command)
{
unknown's avatar
unknown committed
663
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
664
  return uc_update_queries[command] != 0;
unknown's avatar
unknown committed
665
}
666

unknown's avatar
unknown committed
667
/*
668 669
  Reset per-hour user resource limits when it has been more than
  an hour since they were last checked
unknown's avatar
unknown committed
670

671 672 673 674
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
unknown's avatar
unknown committed
675

676 677 678 679
  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.
*/
680

681 682
#ifndef NO_EMBEDDED_ACCESS_CHECKS

683
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
684
{
unknown's avatar
unknown committed
685
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
686
  DBUG_ENTER("time_out_user_resource_limits");
unknown's avatar
unknown committed
687

unknown's avatar
unknown committed
688
  /* If more than a hour since last check, reset resource checking */
689 690 691 692 693 694 695
  if (check_time  - uc->intime >= 3600)
  {
    uc->questions=1;
    uc->updates=0;
    uc->conn_per_hour=0;
    uc->intime=check_time;
  }
696 697 698 699 700 701 702 703 704 705 706

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

742 743
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

unknown's avatar
unknown committed
744

unknown's avatar
unknown committed
745
static void reset_mqh(LEX_USER *lu, bool get_them= 0)
746
{
unknown's avatar
unknown committed
747
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
748
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
749
  if (lu)  // for GRANT
750
  {
751
    USER_CONN *uc;
752
    uint temp_len=lu->user.length+lu->host.length+2;
753
    char temp_user[USER_HOST_BUFF_SIZE];
754

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

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


unknown's avatar
unknown committed
816
/*
817
    Perform handshake, authorize client and update thd ACL variables.
818
  SYNOPSIS
819
    check_connection()
820
    thd  thread handle
821 822

  RETURN
823
     0  success, OK is sent to user, thd is updated.
824 825
    -1  error, which is sent to user
   > 0  error code (not sent to user)
unknown's avatar
unknown committed
826 827
*/

unknown's avatar
unknown committed
828 829
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
unknown's avatar
unknown committed
830
{
831
  uint connect_errors= 0;
unknown's avatar
unknown committed
832
  NET *net= &thd->net;
unknown's avatar
unknown committed
833 834
  ulong pkt_len= 0;
  char *end;
835

836 837
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));
unknown's avatar
unknown committed
838
#ifdef SIGNAL_WITH_VIO_CLOSE
839
  thd->set_active_vio(net->vio);
unknown's avatar
unknown committed
840
#endif
841

842
  if (!thd->main_security_ctx.host)         // If TCP/IP connection
unknown's avatar
unknown committed
843
  {
844
    char ip[30];
845

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

891 892 893 894 895
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
896 897
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
898
      client_flags |= CLIENT_SSL;       /* Wow, SSL is available! */
unknown's avatar
unknown committed
899
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
900

901 902 903 904 905 906 907 908 909 910 911
    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
912
      tail: that's why first part of the scramble is placed here, and second
913 914
      part at the end of packet.
    */
915
    end= strmake(end, thd->scramble, SCRAMBLE_LENGTH_323) + 1;
916 917 918
   
    int2store(end, client_flags);
    /* write server characteristics: up to 16 bytes allowed */
919
    end[2]=(char) default_charset_info->number;
920 921 922 923 924 925 926 927 928
    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
929
			  (uint) (end-buff)) ||
930
	(pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
931 932 933 934 935 936 937 938 939 940 941
	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
942
  if (thd->packet.alloc(thd->variables.net_buffer_length))
unknown's avatar
unknown committed
943 944 945
    return(ER_OUT_OF_RESOURCES);

  thd->client_capabilities=uint2korr(net->read_pos);
946 947 948 949
  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
950
    DBUG_PRINT("info", ("client_character_set: %d", (uint) net->read_pos[8]));
951
    thd_init_client_charset(thd, (uint) net->read_pos[8]);
unknown's avatar
unknown committed
952
    thd->update_charset();
953
    end= (char*) net->read_pos+32;
954 955 956 957 958 959 960
  }
  else
  {
    thd->max_client_packet_length= uint3korr(net->read_pos+2);
    end= (char*) net->read_pos+5;
  }

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

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

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
999
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
1000
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
1001 1002
      opt_using_transactions)
    net->return_status= &thd->server_status;
unknown's avatar
unknown committed
1003

1004 1005
  char *user= end;
  char *passwd= strend(user)+1;
1006
  uint user_len= passwd - user - 1;
unknown's avatar
unknown committed
1007
  char *db= passwd;
unknown's avatar
unknown committed
1008 1009
  char db_buff[NAME_LEN + 1];           // buffer to store db in utf8
  char user_buff[USERNAME_LENGTH + 1];	// buffer to store user in utf8
1010 1011 1012
  uint dummy_errors;

  /*
unknown's avatar
unknown committed
1013 1014 1015
    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'.
1016 1017 1018

    Cast *passwd to an unsigned char, so that it doesn't extend the sign for
    *passwd > 127 and become 2**32-127 after casting to uint.
unknown's avatar
unknown committed
1019
  */
1020
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
1021
    (uchar)(*passwd++) : strlen(passwd);
unknown's avatar
unknown committed
1022 1023
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
unknown's avatar
unknown committed
1024 1025
  uint db_len= db ? strlen(db) : 0;

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

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

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

1047 1048 1049 1050 1051 1052 1053 1054
  /* 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;
  }

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

1062

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

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


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

  pthread_detach_this_thread();

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

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

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

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

1149
    /* Use "connect_timeout" value during connection phase */
1150 1151
    my_net_set_read_timeout(net, connect_timeout);
    my_net_set_write_timeout(net, connect_timeout);
1152

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

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

1177
    if (sys_init_connect.value_length && !(sctx->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1178
    {
1179 1180
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
1181
      {
unknown's avatar
unknown committed
1182
	thd->killed= THD::KILL_CONNECTION;
1183 1184 1185 1186 1187 1188
        sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
                          thd->thread_id,(thd->db ? thd->db : "unconnected"),
                          sctx->user ? sctx->user : "unauthenticated",
                          sctx->host_or_ip, "init_connect command failed");
        sql_print_warning("%s", net->last_error);
      }
1189 1190
      thd->proc_info=0;
      thd->init_for_queries();
unknown's avatar
unknown committed
1191 1192
    }

1193
    /* Connect completed, set read/write timeouts back to tdefault */
1194 1195
    my_net_set_read_timeout(net, thd->variables.net_read_timeout);
    my_net_set_write_timeout(net, thd->variables.net_write_timeout);
1196

1197 1198
    while (!net->error && net->vio != 0 &&
           !(thd->killed == THD::KILL_CONNECTION))
unknown's avatar
unknown committed
1199
    {
1200
      net->no_send_error= 0;
unknown's avatar
unknown committed
1201 1202 1203
      if (do_command(thd))
	break;
    }
1204 1205
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
1206 1207 1208 1209 1210 1211 1212

    if (thd->killed ||
        net->vio && net->error && net->report_error)
    {
      statistic_increment(aborted_threads, &LOCK_status);
    }

unknown's avatar
unknown committed
1213
    if (net->error && net->vio != 0 && net->report_error)
unknown's avatar
unknown committed
1214
    {
1215
      if (!thd->killed && thd->variables.log_warnings > 1)
1216 1217
      {
        sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
unknown's avatar
unknown committed
1218
                          thd->thread_id,(thd->db ? thd->db : "unconnected"),
1219 1220
                          sctx->user ? sctx->user : "unauthenticated",
                          sctx->host_or_ip,
unknown's avatar
unknown committed
1221 1222
                          (net->last_errno ? ER(net->last_errno) :
                           ER(ER_UNKNOWN_ERROR)));
1223 1224
      }

1225
      net_send_error(thd, net->last_errno, NullS);
unknown's avatar
unknown committed
1226
    }
1227

unknown's avatar
unknown committed
1228
end_thread:
1229
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1230 1231 1232 1233 1234 1235
    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;
1236
    thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1237 1238 1239 1240 1241
  } 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
1242 1243
#endif /* EMBEDDED_LIBRARY */

1244 1245 1246 1247
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
1248

1249
pthread_handler_t handle_bootstrap(void *arg)
unknown's avatar
unknown committed
1250
{
1251 1252 1253
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
1254
  const char* found_semicolon= NULL;
unknown's avatar
unknown committed
1255

1256
  /* The following must be called before DBUG_ENTER */
1257
  thd->thread_stack= (char*) &thd;
1258
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
1259
  {
unknown's avatar
unknown committed
1260
#ifndef EMBEDDED_LIBRARY
1261
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
1262
#endif
1263
    thd->fatal_error();
1264
    goto end;
unknown's avatar
unknown committed
1265
  }
1266 1267
  DBUG_ENTER("handle_bootstrap");

unknown's avatar
unknown committed
1268
#ifndef EMBEDDED_LIBRARY
1269 1270
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1271
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1272
  sigset_t set;
1273 1274
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
1275
#endif
unknown's avatar
unknown committed
1276
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1277

1278
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1279 1280 1281 1282
    thd->options |= OPTION_BIG_SELECTS;

  thd->proc_info=0;
  thd->version=refresh_version;
1283 1284
  thd->security_ctx->priv_user=
    thd->security_ctx->user= (char*) my_strdup("boot", MYF(MY_WME));
1285 1286 1287 1288 1289 1290
  /*
    Make the "client" handle multiple results. This is necessary
    to enable stored procedures with SELECTs and Dynamic SQL
    in init-file.
  */
  thd->client_capabilities|= CLIENT_MULTI_RESULTS;
unknown's avatar
unknown committed
1291

1292
  buff= (char*) thd->net.buff;
1293
  thd->init_for_queries();
unknown's avatar
unknown committed
1294 1295
  while (fgets(buff, thd->net.max_packet, file))
  {
unknown's avatar
unknown committed
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
   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
1316
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1317
           buff[length-1] == ';'))
unknown's avatar
unknown committed
1318 1319
      length--;
    buff[length]=0;
1320
    thd->query_length=length;
unknown's avatar
unknown committed
1321 1322
    thd->query= thd->memdup_w_gap(buff, length+1, 
				  thd->db_length+1+QUERY_CACHE_FLAGS_SIZE);
unknown's avatar
unknown committed
1323
    thd->query[length] = '\0';
1324
    DBUG_PRINT("query",("%-.4096s",thd->query));
1325 1326 1327 1328
    /*
      We don't need to obtain LOCK_thread_count here because in bootstrap
      mode we have only one thread.
    */
1329
    thd->query_id=next_query_id();
1330
    thd->set_time();
1331
    mysql_parse(thd, thd->query, length, & found_semicolon);
unknown's avatar
unknown committed
1332
    close_thread_tables(thd);			// Free tables
1333

1334
    if (thd->is_fatal_error)
1335
      break;
1336 1337 1338 1339 1340 1341 1342 1343 1344

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

unknown's avatar
unknown committed
1345
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1346
#ifdef USING_TRANSACTIONS
1347
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
1348
#endif
unknown's avatar
unknown committed
1349
  }
1350 1351

end:
1352
  /* Remember the exit code of bootstrap */
1353 1354 1355 1356 1357 1358
  bootstrap_error= thd->is_fatal_error;

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

unknown's avatar
unknown committed
1359
#ifndef EMBEDDED_LIBRARY
1360 1361 1362
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1363
  (void) pthread_cond_broadcast(&COND_thread_count);
1364 1365
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1366
#endif
1367
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1368 1369 1370
}


1371 1372 1373 1374
    /* This works because items are allocated with sql_alloc() */

void cleanup_items(Item *item)
{
unknown's avatar
unknown committed
1375
  DBUG_ENTER("cleanup_items");  
1376 1377
  for (; item ; item=item->next)
    item->cleanup();
unknown's avatar
unknown committed
1378
  DBUG_VOID_RETURN;
1379 1380
}

unknown's avatar
unknown committed
1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
/*
  Handle COM_TABLE_DUMP command

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

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

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

static
int mysql_table_dump(THD* thd, char* db, char* tbl_name)
unknown's avatar
unknown committed
1401 1402 1403 1404 1405 1406
{
  TABLE* table;
  TABLE_LIST* table_list;
  int error = 0;
  DBUG_ENTER("mysql_table_dump");
  db = (db && db[0]) ? db : thd->db;
1407
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1408
    DBUG_RETURN(1); // out of memory
unknown's avatar
VIEW  
unknown committed
1409
  table_list->db= db;
1410
  table_list->table_name= table_list->alias= tbl_name;
unknown's avatar
VIEW  
unknown committed
1411 1412
  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
1413

1414 1415
  if (!db || check_db_name(db))
  {
1416
    my_error(ER_WRONG_DB_NAME ,MYF(0), db ? db : "NULL");
1417 1418
    goto err;
  }
1419
  if (lower_case_table_names)
1420
    my_casedn_str(files_charset_info, tbl_name);
1421
  remove_escape(table_list->table_name);
1422 1423 1424 1425

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

unknown's avatar
unknown committed
1426
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1427 1428
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1429
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1430
  thd->query = tbl_name;
unknown's avatar
unknown committed
1431
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1432
  {
1433
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1434 1435
    goto err;
  }
unknown's avatar
unknown committed
1436
  net_flush(&thd->net);
unknown's avatar
unknown committed
1437
  if ((error= table->file->dump(thd,-1)))
1438
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1439

unknown's avatar
unknown committed
1440
err:
unknown's avatar
unknown committed
1441
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1442 1443
}

unknown's avatar
unknown committed
1444 1445 1446 1447
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1448
    end_trans()
unknown's avatar
unknown committed
1449 1450 1451 1452 1453 1454 1455
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1456
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
unknown's avatar
unknown committed
1457 1458 1459
{
  bool do_release= 0;
  int res= 0;
1460
  DBUG_ENTER("end_trans");
unknown's avatar
unknown committed
1461

1462
  if (unlikely(thd->in_sub_stmt))
1463 1464 1465 1466
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
1467 1468 1469 1470 1471 1472
  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
1473 1474 1475 1476 1477 1478 1479 1480
  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;
1481
    res= ha_commit(thd);
1482
    thd->options&= ~(ulong) OPTION_BEGIN;
unknown's avatar
unknown committed
1483
    thd->transaction.all.modified_non_trans_table= FALSE;
unknown's avatar
unknown committed
1484 1485
    break;
  case COMMIT_RELEASE:
unknown's avatar
unknown committed
1486
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1487 1488 1489 1490 1491 1492
  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
1493
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1494 1495 1496 1497
  case ROLLBACK:
  case ROLLBACK_AND_CHAIN:
  {
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
unknown's avatar
unknown committed
1498
    if (ha_rollback(thd))
unknown's avatar
unknown committed
1499
      res= -1;
1500
    thd->options&= ~(ulong) OPTION_BEGIN;
unknown's avatar
unknown committed
1501
    thd->transaction.all.modified_non_trans_table= FALSE;
unknown's avatar
unknown committed
1502 1503 1504 1505 1506 1507 1508 1509 1510
    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
1511

unknown's avatar
unknown committed
1512 1513 1514
  if (res < 0)
    my_error(thd->killed_errno(), MYF(0));
  else if ((res == 0) && do_release)
unknown's avatar
unknown committed
1515 1516
    thd->killed= THD::KILL_CONNECTION;

unknown's avatar
unknown committed
1517 1518
  DBUG_RETURN(res);
}
unknown's avatar
unknown committed
1519

1520
#ifndef EMBEDDED_LIBRARY
1521 1522

/*
1523
  Read one command from connection and execute it (query or simple command).
1524 1525 1526 1527 1528 1529 1530 1531
  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
1532
static bool do_command(THD *thd)
unknown's avatar
unknown committed
1533
{
1534
  char *packet= 0;
unknown's avatar
unknown committed
1535
  ulong packet_length;
1536
  NET *net= &thd->net;
unknown's avatar
unknown committed
1537 1538 1539
  enum enum_server_command command;
  DBUG_ENTER("do_command");

unknown's avatar
unknown committed
1540 1541 1542 1543
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1544
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1545

1546 1547 1548 1549 1550 1551
  /*
    This thread will do a blocking read from the client which
    will be interrupted when the next command is received from
    the client, the connection is closed or "net_wait_timeout"
    number of seconds has passed
  */
1552
  my_net_set_read_timeout(net, thd->variables.net_wait_timeout);
1553

unknown's avatar
unknown committed
1554
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1555 1556 1557 1558

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1559 1560 1561
    DBUG_PRINT("info",("Got error %d reading command from socket %s",
		       net->error,
		       vio_description(net->vio)));
1562

1563
    /* Check if we can continue without closing the connection */
1564

1565 1566
    if (net->error != 3)
      DBUG_RETURN(TRUE);			// We have to close it.
1567

1568
    net_send_error(thd, net->last_errno, NullS);
1569
    net->error= 0;
1570
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1571 1572 1573 1574 1575
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1576 1577
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
1578 1579 1580
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
1581
  }
1582 1583

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

1586 1587 1588 1589 1590 1591 1592 1593 1594
  /*
    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
1595
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1596
}
1597
#endif  /* EMBEDDED_LIBRARY */
1598

1599

1600 1601
/*
   Perform one connection-level (COM_XXXX) command.
1602

1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
  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
*/
1616

1617 1618 1619 1620
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1621
  bool error= 0;
1622 1623
  DBUG_ENTER("dispatch_command");

1624
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
1625
  {
1626
    thd->killed= THD::NOT_KILLED;
1627 1628
    thd->mysys_var->abort= 0;
  }
1629

1630
  thd->command=command;
unknown's avatar
unknown committed
1631
  /*
1632 1633
    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
1634
  */
1635
  thd->enable_slow_log= TRUE;
1636
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
unknown's avatar
unknown committed
1637
  thd->set_time();
unknown's avatar
unknown committed
1638
  VOID(pthread_mutex_lock(&LOCK_thread_count));
1639
  thd->query_id= global_query_id;
unknown's avatar
unknown committed
1640
  if (command != COM_STATISTICS && command != COM_PING)
1641
    next_query_id();
unknown's avatar
unknown committed
1642
  thread_running++;
1643
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1644
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1645

1646 1647
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1648
  switch (command) {
unknown's avatar
unknown committed
1649
  case COM_INIT_DB:
unknown's avatar
unknown committed
1650 1651
  {
    LEX_STRING tmp;
1652 1653
    statistic_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB],
			&LOCK_status);
unknown's avatar
unknown committed
1654 1655
    thd->convert_string(&tmp, system_charset_info,
			packet, strlen(packet), thd->charset());
1656
    if (!mysql_change_db(thd, &tmp, FALSE))
1657
    {
unknown's avatar
unknown committed
1658
      mysql_log.write(thd,command,"%s",thd->db);
1659 1660
      send_ok(thd);
    }
unknown's avatar
unknown committed
1661 1662
    break;
  }
unknown's avatar
unknown committed
1663
#ifdef HAVE_REPLICATION
1664 1665
  case COM_REGISTER_SLAVE:
  {
1666
    if (!register_slave(thd, (uchar*)packet, packet_length))
1667
      send_ok(thd);
1668 1669
    break;
  }
1670
#endif
unknown's avatar
unknown committed
1671
  case COM_TABLE_DUMP:
1672 1673 1674
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
unknown's avatar
unknown committed
1675
    if (db_len >= packet_length || db_len > NAME_LEN)
unknown's avatar
unknown committed
1676
    {
unknown's avatar
unknown committed
1677
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
1678 1679
      break;
    }
1680
    uint tbl_len= *(uchar*) (packet + db_len + 1);
unknown's avatar
unknown committed
1681 1682
    if (db_len+tbl_len+2 > packet_length || tbl_len > NAME_LEN)
    {
unknown's avatar
unknown committed
1683
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
1684 1685
      break;
    }
1686

1687
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1688
    thd->enable_slow_log= opt_log_slow_admin_statements;
1689
    db= thd->alloc(db_len + tbl_len + 2);
1690 1691 1692 1693 1694
    if (!db)
    {
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
      break;
    }
1695 1696
    tbl_name= strmake(db, packet + 1, db_len)+1;
    strmake(tbl_name, packet + db_len + 2, tbl_len);
unknown's avatar
unknown committed
1697
    mysql_table_dump(thd, db, tbl_name);
1698 1699
    break;
  }
unknown's avatar
unknown committed
1700 1701
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1702
    thd->change_user();
1703
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1704

1705
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1706
    char *user= (char*) packet;
unknown's avatar
unknown committed
1707
    char *passwd= strend(user)+1;
1708
    /*
unknown's avatar
unknown committed
1709 1710 1711
      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).
1712 1713 1714

      Cast *passwd to an unsigned char, so that it doesn't extend the sign
      for *passwd > 127 and become 2**32-127 after casting to uint.
unknown's avatar
unknown committed
1715
    */
unknown's avatar
unknown committed
1716
    char db_buff[NAME_LEN+1];               // buffer to store db in utf8
unknown's avatar
unknown committed
1717
    char *db= passwd;
1718
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
1719
      (uchar)(*passwd++) : strlen(passwd);
unknown's avatar
unknown committed
1720
    db+= passwd_len + 1;
1721
#ifndef EMBEDDED_LIBRARY
1722
    /* Small check for incoming packet */
unknown's avatar
unknown committed
1723
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1724
    {
unknown's avatar
unknown committed
1725
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1726 1727
      break;
    }
1728
#endif
1729
    /* Convert database name to utf8 */
1730
    uint dummy_errors;
1731 1732
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1733
                             thd->charset(), &dummy_errors)]= 0;
1734
    db= db_buff;
unknown's avatar
unknown committed
1735

1736 1737 1738
    /* Save user and privileges */
    uint save_db_length= thd->db_length;
    char *save_db= thd->db;
1739
    Security_context save_security_ctx= *thd->security_ctx;
unknown's avatar
unknown committed
1740
    USER_CONN *save_user_connect= thd->user_connect;
1741 1742

    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
1743
    {
1744
      thd->security_ctx->user= save_security_ctx.user;
unknown's avatar
unknown committed
1745
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1746 1747
      break;
    }
unknown's avatar
unknown committed
1748

unknown's avatar
unknown committed
1749 1750
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1751
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1752

1753 1754
    if (res)
    {
1755
      /* authentication failure, we shall restore old user */
1756
      if (res > 0)
unknown's avatar
unknown committed
1757
        my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1758 1759
      x_free(thd->security_ctx->user);
      *thd->security_ctx= save_security_ctx;
unknown's avatar
unknown committed
1760
      thd->user_connect= save_user_connect;
1761 1762 1763 1764 1765
      thd->db= save_db;
      thd->db_length= save_db_length;
    }
    else
    {
1766
#ifndef NO_EMBEDDED_ACCESS_CHECKS
1767
      /* we've authenticated new user */
unknown's avatar
unknown committed
1768 1769
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1770
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
1771
      x_free((gptr) save_db);
1772
      x_free((gptr)  save_security_ctx.user);
1773
    }
unknown's avatar
unknown committed
1774 1775
    break;
  }
1776
  case COM_STMT_EXECUTE:
unknown's avatar
unknown committed
1777
  {
1778
    mysql_stmt_execute(thd, packet, packet_length);
unknown's avatar
unknown committed
1779 1780
    break;
  }
1781
  case COM_STMT_FETCH:
1782 1783 1784 1785
  {
    mysql_stmt_fetch(thd, packet, packet_length);
    break;
  }
1786
  case COM_STMT_SEND_LONG_DATA:
unknown's avatar
unknown committed
1787
  {
1788
    mysql_stmt_get_longdata(thd, packet, packet_length);
unknown's avatar
unknown committed
1789 1790
    break;
  }
1791
  case COM_STMT_PREPARE:
unknown's avatar
unknown committed
1792
  {
1793
    mysql_stmt_prepare(thd, packet, packet_length);
unknown's avatar
unknown committed
1794 1795
    break;
  }
1796
  case COM_STMT_CLOSE:
unknown's avatar
unknown committed
1797
  {
1798
    mysql_stmt_close(thd, packet);
unknown's avatar
unknown committed
1799 1800
    break;
  }
1801
  case COM_STMT_RESET:
1802 1803 1804 1805
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
unknown's avatar
unknown committed
1806 1807
  case COM_QUERY:
  {
1808 1809
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1810
    char *packet_end= thd->query + thd->query_length;
unknown's avatar
unknown committed
1811 1812
    /* 'b' stands for 'buffer' parameter', special for 'my_snprintf' */
    const char *format= "%.*b";
1813 1814
    const char* found_semicolon= NULL;

unknown's avatar
unknown committed
1815
    mysql_log.write(thd,command, format, thd->query_length, thd->query);
1816
    DBUG_PRINT("query",("%-.4096s",thd->query));
1817 1818 1819 1820

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

1821
    mysql_parse(thd, thd->query, thd->query_length, & found_semicolon);
1822

1823
    while (!thd->killed && found_semicolon && !thd->net.report_error)
1824
    {
1825
      char *next_packet= (char*) found_semicolon;
1826
      net->no_send_error= 0;
1827
      /*
1828 1829
        Multiple queries exits, execute them individually
      */
1830 1831
      if (thd->lock || thd->open_tables || thd->derived_tables ||
          thd->prelocked_mode)
1832
        close_thread_tables(thd);
1833
      ulong length= (ulong)(packet_end - next_packet);
1834

1835
      log_slow_statement(thd);
1836

1837
      /* Remove garbage at start of query */
1838
      while (my_isspace(thd->charset(), *next_packet) && length > 0)
1839
      {
1840
        next_packet++;
1841 1842
        length--;
      }
unknown's avatar
unknown committed
1843
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1844
      thd->query_length= length;
1845
      thd->query= next_packet;
1846
      thd->query_id= next_query_id();
1847
      thd->set_time(); /* Reset the query start time. */
1848
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1849
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1850
      mysql_parse(thd, next_packet, length, & found_semicolon);
1851 1852
    }

unknown's avatar
unknown committed
1853 1854 1855 1856 1857
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1858
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1859
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
1860 1861
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
unknown's avatar
unknown committed
1862 1863 1864
    break;
#else
  {
1865
    char *fields, *pend;
1866
    /* Locked closure of all tables */
unknown's avatar
unknown committed
1867
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1868
    LEX_STRING conv_name;
1869

unknown's avatar
unknown committed
1870
    /* used as fields initializator */
1871
    lex_start(thd);
1872

1873 1874
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
unknown's avatar
unknown committed
1875
    bzero((char*) &table_list,sizeof(table_list));
1876
    if (thd->copy_db_to(&table_list.db, &table_list.db_length))
unknown's avatar
unknown committed
1877
      break;
1878
    pend= strend(packet);
unknown's avatar
unknown committed
1879 1880
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1881
    table_list.alias= table_list.table_name= conv_name.str;
1882
    packet= pend+1;
1883 1884

    if (!my_strcasecmp(system_charset_info, table_list.db,
1885
                       INFORMATION_SCHEMA_NAME.str))
1886 1887 1888 1889 1890 1891
    {
      ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, table_list.alias);
      if (schema_table)
        table_list.schema_table= schema_table;
    }

1892
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
unknown's avatar
unknown committed
1893 1894
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1895
    mysql_log.write(thd,command,"%s %s",table_list.table_name, fields);
1896
    if (lower_case_table_names)
1897 1898
      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
1899

unknown's avatar
unknown committed
1900
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
1901
		     0, 0, test(table_list.schema_table)))
unknown's avatar
unknown committed
1902
      break;
unknown's avatar
unknown committed
1903 1904
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1905
      break;
1906 1907
    /* init structures for VIEW processing */
    table_list.select_lex= &(thd->lex->select_lex);
1908 1909 1910 1911

    lex_start(thd);
    mysql_reset_thd_for_next_command(thd);

1912 1913 1914
    thd->lex->
      select_lex.table_list.link_in_list((byte*) &table_list,
                                         (byte**) &table_list.next_local);
unknown's avatar
unknown committed
1915
    thd->lex->add_to_query_tables(&table_list);
1916

1917 1918
    /* switch on VIEW optimisation: do not fill temporary tables */
    thd->lex->sql_command= SQLCOM_SHOW_FIELDS;
unknown's avatar
unknown committed
1919
    mysqld_list_fields(thd,&table_list,fields);
1920
    thd->lex->unit.cleanup();
1921
    thd->cleanup_after_query();
unknown's avatar
unknown committed
1922 1923 1924 1925
    break;
  }
#endif
  case COM_QUIT:
1926
    /* We don't calculate statistics for this command */
1927
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1928 1929 1930 1931
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1932
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1933
    {
unknown's avatar
unknown committed
1934
      char *db=thd->strdup(packet), *alias;
1935
      HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1936

1937 1938
      statistic_increment(thd->status_var.com_stat[SQLCOM_CREATE_DB],
			  &LOCK_status);
1939
      // null test to handle EOM
unknown's avatar
unknown committed
1940
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1941
      {
1942
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1943 1944
	break;
      }
1945
      if (check_access(thd,CREATE_ACL,db,0,1,0,is_schema_db(db)))
unknown's avatar
unknown committed
1946
	break;
1947
      mysql_log.write(thd,command,packet);
1948
      bzero(&create_info, sizeof(create_info));
1949 1950
      mysql_create_db(thd, (lower_case_table_names == 2 ? alias : db),
                      &create_info, 0);
unknown's avatar
unknown committed
1951 1952
      break;
    }
unknown's avatar
unknown committed
1953
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1954
    {
1955 1956
      statistic_increment(thd->status_var.com_stat[SQLCOM_DROP_DB],
			  &LOCK_status);
1957
      char *db=thd->strdup(packet);
unknown's avatar
unknown committed
1958
      /*  null test to handle EOM */
1959
      if (!db || check_db_name(db))
1960
      {
1961
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1962 1963
	break;
      }
1964
      if (check_access(thd,DROP_ACL,db,0,1,0,is_schema_db(db)))
1965
	break;
unknown's avatar
unknown committed
1966 1967
      if (thd->locked_tables || thd->active_transaction())
      {
unknown's avatar
unknown committed
1968 1969
	my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                   ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
unknown's avatar
unknown committed
1970
	break;
unknown's avatar
unknown committed
1971
      }
1972
      mysql_log.write(thd,command,db);
1973
      mysql_rm_db(thd, db, 0, 0);
unknown's avatar
unknown committed
1974 1975
      break;
    }
1976
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1977 1978
  case COM_BINLOG_DUMP:
    {
unknown's avatar
unknown committed
1979 1980 1981 1982
      ulong pos;
      ushort flags;
      uint32 slave_server_id;

1983
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1984
      thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
unknown committed
1985
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1986
	break;
unknown's avatar
unknown committed
1987

1988
      /* TODO: The following has to be changed to an 8 byte integer */
1989 1990
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1991
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1992
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1993
	kill_zombie_dump_threads(slave_server_id);
1994
      thd->server_id = slave_server_id;
unknown's avatar
unknown committed
1995 1996 1997

      mysql_log.write(thd, command, "Log: '%s'  Pos: %ld", packet+10,
                      (long) pos);
1998
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1999
      unregister_slave(thd,1,1);
unknown's avatar
unknown committed
2000
      /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
2001 2002
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
2003 2004
      break;
    }
2005
#endif
unknown's avatar
unknown committed
2006
  case COM_REFRESH:
unknown's avatar
unknown committed
2007 2008 2009 2010 2011 2012
  {
    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
2013
      break;
unknown's avatar
unknown committed
2014 2015 2016 2017 2018
    mysql_log.write(thd,command,NullS);
    if (!reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, &not_used))
      send_ok(thd);
    break;
  }
2019
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2020
  case COM_SHUTDOWN:
2021
  {
2022
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
2023
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
2024
      break; /* purecov: inspected */
2025
    /*
2026 2027 2028 2029
      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].
2030
    */
2031 2032
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
2033
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
2034 2035 2036 2037 2038 2039 2040
    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;
    }
2041
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
2042
    mysql_log.write(thd,command,NullS);
2043
    send_eof(thd);
unknown's avatar
unknown committed
2044 2045 2046
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
unknown's avatar
unknown committed
2047
#ifndef OS2
2048
    send_eof(thd);				// This is for 'quit request'
unknown's avatar
unknown committed
2049
#endif
2050
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
2051 2052 2053 2054
    close_thread_tables(thd);			// Free before kill
    kill_mysql();
    error=TRUE;
    break;
2055
  }
2056
#endif
unknown's avatar
unknown committed
2057 2058
  case COM_STATISTICS:
  {
2059
    mysql_log.write(thd,command,NullS);
2060 2061
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_STATUS],
			&LOCK_status);
unknown's avatar
unknown committed
2062
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2063
    char buff[200];
unknown's avatar
unknown committed
2064 2065 2066
#else
    char *buff= thd->net.last_error;
#endif
2067 2068 2069 2070

    STATUS_VAR current_global_status_var;
    calc_sum_of_all_status(&current_global_status_var);

2071
    ulong uptime = (ulong) (thd->start_time - server_start_time);
unknown's avatar
unknown committed
2072
    sprintf((char*) buff,
2073
	    "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
2074
	    uptime,
2075
	    (int) thread_count, (ulong) thd->query_id,
2076 2077
	    current_global_status_var.long_query_count,
	    current_global_status_var.opened_tables, refresh_version, cached_tables(),
2078 2079
	    (uptime ? (ulonglong2double(thd->query_id) / (double) uptime) :
	     (double) 0));
unknown's avatar
unknown committed
2080
#ifdef SAFEMALLOC
2081
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
2082
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
2083 2084
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
2085 2086
#endif
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2087
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
2088
    VOID(net_flush(net));
unknown's avatar
unknown committed
2089
#endif
unknown's avatar
unknown committed
2090 2091 2092
    break;
  }
  case COM_PING:
2093
    statistic_increment(thd->status_var.com_other, &LOCK_status);
2094
    send_ok(thd);				// Tell client we are alive
unknown's avatar
unknown committed
2095 2096
    break;
  case COM_PROCESS_INFO:
2097 2098
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST],
			&LOCK_status);
2099 2100
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd, PROCESS_ACL))
unknown's avatar
unknown committed
2101
      break;
2102
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
2103
    mysqld_list_processes(thd,
2104 2105
			  thd->security_ctx->master_access & PROCESS_ACL ? 
			  NullS : thd->security_ctx->priv_user, 0);
unknown's avatar
unknown committed
2106 2107 2108
    break;
  case COM_PROCESS_KILL:
  {
2109
    statistic_increment(thd->status_var.com_stat[SQLCOM_KILL], &LOCK_status);
2110
    ulong id=(ulong) uint4korr(packet);
unknown's avatar
SCRUM  
unknown committed
2111
    kill_one_thread(thd,id,false);
unknown's avatar
unknown committed
2112 2113
    break;
  }
2114 2115
  case COM_SET_OPTION:
  {
2116 2117
    statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
			&LOCK_status);
2118 2119 2120 2121
    uint opt_command= uint2korr(packet);

    switch (opt_command) {
    case (int) MYSQL_OPTION_MULTI_STATEMENTS_ON:
2122
      thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
2123
      send_eof(thd);
2124
      break;
2125
    case (int) MYSQL_OPTION_MULTI_STATEMENTS_OFF:
2126
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
2127
      send_eof(thd);
2128 2129
      break;
    default:
unknown's avatar
unknown committed
2130
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
2131 2132 2133 2134
      break;
    }
    break;
  }
unknown's avatar
unknown committed
2135
  case COM_DEBUG:
2136
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
2137
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2138
      break;					/* purecov: inspected */
2139
    mysql_print_status();
2140
    mysql_log.write(thd,command,NullS);
2141
    send_eof(thd);
unknown's avatar
unknown committed
2142 2143 2144 2145 2146
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
2147
  case COM_END:
unknown's avatar
unknown committed
2148
  default:
unknown's avatar
unknown committed
2149
    my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
2150 2151
    break;
  }
2152 2153
  if (thd->lock || thd->open_tables || thd->derived_tables ||
      thd->prelocked_mode)
unknown's avatar
unknown committed
2154 2155 2156 2157
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }
2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
  /*
    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())
2168
    thd->transaction.xid_state.xid.null();
unknown's avatar
unknown committed
2169

unknown's avatar
unknown committed
2170 2171 2172
  /* report error issued during command execution */
  if (thd->killed_errno() && !thd->net.report_error)
    thd->send_kill_message();
unknown's avatar
unknown committed
2173
  if (thd->net.report_error)
2174
    net_send_error(thd);
unknown's avatar
unknown committed
2175

2176
  log_slow_statement(thd);
2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191

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


2192
void log_slow_statement(THD *thd)
2193
{
2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204
  time_t start_of_query;

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

  start_of_query= thd->start_time;
2205
  thd->end_time();				// Set start time
2206

2207 2208 2209 2210 2211
  /*
    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
2212
  {
2213 2214
    thd->proc_info="logging slow query";

2215 2216
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2217
        (thd->server_status &
2218
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2219
        opt_log_queries_not_using_indexes &&
2220 2221
        /* == SQLCOM_END unless this is a SHOW command */
        thd->lex->orig_sql_command == SQLCOM_END)
2222
    {
2223
      thd->status_var.long_query_count++;
2224 2225
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
unknown's avatar
unknown committed
2226 2227 2228
  }
}

2229

unknown's avatar
unknown committed
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
/*
  Create a TABLE_LIST object for an INFORMATION_SCHEMA table.

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

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

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

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

2258 2259 2260 2261
int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
                         enum enum_schema_tables schema_table_idx)
{
  DBUG_ENTER("prepare_schema_table");
2262 2263
  SELECT_LEX *schema_select_lex= NULL;

2264
  switch (schema_table_idx) {
2265 2266
  case SCH_SCHEMATA:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
2267 2268
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0));   /* purecov: inspected */
2269 2270 2271 2272
    DBUG_RETURN(1);
#else
    break;
#endif
2273

2274 2275 2276
  case SCH_TABLE_NAMES:
  case SCH_TABLES:
  case SCH_VIEWS:
2277
  case SCH_TRIGGERS:
2278
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2279 2280
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2281 2282
    DBUG_RETURN(1);
#else
2283
    if (lex->select_lex.db == NULL &&
2284
        lex->copy_db_to(&lex->select_lex.db, NULL))
2285
    {
2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297
      DBUG_RETURN(1);
    }

    schema_select_lex= new SELECT_LEX();
    schema_select_lex->db= lex->select_lex.db;
    schema_select_lex->table_list.first= NULL;
    remove_escape(schema_select_lex->db); // Fix escaped '_'

    if (check_db_name(schema_select_lex->db))
    {
      my_error(ER_WRONG_DB_NAME, MYF(0), schema_select_lex->db);
      DBUG_RETURN(1);
2298
    }
2299 2300 2301


    break;
2302 2303 2304 2305
#endif
  case SCH_COLUMNS:
  case SCH_STATISTICS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2306 2307
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2308 2309 2310
    DBUG_RETURN(1);
#else
    {
2311 2312
      DBUG_ASSERT(table_ident);

2313
      TABLE_LIST **query_tables_last= lex->query_tables_last;
2314
      schema_select_lex= new SELECT_LEX();
unknown's avatar
unknown committed
2315
      /* 'parent_lex' is used in init_query() so it must be before it. */
2316 2317 2318 2319
      schema_select_lex->parent_lex= lex;
      schema_select_lex->init_query();
      if (!schema_select_lex->add_table_to_list(thd, table_ident, 0, 0, TL_READ,
                                  (List<String> *) 0, (List<String> *) 0))
2320 2321
        DBUG_RETURN(1);
      lex->query_tables_last= query_tables_last;
2322 2323 2324 2325 2326

      TABLE_LIST *dst_table= (TABLE_LIST*) schema_select_lex->table_list.first;
      remove_escape(dst_table->db);			// Fix escaped '_'
      remove_escape(dst_table->table_name);

2327 2328 2329
      break;
    }
#endif
2330 2331 2332
  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352
  case SCH_PROCEDURES:
  case SCH_CHARSETS:
  case SCH_COLLATIONS:
  case SCH_COLLATION_CHARACTER_SET_APPLICABILITY:
  case SCH_USER_PRIVILEGES:
  case SCH_SCHEMA_PRIVILEGES:
  case SCH_TABLE_PRIVILEGES:
  case SCH_COLUMN_PRIVILEGES:
  case SCH_TABLE_CONSTRAINTS:
  case SCH_KEY_COLUMN_USAGE:
  default:
    break;
  }
  
  SELECT_LEX *select_lex= lex->current_select;
  if (make_schema_select(thd, select_lex, schema_table_idx))
  {
    DBUG_RETURN(1);
  }
  TABLE_LIST *table_list= (TABLE_LIST*) select_lex->table_list.first;
2353
  table_list->schema_select_lex= schema_select_lex;
2354
  table_list->schema_table_reformed= 1;
2355 2356
  statistic_increment(thd->status_var.com_stat[lex->orig_sql_command],
                      &LOCK_status);
2357 2358 2359 2360
  DBUG_RETURN(0);
}


2361 2362
/*
  Read query from packet and store in thd->query
2363
  Used in COM_QUERY and COM_STMT_PREPARE
2364 2365 2366 2367 2368 2369 2370

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
unknown's avatar
unknown committed
2371 2372
    FALSE ok
    TRUE  error;  In this case thd->fatal_error is set
2373 2374
*/

2375
bool alloc_query(THD *thd, const char *packet, uint packet_length)
2376 2377
{
  packet_length--;				// Remove end null
2378
  /* Remove garbage at start and end of query */
unknown's avatar
unknown committed
2379
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
2380 2381 2382 2383
  {
    packet++;
    packet_length--;
  }
2384
  const char *pos= packet + packet_length;     // Point at end null
unknown's avatar
unknown committed
2385
  while (packet_length > 0 &&
unknown's avatar
unknown committed
2386
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
2387 2388 2389 2390 2391
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
2392
  thd->query_length= 0;                        // Extra safety: Avoid races
2393 2394
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
2395 2396
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
unknown's avatar
unknown committed
2397
    return TRUE;
2398 2399
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
2400 2401 2402 2403

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

unknown's avatar
unknown committed
2405
  return FALSE;
2406 2407
}

2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
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;
2421
  thd->variables.lc_time_names= &my_locale_en_US;
2422 2423 2424
  thd->one_shot_set= 0;
}

2425

2426
/*
2427
  Execute command saved in thd and lex->sql_command
2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448

  SYNOPSIS
    mysql_execute_command()
      thd                       Thread handle

  IMPLEMENTATION

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

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

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

unknown's avatar
unknown committed
2450
bool
2451
mysql_execute_command(THD *thd)
unknown's avatar
unknown committed
2452
{
2453 2454
  bool res= FALSE;
  bool need_start_waiting= FALSE; // have protection against global read lock
2455
  int  up_result= 0;
2456
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
2457
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
unknown's avatar
unknown committed
2458
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
2459
  /* first table of first SELECT_LEX */
unknown's avatar
unknown committed
2460
  TABLE_LIST *first_table= (TABLE_LIST*) select_lex->table_list.first;
unknown's avatar
VIEW  
unknown committed
2461 2462 2463
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
2464
  SELECT_LEX_UNIT *unit= &lex->unit;
2465
  /* Saved variable value */
unknown's avatar
unknown committed
2466
  DBUG_ENTER("mysql_execute_command");
2467
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
2468

2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
  /*
    Remember first generated insert id value of the previous
    statement.  We remember it here at the beginning of the statement,
    and also in Item_func_last_insert_id::fix_fields() and
    sys_var_last_insert_id::value_ptr().  Last two places are required
    because LAST_INSERT_ID() and @@LAST_INSERT_ID may also be used in
    expression that is not executed with mysql_execute_command().

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

unknown's avatar
VIEW  
unknown committed
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498
  /*
    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();
2499
  /* should be assigned after making first tables same */
unknown's avatar
VIEW  
unknown committed
2500
  all_tables= lex->query_tables;
2501 2502 2503 2504
  /* 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
2505

2506 2507 2508 2509 2510
  /*
    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.
2511
    Don't reset warnings when executing a stored routine.
2512
  */
2513
  if ((all_tables || &lex->select_lex != lex->all_selects_list ||
2514
       lex->sroutines.records) && !thd->spcont ||
2515
      lex->time_zone_tables_used)
unknown's avatar
unknown committed
2516
    mysql_reset_errors(thd, 0);
2517

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

      Exceptions are:
unknown's avatar
unknown committed
2550 2551
      - UPDATE MULTI: For this statement, we want to check the filtering
        rules later in the code
2552
      - SET: we always execute it (Not that many SET commands exists in
unknown's avatar
unknown committed
2553 2554
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
2555 2556
      - 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
2557
    */
unknown's avatar
unknown committed
2558 2559
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
	!(lex->sql_command == SQLCOM_SET_OPTION) &&
2560
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2561
          lex->drop_temporary && lex->drop_if_exists) &&
unknown's avatar
Merge  
unknown committed
2562
        all_tables_not_ok(thd, all_tables))
unknown's avatar
unknown committed
2563 2564
    {
      /* we warn the slave SQL thread */
unknown's avatar
unknown committed
2565
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582
      if (thd->one_shot_set)
      {
        /*
          It's ok to check thd->one_shot_set here:

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

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

unknown's avatar
unknown committed
2612 2613
  DBUG_ASSERT(thd->transaction.stmt.modified_non_trans_table == FALSE);
  
unknown's avatar
unknown committed
2614 2615 2616
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2617 2618 2619 2620
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
2621 2622
	param->select_limit=
          new Item_int((ulonglong)thd->variables.select_limit);
2623 2624
    }

2625
    select_result *sel_result=lex->result;
unknown's avatar
VIEW  
unknown committed
2626
    if (all_tables)
unknown's avatar
unknown committed
2627
    {
2628 2629 2630 2631 2632 2633
      if (lex->orig_sql_command != SQLCOM_SHOW_STATUS_PROC &&
          lex->orig_sql_command != SQLCOM_SHOW_STATUS_FUNC)
        res= check_table_access(thd,
                                lex->exchange ? SELECT_ACL | FILE_ACL :
                                SELECT_ACL,
                                all_tables, 0);
unknown's avatar
unknown committed
2634 2635
    }
    else
unknown's avatar
VIEW  
unknown committed
2636 2637
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
2638
			any_db, 0, 0, 0, 0);
unknown's avatar
unknown committed
2639
    if (res)
unknown's avatar
unknown committed
2640
      goto error;
unknown's avatar
unknown committed
2641

unknown's avatar
VIEW  
unknown committed
2642
    if (!(res= open_and_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
2643
    {
unknown's avatar
unknown committed
2644
      if (lex->describe)
unknown's avatar
unknown committed
2645
      {
2646 2647 2648 2649 2650 2651
        /*
          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.
        */
2652
	if (!(sel_result= new select_send()))
2653
	  goto error;
2654
	else
2655 2656
	  thd->send_explain_fields(sel_result);
	res= mysql_explain_union(thd, &thd->lex->unit, sel_result);
unknown's avatar
unknown committed
2657 2658 2659 2660 2661
	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
2662
	  thd->lex->unit.print(&str);
unknown's avatar
unknown committed
2663 2664 2665 2666
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2667 2668
	sel_result->send_eof();
        delete sel_result;
unknown's avatar
unknown committed
2669 2670 2671
      }
      else
      {
2672
	if (!sel_result && !(sel_result= new select_send()))
unknown's avatar
unknown committed
2673
          goto error;
unknown's avatar
VIEW  
unknown committed
2674
	query_cache_store_query(thd, all_tables);
2675 2676 2677
	res= handle_select(thd, lex, sel_result, 0);
        if (sel_result != lex->result)
          delete sel_result;
unknown's avatar
unknown committed
2678
      }
unknown's avatar
unknown committed
2679
    }
unknown's avatar
unknown committed
2680 2681
    break;
  }
unknown's avatar
unknown committed
2682
  case SQLCOM_PREPARE:
2683
  {
2684
    mysql_sql_stmt_prepare(thd);
unknown's avatar
unknown committed
2685 2686 2687 2688
    break;
  }
  case SQLCOM_EXECUTE:
  {
2689
    mysql_sql_stmt_execute(thd);
unknown's avatar
unknown committed
2690 2691 2692 2693
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2694
    mysql_sql_stmt_close(thd);
unknown's avatar
unknown committed
2695 2696
    break;
  }
unknown's avatar
unknown committed
2697
  case SQLCOM_DO:
2698 2699
    if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
        open_and_lock_tables(thd, all_tables))
unknown's avatar
unknown committed
2700
      goto error;
unknown's avatar
unknown committed
2701 2702

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

2705
  case SQLCOM_EMPTY_QUERY:
2706
    send_ok(thd);
2707 2708
    break;

unknown's avatar
unknown committed
2709 2710 2711 2712
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2713
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2714
  case SQLCOM_PURGE:
2715
  {
unknown's avatar
unknown committed
2716
    if (check_global_access(thd, SUPER_ACL))
2717
      goto error;
unknown's avatar
unknown committed
2718
    /* PURGE MASTER LOGS TO 'file' */
2719 2720 2721
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2722 2723
  case SQLCOM_PURGE_BEFORE:
  {
2724 2725
    Item *it;

2726 2727
    if (check_global_access(thd, SUPER_ACL))
      goto error;
unknown's avatar
unknown committed
2728
    /* PURGE MASTER LOGS BEFORE 'data' */
2729
    it= (Item *)lex->value_list.head();
2730
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
unknown's avatar
unknown committed
2731
        it->check_cols(1))
2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742
    {
      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());
2743 2744
    break;
  }
2745
#endif
unknown's avatar
unknown committed
2746 2747
  case SQLCOM_SHOW_WARNS:
  {
2748 2749
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2750 2751 2752
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
unknown's avatar
unknown committed
2753 2754 2755 2756
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2757 2758
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
unknown's avatar
unknown committed
2759 2760
    break;
  }
unknown's avatar
unknown committed
2761 2762
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
2763
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2764
      goto error;
2765
    /* This query don't work now. See comment in repl_failsafe.cc */
unknown's avatar
unknown committed
2766
#ifndef WORKING_NEW_MASTER
unknown's avatar
unknown committed
2767 2768
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "SHOW NEW MASTER");
    goto error;
unknown's avatar
unknown committed
2769
#else
unknown's avatar
unknown committed
2770 2771
    res = show_new_master(thd);
    break;
unknown's avatar
unknown committed
2772
#endif
unknown's avatar
unknown committed
2773
  }
2774

unknown's avatar
unknown committed
2775
#ifdef HAVE_REPLICATION
2776 2777
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2778
    if (check_global_access(thd, REPL_SLAVE_ACL))
2779 2780 2781 2782
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2783 2784
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2785
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2786
      goto error;
2787
    res = mysql_show_binlog_events(thd);
unknown's avatar
unknown committed
2788 2789
    break;
  }
2790 2791
#endif

unknown's avatar
unknown committed
2792
  case SQLCOM_BACKUP_TABLE:
2793
  {
unknown's avatar
VIEW  
unknown committed
2794 2795 2796
    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
2797
	check_global_access(thd, FILE_ACL))
2798
      goto error; /* purecov: inspected */
2799
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2800
    res = mysql_backup_table(thd, first_table);
2801
    select_lex->table_list.first= (byte*) first_table;
2802
    lex->query_tables=all_tables;
2803 2804
    break;
  }
unknown's avatar
unknown committed
2805
  case SQLCOM_RESTORE_TABLE:
2806
  {
unknown's avatar
VIEW  
unknown committed
2807 2808 2809
    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
2810
	check_global_access(thd, FILE_ACL))
2811
      goto error; /* purecov: inspected */
2812
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2813
    res = mysql_restore_table(thd, first_table);
2814
    select_lex->table_list.first= (byte*) first_table;
2815
    lex->query_tables=all_tables;
2816 2817
    break;
  }
unknown's avatar
unknown committed
2818 2819
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
unknown's avatar
VIEW  
unknown committed
2820 2821 2822
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
2823 2824
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2825
      goto error;
2826
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
unknown's avatar
unknown committed
2827 2828
    break;
  }
unknown's avatar
unknown committed
2829 2830
  case SQLCOM_PRELOAD_KEYS:
  {
unknown's avatar
VIEW  
unknown committed
2831 2832 2833
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
2834 2835
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
2836
      goto error;
unknown's avatar
VIEW  
unknown committed
2837
    res = mysql_preload_keys(thd, first_table);
unknown's avatar
unknown committed
2838 2839
    break;
  }
unknown's avatar
unknown committed
2840
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2841
  case SQLCOM_CHANGE_MASTER:
2842
  {
unknown's avatar
unknown committed
2843
    if (check_global_access(thd, SUPER_ACL))
2844
      goto error;
2845
    pthread_mutex_lock(&LOCK_active_mi);
2846
    res = change_master(thd,active_mi);
2847
    pthread_mutex_unlock(&LOCK_active_mi);
2848 2849
    break;
  }
unknown's avatar
unknown committed
2850
  case SQLCOM_SHOW_SLAVE_STAT:
2851
  {
2852 2853
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2854
      goto error;
2855
    pthread_mutex_lock(&LOCK_active_mi);
2856
    res = show_master_info(thd,active_mi);
2857
    pthread_mutex_unlock(&LOCK_active_mi);
2858 2859
    break;
  }
unknown's avatar
unknown committed
2860
  case SQLCOM_SHOW_MASTER_STAT:
2861
  {
2862 2863
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2864 2865 2866 2867
      goto error;
    res = show_binlog_info(thd);
    break;
  }
unknown's avatar
unknown committed
2868

2869
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
2870
    if (check_global_access(thd, SUPER_ACL))
2871
      goto error;
2872
    if (end_active_trans(thd))
unknown's avatar
unknown committed
2873
      goto error;
2874 2875
    else
      res = load_master_data(thd);
2876
    break;
unknown's avatar
unknown committed
2877
#endif /* HAVE_REPLICATION */
2878 2879 2880 2881 2882 2883 2884
#ifdef HAVE_NDBCLUSTER_DB
  case SQLCOM_SHOW_NDBCLUSTER_STATUS:
    {
      res = ndbcluster_show_status(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
2885 2886 2887
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
2888
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2889 2890 2891 2892
	goto error;
      res = innodb_show_status(thd);
      break;
    }
unknown's avatar
unknown committed
2893 2894 2895
  case SQLCOM_SHOW_MUTEX_STATUS:
    {
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2896
        goto error;
unknown's avatar
unknown committed
2897 2898 2899
      res = innodb_mutex_show_status(thd);
      break;
    }
unknown's avatar
unknown committed
2900
#endif
unknown's avatar
unknown committed
2901
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2902
  case SQLCOM_LOAD_MASTER_TABLE:
2903
  {
unknown's avatar
VIEW  
unknown committed
2904
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2905 2906
    DBUG_ASSERT(first_table->db); /* Must be set in the parser */

unknown's avatar
VIEW  
unknown committed
2907
    if (check_access(thd, CREATE_ACL, first_table->db,
2908 2909
		     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2910 2911 2912 2913
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
unknown's avatar
VIEW  
unknown committed
2914
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2915
	goto error;
unknown's avatar
unknown committed
2916
    }
2917
    if (strlen(first_table->table_name) > NAME_LEN)
unknown's avatar
unknown committed
2918
    {
2919
      my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name);
unknown's avatar
unknown committed
2920 2921
      break;
    }
2922
    pthread_mutex_lock(&LOCK_active_mi);
2923 2924 2925 2926
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2927
    if (!fetch_master_table(thd, first_table->db, first_table->table_name,
2928
			    active_mi, 0, 0))
2929
    {
2930
      send_ok(thd);
2931
    }
2932
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2933
    break;
2934
  }
unknown's avatar
unknown committed
2935
#endif /* HAVE_REPLICATION */
2936

unknown's avatar
unknown committed
2937
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
2938
  {
2939
    /* If CREATE TABLE of non-temporary table, do implicit commit */
2940 2941 2942 2943 2944 2945 2946 2947 2948 2949
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
    {
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
    else 
    {
unknown's avatar
unknown committed
2950
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
unknown's avatar
unknown committed
2951
      thd->transaction.all.modified_non_trans_table= TRUE;
2952
    }
unknown's avatar
VIEW  
unknown committed
2953 2954 2955 2956 2957
    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
2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971
    /*
      Code below (especially in mysql_create_table() and select_create
      methods) may modify HA_CREATE_INFO structure in LEX, so we have to
      use a copy of this structure to make execution prepared statement-
      safe. A shallow copy is enough as this code won't modify any memory
      referenced from this structure.
    */
    HA_CREATE_INFO create_info(lex->create_info);
    Alter_info alter_info(lex->alter_info, thd->mem_root);

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

unknown's avatar
VIEW  
unknown committed
2975
    if ((res= create_table_precheck(thd, select_tables, create_table)))
unknown's avatar
unknown committed
2976
      goto end_with_restore_list;
unknown's avatar
unknown committed
2977

2978
    create_info.alias= create_table->alias;
2979

2980
#ifndef HAVE_READLINK
2981
    if (create_info.data_file_name)
2982 2983
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                   "DATA DIRECTORY option ignored");
2984
    if (create_info.index_file_name)
2985 2986
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                   "INDEX DIRECTORY option ignored");
unknown's avatar
unknown committed
2987
    create_info.data_file_name= create_info.index_file_name= NULL;
2988
#else
2989
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
2990
    if (append_file_to_dir(thd, &create_info.data_file_name,
2991
			   create_table->table_name) ||
unknown's avatar
unknown committed
2992
	append_file_to_dir(thd, &create_info.index_file_name,
2993
			   create_table->table_name))
unknown's avatar
unknown committed
2994
      goto end_with_restore_list;
2995
#endif
2996
    /*
2997
      If we are using SET CHARSET without DEFAULT, add an implicit
2998 2999
      DEFAULT to not confuse old users. (This may change).
    */
unknown's avatar
unknown committed
3000
    if ((create_info.used_fields &
3001 3002 3003
	 (HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) ==
	HA_CREATE_USED_CHARSET)
    {
unknown's avatar
unknown committed
3004 3005 3006 3007
      create_info.used_fields&= ~HA_CREATE_USED_CHARSET;
      create_info.used_fields|= HA_CREATE_USED_DEFAULT_CHARSET;
      create_info.default_table_charset= create_info.table_charset;
      create_info.table_charset= 0;
3008
    }
3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021
    /*
      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.
    */
3022 3023
    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
3024
    {
unknown's avatar
unknown committed
3025 3026
      res= 1;
      goto end_with_restore_list;
3027
    }
3028
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
3029
    {
3030
      select_result *sel_result;
3031

3032
      select_lex->options|= SELECT_NO_UNLOCK;
3033
      unit->set_limit(select_lex);
3034

unknown's avatar
unknown committed
3035 3036 3037 3038 3039 3040 3041
      if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
      {
        lex->link_first_table_back(create_table, link_to_local);
        create_table->create= TRUE;
      }

      if (!(res= open_and_lock_tables(thd, lex->query_tables)))
3042
      {
3043 3044 3045 3046
        /*
          Is table which we are changing used somewhere in other parts
          of query
        */
3047
        if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
3048
        {
3049
          TABLE_LIST *duplicate;
unknown's avatar
unknown committed
3050
          create_table= lex->unlink_first_table(&link_to_local);
3051
          if ((duplicate= unique_table(thd, create_table, select_tables, 0)))
3052 3053 3054
          {
            update_non_unique_table_error(create_table, "CREATE", duplicate);
            res= 1;
3055
            goto end_with_restore_list;
3056
          }
3057
        }
unknown's avatar
unknown committed
3058
        /* If we create merge table, we have to test tables in merge, too */
3059
        if (create_info.used_fields & HA_CREATE_USED_UNION)
unknown's avatar
unknown committed
3060 3061
        {
          TABLE_LIST *tab;
3062
          for (tab= (TABLE_LIST*) create_info.merge_list.first;
unknown's avatar
unknown committed
3063 3064 3065
               tab;
               tab= tab->next_local)
          {
3066
            TABLE_LIST *duplicate;
3067
            if ((duplicate= unique_table(thd, tab, select_tables, 0)))
unknown's avatar
unknown committed
3068
            {
3069
              update_non_unique_table_error(tab, "CREATE", duplicate);
unknown's avatar
unknown committed
3070
              res= 1;
3071
              goto end_with_restore_list;
unknown's avatar
unknown committed
3072 3073 3074
            }
          }
        }
unknown's avatar
unknown committed
3075 3076 3077 3078
        /*
          select_create is currently not re-execution friendly and
          needs to be created for every execution of a PS/SP.
        */
3079
        if ((sel_result= new select_create(create_table,
3080 3081
                                           &create_info,
                                           &alter_info,
3082 3083 3084
                                           select_lex->item_list,
                                           lex->duplicates,
                                           lex->ignore)))
3085 3086 3087 3088 3089
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
3090 3091
          res= handle_select(thd, lex, sel_result, 0);
          delete sel_result;
3092
        }
3093
      }
unknown's avatar
unknown committed
3094 3095 3096
      else if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
        create_table= lex->unlink_first_table(&link_to_local);

3097
    }
unknown's avatar
unknown committed
3098
    else
unknown's avatar
unknown committed
3099
    {
unknown's avatar
unknown committed
3100
      /* regular create */
unknown's avatar
unknown committed
3101 3102 3103
      if (lex->create_info.options & HA_LEX_CREATE_TABLE_LIKE)
        res= mysql_create_like_table(thd, create_table, select_tables,
                                     &create_info);
unknown's avatar
unknown committed
3104
      else
3105
      {
unknown's avatar
VIEW  
unknown committed
3106
        res= mysql_create_table(thd, create_table->db,
3107
                                create_table->table_name, &create_info,
unknown's avatar
unknown committed
3108
                                &alter_info, 0, 0);
3109
      }
unknown's avatar
unknown committed
3110
      if (!res)
3111
	send_ok(thd);
unknown's avatar
unknown committed
3112
    }
3113

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

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

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

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

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

unknown's avatar
unknown committed
3153 3154
    bzero((char*) &create_info, sizeof(create_info));
    create_info.db_type= DB_TYPE_DEFAULT;
unknown's avatar
unknown committed
3155
    create_info.row_type= ROW_TYPE_NOT_USED;
unknown's avatar
unknown committed
3156
    create_info.default_table_charset= thd->variables.collation_database;
unknown's avatar
unknown committed
3157

3158
    res= mysql_alter_table(thd, first_table->db, first_table->table_name,
3159
                           &create_info, first_table, &alter_info,
3160
                           0, (ORDER*) 0, 0);
unknown's avatar
unknown committed
3161 3162
    break;
  }
unknown's avatar
unknown committed
3163
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3164
  case SQLCOM_SLAVE_START:
3165
  {
3166
    pthread_mutex_lock(&LOCK_active_mi);
3167
    start_slave(thd,active_mi,1 /* net report*/);
3168
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
3169
    break;
3170
  }
unknown's avatar
unknown committed
3171
  case SQLCOM_SLAVE_STOP:
3172 3173 3174 3175 3176 3177
  /*
    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,
3178
      so it waits for the client thread because t is locked by it.
3179
    - then the client thread does SLAVE STOP.
3180 3181
      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.
3182 3183 3184
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
3185
  if (thd->locked_tables || thd->active_transaction() || thd->global_read_lock)
3186
  {
3187 3188
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3189
    goto error;
3190
  }
3191
  {
3192
    pthread_mutex_lock(&LOCK_active_mi);
3193
    stop_slave(thd,active_mi,1/* net report*/);
3194
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
3195
    break;
3196
  }
unknown's avatar
unknown committed
3197
#endif /* HAVE_REPLICATION */
3198

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

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

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

unknown's avatar
VIEW  
unknown committed
3339
      if (check_db_used(thd, all_tables) ||
unknown's avatar
unknown committed
3340
          check_show_create_table_access(thd, first_table))
3341
	goto error;
unknown's avatar
unknown committed
3342
      res= mysqld_show_create(thd, first_table);
unknown's avatar
unknown committed
3343 3344
      break;
    }
unknown's avatar
unknown committed
3345
#endif
3346 3347
  case SQLCOM_CHECKSUM:
  {
unknown's avatar
VIEW  
unknown committed
3348 3349 3350
    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))
3351
      goto error; /* purecov: inspected */
unknown's avatar
VIEW  
unknown committed
3352
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
3353 3354
    break;
  }
unknown's avatar
unknown committed
3355
  case SQLCOM_REPAIR:
3356
  {
unknown's avatar
VIEW  
unknown committed
3357 3358 3359
    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))
3360
      goto error; /* purecov: inspected */
3361
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3362
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
3363 3364 3365
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3366
      /* Presumably, REPAIR and binlog writing doesn't require synchronization */
3367 3368
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3369
	thd->clear_error(); // No binlog error generated
3370
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3371 3372 3373
        mysql_bin_log.write(&qinfo);
      }
    }
3374
    select_lex->table_list.first= (byte*) first_table;
3375
    lex->query_tables=all_tables;
3376 3377
    break;
  }
unknown's avatar
unknown committed
3378
  case SQLCOM_CHECK:
3379
  {
unknown's avatar
VIEW  
unknown committed
3380 3381 3382
    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))
3383
      goto error; /* purecov: inspected */
3384
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3385
    res = mysql_check_table(thd, first_table, &lex->check_opt);
3386
    select_lex->table_list.first= (byte*) first_table;
3387
    lex->query_tables=all_tables;
3388 3389
    break;
  }
unknown's avatar
unknown committed
3390 3391
  case SQLCOM_ANALYZE:
  {
unknown's avatar
VIEW  
unknown committed
3392 3393 3394
    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
3395
      goto error; /* purecov: inspected */
3396
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
3397
    res = mysql_analyze_table(thd, first_table, &lex->check_opt);
3398 3399 3400
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3401
      /* Presumably, ANALYZE and binlog writing doesn't require synchronization */
3402 3403
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3404
	thd->clear_error(); // No binlog error generated
3405
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3406 3407 3408
        mysql_bin_log.write(&qinfo);
      }
    }
3409
    select_lex->table_list.first= (byte*) first_table;
3410
    lex->query_tables=all_tables;
unknown's avatar
unknown committed
3411
    break;
unknown's avatar
unknown committed
3412
  }
3413

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

3469
    res= mysql_multi_update_prepare(thd);
unknown's avatar
unknown committed
3470

3471
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3472
    /* Check slave filtering rules */
3473
    if (unlikely(thd->slave_thread))
unknown's avatar
unknown committed
3474
    {
3475 3476
      if (all_tables_not_ok(thd, all_tables))
      {
3477 3478 3479 3480 3481
        if (res!= 0)
        {
          res= 0;             /* don't care of prev failure  */
          thd->clear_error(); /* filters are of highest prior */
        }
3482 3483 3484 3485
        /* we warn the slave SQL thread */
        my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
        break;
      }
3486 3487
      if (res)
        break;
unknown's avatar
unknown committed
3488
    }
3489 3490
    else
    {
3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503
#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
3504

unknown's avatar
unknown committed
3505 3506 3507 3508 3509 3510
    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
3511
    break;
unknown's avatar
unknown committed
3512
  }
unknown's avatar
unknown committed
3513
  case SQLCOM_REPLACE:
3514 3515
  case SQLCOM_INSERT:
  {
unknown's avatar
VIEW  
unknown committed
3516
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3517
    if ((res= insert_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3518
      break;
3519 3520 3521 3522 3523 3524 3525 3526

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

unknown's avatar
VIEW  
unknown committed
3527
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
unknown's avatar
unknown committed
3528
		      lex->update_list, lex->value_list,
3529
                      lex->duplicates, lex->ignore);
3530 3531 3532 3533 3534 3535 3536

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

unknown's avatar
unknown committed
3540
    break;
3541
  }
unknown's avatar
unknown committed
3542 3543 3544
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
3545
    select_result *sel_result;
unknown's avatar
VIEW  
unknown committed
3546
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3547
    if ((res= insert_precheck(thd, all_tables)))
3548
      break;
unknown's avatar
unknown committed
3549

3550
    /* Fix lock for first table */
unknown's avatar
VIEW  
unknown committed
3551 3552
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
3553

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

3557
    unit->set_limit(select_lex);
3558 3559 3560 3561 3562 3563 3564 3565

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

unknown's avatar
VIEW  
unknown committed
3566
    if (!(res= open_and_lock_tables(thd, all_tables)))
3567
    {
3568
      /* Skip first table, which is the table we are inserting in */
unknown's avatar
unknown committed
3569 3570
      TABLE_LIST *second_table= first_table->next_local;
      select_lex->table_list.first= (byte*) second_table;
3571 3572
      select_lex->context.table_list= 
        select_lex->context.first_name_resolution_table= second_table;
3573
      res= mysql_insert_select_prepare(thd);
3574 3575 3576 3577 3578 3579 3580
      if (!res && (sel_result= new select_insert(first_table,
                                                 first_table->table,
                                                 &lex->field_list,
                                                 &lex->update_list,
                                                 &lex->value_list,
                                                 lex->duplicates,
                                                 lex->ignore)))
3581
      {
3582
	res= handle_select(thd, lex, sel_result, OPTION_SETUP_TABLES_DONE);
3583 3584 3585 3586 3587 3588 3589 3590 3591
        /*
          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)
        {
3592 3593 3594
          /* INSERT ... SELECT should invalidate only the very first table */
          TABLE_LIST *save_table= first_table->next_local;
          first_table->next_local= 0;
3595 3596
          mysql_unlock_tables(thd, thd->lock);
          query_cache_invalidate3(thd, first_table, 1);
3597
          first_table->next_local= save_table;
3598 3599
          thd->lock=0;
        }
3600
        delete sel_result;
3601
      }
3602
      /* revert changes for SP */
unknown's avatar
unknown committed
3603
      select_lex->table_list.first= (byte*) first_table;
3604
    }
unknown's avatar
VIEW  
unknown committed
3605

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

unknown's avatar
unknown committed
3615 3616
    break;
  }
3617
  case SQLCOM_TRUNCATE:
3618 3619 3620 3621 3622
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
VIEW  
unknown committed
3623 3624
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
unknown's avatar
unknown committed
3625
      goto error;
3626 3627 3628 3629
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
3630
    if (thd->locked_tables || thd->active_transaction())
3631
    {
unknown's avatar
unknown committed
3632 3633
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3634 3635
      goto error;
    }
unknown's avatar
VIEW  
unknown committed
3636

unknown's avatar
unknown committed
3637
    res= mysql_truncate(thd, first_table, 0);
3638
    break;
unknown's avatar
unknown committed
3639
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
3640
  {
unknown's avatar
VIEW  
unknown committed
3641 3642
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= delete_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3643
      break;
3644 3645
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
3646 3647 3648 3649 3650 3651 3652 3653

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

unknown's avatar
VIEW  
unknown committed
3654
    res = mysql_delete(thd, all_tables, select_lex->where,
3655
                       &select_lex->order_list,
unknown's avatar
unknown committed
3656 3657
                       unit->select_limit_cnt, select_lex->options,
                       FALSE);
unknown's avatar
unknown committed
3658 3659
    break;
  }
3660
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
3661
  {
unknown's avatar
VIEW  
unknown committed
3662
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3663
    TABLE_LIST *aux_tables=
unknown's avatar
unknown committed
3664
      (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
3665
    multi_delete *del_result;
unknown's avatar
unknown committed
3666

3667 3668 3669 3670 3671 3672 3673
    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
    {
      res= 1;
      break;
    }

3674
    if ((res= multi_delete_precheck(thd, all_tables)))
3675
      break;
unknown's avatar
unknown committed
3676

unknown's avatar
unknown committed
3677
    /* condition will be TRUE on SP re-excuting */
3678 3679
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
unknown's avatar
unknown committed
3680
    if (add_item_to_list(thd, new Item_null()))
unknown's avatar
unknown committed
3681
      goto error;
3682

unknown's avatar
unknown committed
3683
    thd->proc_info="init";
unknown's avatar
VIEW  
unknown committed
3684 3685 3686 3687
    if ((res= open_and_lock_tables(thd, all_tables)))
      break;

    if ((res= mysql_multi_delete_prepare(thd)))
unknown's avatar
unknown committed
3688
      goto error;
3689

3690 3691
    if (!thd->is_fatal_error &&
        (del_result= new multi_delete(aux_tables, lex->table_count)))
unknown's avatar
unknown committed
3692
    {
3693 3694 3695
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3696
			select_lex->item_list,
unknown's avatar
unknown committed
3697
			select_lex->where,
3698
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
unknown's avatar
unknown committed
3699 3700
			(ORDER *)NULL,
			select_lex->options | thd->options |
3701 3702
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                        OPTION_SETUP_TABLES_DONE,
3703 3704
			del_result, unit, select_lex);
      delete del_result;
unknown's avatar
unknown committed
3705 3706
    }
    else
3707
      res= TRUE;                                // Error
unknown's avatar
unknown committed
3708 3709
    break;
  }
unknown's avatar
unknown committed
3710
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
3711
  {
unknown's avatar
VIEW  
unknown committed
3712
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3713 3714
    if (!lex->drop_temporary)
    {
unknown's avatar
VIEW  
unknown committed
3715
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
3716 3717
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
unknown's avatar
unknown committed
3718
        goto error;
3719
    }
unknown's avatar
unknown committed
3720
    else
unknown's avatar
unknown committed
3721 3722 3723 3724 3725 3726
    {
      /*
	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
3727 3728
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
unknown's avatar
unknown committed
3729 3730
      */
      if (thd->slave_thread)
3731
        lex->drop_if_exists= 1;
3732

unknown's avatar
unknown committed
3733
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
unknown's avatar
unknown committed
3734
      thd->transaction.all.modified_non_trans_table= TRUE;
unknown's avatar
unknown committed
3735
    }
3736
    /* DDL and binlog write order protected by LOCK_open */
unknown's avatar
VIEW  
unknown committed
3737 3738
    res= mysql_rm_table(thd, first_table, lex->drop_if_exists,
			lex->drop_temporary);
unknown's avatar
unknown committed
3739 3740
  }
  break;
unknown's avatar
unknown committed
3741
  case SQLCOM_SHOW_PROCESSLIST:
3742 3743
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
3744
      break;
unknown's avatar
unknown committed
3745
    mysqld_list_processes(thd,
3746 3747 3748 3749
			  (thd->security_ctx->master_access & PROCESS_ACL ?
                           NullS :
                           thd->security_ctx->priv_user),
                          lex->verbose);
unknown's avatar
unknown committed
3750
    break;
unknown's avatar
unknown committed
3751 3752
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
unknown's avatar
unknown committed
3753 3754 3755 3756 3757 3758 3759
    break;
  case SQLCOM_SHOW_PRIVILEGES:
    res= mysqld_show_privileges(thd);
    break;
  case SQLCOM_SHOW_COLUMN_TYPES:
    res= mysqld_show_column_types(thd);
    break;
unknown's avatar
unknown committed
3760 3761
  case SQLCOM_SHOW_LOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3762 3763
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
3764
    goto error;
unknown's avatar
unknown committed
3765 3766
#else
    {
3767
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0,0))
unknown's avatar
unknown committed
3768 3769 3770 3771
	goto error;
      res= mysqld_show_logs(thd);
      break;
    }
unknown's avatar
unknown committed
3772 3773
#endif
  case SQLCOM_CHANGE_DB:
3774 3775 3776 3777
  {
    LEX_STRING db_str= { (char *) select_lex->db, strlen(select_lex->db) };

    if (!mysql_change_db(thd, &db_str, FALSE))
3778
      send_ok(thd);
3779

unknown's avatar
unknown committed
3780
    break;
3781
  }
3782

unknown's avatar
unknown committed
3783 3784
  case SQLCOM_LOAD:
  {
unknown's avatar
VIEW  
unknown committed
3785
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3786
    uint privilege= (lex->duplicates == DUP_REPLACE ?
unknown's avatar
unknown committed
3787 3788
		     INSERT_ACL | DELETE_ACL : INSERT_ACL) |
                    (lex->local_file ? 0 : FILE_ACL);
3789

unknown's avatar
unknown committed
3790
    if (lex->local_file)
unknown's avatar
unknown committed
3791
    {
3792
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
3793
          !opt_local_infile)
3794
      {
unknown's avatar
unknown committed
3795
	my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
3796 3797
	goto error;
      }
unknown's avatar
unknown committed
3798
    }
unknown's avatar
unknown committed
3799 3800 3801 3802

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

unknown's avatar
VIEW  
unknown committed
3803
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
unknown's avatar
unknown committed
3804
                    lex->update_list, lex->value_list, lex->duplicates,
3805
                    lex->ignore, (bool) lex->local_file);
unknown's avatar
unknown committed
3806 3807
    break;
  }
3808

unknown's avatar
unknown committed
3809
  case SQLCOM_SET_OPTION:
3810 3811
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
3812
    if ((check_table_access(thd, SELECT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
3813 3814
	 open_and_lock_tables(thd, all_tables)))
      goto error;
3815 3816
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
unknown's avatar
unknown committed
3817 3818
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
      goto error;
3819 3820 3821 3822 3823 3824 3825 3826
    }
    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;
3827
      send_ok(thd);
3828
    }
unknown's avatar
unknown committed
3829
    break;
3830
  }
unknown's avatar
unknown committed
3831

unknown's avatar
unknown committed
3832
  case SQLCOM_UNLOCK_TABLES:
3833 3834 3835 3836 3837 3838
    /*
      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
3839
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
3840 3841
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
3842
      end_active_trans(thd);
unknown's avatar
unknown committed
3843
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3844 3845
    }
    if (thd->global_read_lock)
3846
      unlock_global_read_lock(thd);
3847
    send_ok(thd);
unknown's avatar
unknown committed
3848 3849
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
3850
    unlock_locked_tables(thd);
3851 3852 3853 3854
    /* we must end the trasaction first, regardless of anything */
    if (end_active_trans(thd))
      goto error;
    if (check_db_used(thd, all_tables))
unknown's avatar
unknown committed
3855
      goto error;
unknown's avatar
VIEW  
unknown committed
3856
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3857
      goto error;
unknown's avatar
unknown committed
3858
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
3859
    thd->options|= OPTION_TABLE_LOCK;
unknown's avatar
VIEW  
unknown committed
3860

3861
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
3862
    {
3863 3864
#ifdef HAVE_QUERY_CACHE
      if (thd->variables.query_cache_wlock_invalidate)
unknown's avatar
VIEW  
unknown committed
3865
	query_cache.invalidate_locked_for_write(first_table);
3866
#endif /*HAVE_QUERY_CACHE*/
unknown's avatar
unknown committed
3867 3868
      thd->locked_tables=thd->lock;
      thd->lock=0;
3869
      send_ok(thd);
unknown's avatar
unknown committed
3870
    }
unknown's avatar
unknown committed
3871
    else
3872 3873 3874 3875 3876 3877 3878
    {
      /* 
        Need to end the current transaction, so the storage engine (InnoDB)
        can free its locks if LOCK TABLES locked some tables before finding
        that it can't lock a table in its list
      */
      end_active_trans(thd);
unknown's avatar
unknown committed
3879
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
3880
    }
unknown's avatar
unknown committed
3881 3882 3883
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3884
  {
unknown's avatar
unknown committed
3885 3886 3887 3888 3889 3890
    /*
      As mysql_create_db() may modify HA_CREATE_INFO structure passed to
      it, we need to use a copy of LEX::create_info to make execution
      prepared statement- safe.
    */
    HA_CREATE_INFO create_info(lex->create_info);
3891 3892 3893 3894 3895
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
unknown committed
3896
    char *alias;
unknown's avatar
unknown committed
3897
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3898
    {
3899
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3900 3901
      break;
    }
3902 3903 3904
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
3905
      For that reason, db_ok() in sql/slave.cc did not check the
3906 3907 3908
      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.
    */
3909
#ifdef HAVE_REPLICATION
3910
    if (thd->slave_thread &&
3911 3912
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3913
    {
unknown's avatar
unknown committed
3914
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3915
      break;
unknown's avatar
unknown committed
3916
    }
3917
#endif
3918

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

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

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

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

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

unknown's avatar
unknown committed
4271
  case SQLCOM_BEGIN:
4272 4273 4274 4275 4276 4277
    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
4278
    if (begin_trans(thd))
unknown's avatar
unknown committed
4279
      goto error;
unknown's avatar
unknown committed
4280
    send_ok(thd);
unknown's avatar
unknown committed
4281 4282
    break;
  case SQLCOM_COMMIT:
4283
    if (end_trans(thd, lex->tx_release ? COMMIT_RELEASE :
unknown's avatar
unknown committed
4284
                              lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
unknown's avatar
unknown committed
4285
      goto error;
4286
    send_ok(thd);
unknown's avatar
unknown committed
4287 4288
    break;
  case SQLCOM_ROLLBACK:
4289
    if (end_trans(thd, lex->tx_release ? ROLLBACK_RELEASE :
unknown's avatar
unknown committed
4290
                              lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
unknown's avatar
unknown committed
4291
      goto error;
4292
    send_ok(thd);
unknown's avatar
unknown committed
4293
    break;
unknown's avatar
unknown committed
4294
  case SQLCOM_RELEASE_SAVEPOINT:
unknown's avatar
unknown committed
4295
  {
4296 4297
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
unknown's avatar
unknown committed
4298 4299 4300
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4301
                       (uchar *)sv->name, sv->length) == 0)
unknown's avatar
unknown committed
4302 4303
        break;
    }
4304
    if (sv)
unknown's avatar
unknown committed
4305
    {
4306
      if (ha_release_savepoint(thd, sv))
unknown's avatar
unknown committed
4307
        res= TRUE; // cannot happen
unknown's avatar
unknown committed
4308 4309
      else
        send_ok(thd);
4310
      thd->transaction.savepoints=sv->prev;
unknown's avatar
unknown committed
4311
    }
4312
    else
unknown's avatar
unknown committed
4313
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
4314
    break;
unknown's avatar
unknown committed
4315
  }
unknown's avatar
unknown committed
4316
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
unknown's avatar
unknown committed
4317
  {
4318 4319
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
4320 4321 4322
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4323
                       (uchar *)sv->name, sv->length) == 0)
4324 4325
        break;
    }
4326
    if (sv)
4327
    {
4328
      if (ha_rollback_to_savepoint(thd, sv))
4329 4330
        res= TRUE; // cannot happen
      else
unknown's avatar
unknown committed
4331
      {
unknown's avatar
unknown committed
4332
        if (thd->transaction.all.modified_non_trans_table &&
unknown's avatar
unknown committed
4333 4334 4335 4336 4337 4338
            !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);
      }
4339
      thd->transaction.savepoints=sv;
unknown's avatar
unknown committed
4340 4341
    }
    else
4342
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
4343
    break;
4344
  }
4345
  case SQLCOM_SAVEPOINT:
4346 4347
    if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN) ||
          thd->in_sub_stmt) || !opt_using_transactions)
unknown's avatar
unknown committed
4348
      send_ok(thd);
unknown's avatar
unknown committed
4349
    else
4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387
    {
      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
4388
    break;
4389 4390
  case SQLCOM_CREATE_PROCEDURE:
  case SQLCOM_CREATE_SPFUNCTION:
unknown's avatar
unknown committed
4391
  {
4392
    uint namelen;
unknown's avatar
unknown committed
4393
    char *name;
4394
    int sp_result= SP_INTERNAL_ERROR;
4395

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

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

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

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

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

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

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

4444 4445 4446 4447 4448 4449 4450 4451
        - 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.
4452

4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466
          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)
    {
4467
      bool local_res= FALSE;
4468 4469 4470 4471
      Query_arena original_arena;
      Query_arena *ps_arena = thd->activate_stmt_arena_if_needed(&original_arena);

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

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

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

      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).
    */
4490

4491 4492 4493 4494 4495 4496 4497 4498
    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");
4499
        goto create_sp_error;
4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517
      }
    }

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

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

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

4565 4566 4567 4568 4569 4570 4571 4572 4573
      /*
        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;

      /*
4574 4575
        By this moment all needed SPs should be in cache so no need to look 
        into DB. 
4576
      */
4577 4578
      if (!(sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                                &thd->sp_proc_cache, TRUE)))
4579
      {
4580
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PROCEDURE",
unknown's avatar
unknown committed
4581
                 lex->spname->m_qname.str);
4582
	goto error;
4583 4584 4585
      }
      else
      {
unknown's avatar
unknown committed
4586
	ha_rows select_limit;
unknown's avatar
unknown committed
4587 4588
        /* bits that should be cleared in thd->server_status */
	uint bits_to_be_cleared= 0;
4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600
        /*
          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;
        }
4601

4602
	my_bool save_no_send_ok= thd->net.no_send_ok;
4603
	thd->net.no_send_ok= TRUE;
4604
	if (sp->m_flags & sp_head::MULTI_RESULTS)
4605
	{
4606
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
4607
	  {
4608 4609 4610 4611
            /*
              The client does not support multiple result sets being sent
              back
            */
4612
	    my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str);
4613
	    thd->net.no_send_ok= save_no_send_ok;
4614 4615
	    goto error;
	  }
unknown's avatar
unknown committed
4616 4617 4618 4619 4620 4621 4622
          /*
            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;
4623 4624
	}

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

4636
        /* 
4637
          We never write CALL statements into binlog:
4638 4639 4640 4641 4642
           - 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.
4643
        */
4644
	res= sp->execute_procedure(thd, &lex->value_list);
4645 4646 4647
	/*
          If warnings have been cleared, we have to clear total_warn_count
          too, otherwise the clients get confused.
4648 4649 4650 4651
	 */
	if (thd->warn_list.is_empty())
	  thd->total_warn_count= 0;

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

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

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

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

        if (end_active_trans(thd)) 
          goto error;
4699
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
4700 4701
        if ((sp->m_type == TYPE_ENUM_FUNCTION) &&
            !trust_function_creators &&  mysql_bin_log.is_open() &&
4702 4703 4704 4705 4706 4707
            !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));
4708
          sp_result= SP_INTERNAL_ERROR;
4709 4710 4711
        }
        else
        {
4712 4713 4714 4715 4716 4717
          /*
            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.
          */
4718
          /* Conditionally writes to binlog */
4719
          if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4720 4721
            sp_result= sp_update_procedure(thd, lex->spname,
                                           &lex->sp_chistics);
4722
          else
4723
            sp_result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
4724
        }
4725
      }
4726
      switch (sp_result)
4727
      {
unknown's avatar
unknown committed
4728
      case SP_OK:
4729
	send_ok(thd);
unknown's avatar
unknown committed
4730 4731
	break;
      case SP_KEY_NOT_FOUND:
4732 4733
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4734 4735
	goto error;
      default:
4736 4737
	my_error(ER_SP_CANT_ALTER, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4738
	goto error;
4739
      }
4740
      break;
4741 4742
    }
  case SQLCOM_DROP_PROCEDURE:
4743
  case SQLCOM_DROP_FUNCTION:
4744
    {
4745
      int sp_result;
4746 4747
      int type= (lex->sql_command == SQLCOM_DROP_PROCEDURE ?
                 TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION);
4748

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

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

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

	    /* Does NOT write to binlog */
4791
	    if (!(res = mysql_drop_function(thd, &lex->spname->m_name)))
4792
	    {
4793 4794
	      send_ok(thd);
	      break;
4795 4796
	    }
	  }
4797
	}
4798
#endif
4799
	if (lex->spname->m_db.str)
4800
	  sp_result= SP_KEY_NOT_FOUND;
4801 4802 4803 4804 4805
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
4806
      }
4807 4808
      res= sp_result;
      switch (sp_result) {
4809
      case SP_OK:
4810
	send_ok(thd);
4811 4812
	break;
      case SP_KEY_NOT_FOUND:
4813 4814
	if (lex->drop_if_exists)
	{
4815
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
4816
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
4817
			      SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4818
	  res= FALSE;
4819 4820 4821
	  send_ok(thd);
	  break;
	}
4822 4823
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4824 4825
	goto error;
      default:
4826 4827
	my_error(ER_SP_DROP_FAILED, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4828
	goto error;
4829
      }
4830
      break;
4831
    }
unknown's avatar
unknown committed
4832 4833
  case SQLCOM_SHOW_CREATE_PROC:
    {
4834
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4835
      {
4836
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4837 4838
	goto error;
      }
unknown's avatar
unknown committed
4839
      if (sp_show_create_procedure(thd, lex->spname) != SP_OK)
4840
      {			/* We don't distinguish between errors for now */
4841 4842
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4843 4844 4845 4846 4847 4848
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
4849
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4850
      {
4851
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4852 4853
	goto error;
      }
unknown's avatar
unknown committed
4854
      if (sp_show_create_function(thd, lex->spname) != SP_OK)
4855
      {			/* We don't distinguish between errors for now */
4856 4857
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4858 4859 4860 4861 4862 4863
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
4864
      res= sp_show_status_procedure(thd, (lex->wild ?
unknown's avatar
unknown committed
4865 4866 4867 4868 4869
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
4870
      res= sp_show_status_function(thd, (lex->wild ? 
unknown's avatar
unknown committed
4871 4872 4873
					 lex->wild->ptr() : NullS));
      break;
    }
unknown's avatar
unknown committed
4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885
#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
4886 4887
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
unknown's avatar
unknown committed
4888
      else
unknown's avatar
unknown committed
4889 4890
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
4891
      if (!sp || sp->show_routine_code(thd))
4892 4893
      {
        /* We don't distinguish between errors for now */
unknown's avatar
unknown committed
4894 4895 4896 4897 4898 4899 4900
        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
4901 4902
  case SQLCOM_CREATE_VIEW:
    {
4903 4904 4905 4906
      /*
        Note: SQLCOM_CREATE_VIEW also handles 'ALTER VIEW' commands
        as specified through the thd->lex->create_view_mode flag.
      */
4907 4908 4909
      if (end_active_trans(thd))
        goto error;

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

4927
    /* Conditionally writes to binlog. */
4928 4929
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

4930 4931 4932 4933
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
4934 4935 4936
    if (end_active_trans(thd))
      goto error;

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

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

5135
  /*
5136 5137 5138 5139 5140 5141
    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.
5142
   */
5143 5144
  if (lex->sql_command != SQLCOM_CALL && lex->sql_command != SQLCOM_EXECUTE &&
      uc_update_queries[lex->sql_command]<2)
5145
    thd->row_count_func= -1;
5146 5147

  goto end;
unknown's avatar
unknown committed
5148 5149

error:
5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161
  res= TRUE;

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


unknown's avatar
unknown committed
5165
/*
5166
  Check grants for commands which work only with one table.
unknown's avatar
unknown committed
5167

5168
  SYNOPSIS
5169
    check_single_table_access()
unknown's avatar
unknown committed
5170
    thd			Thread handler
5171
    privilege		requested privilege
unknown's avatar
VIEW  
unknown committed
5172
    all_tables		global table list of query
unknown's avatar
unknown committed
5173 5174 5175

  RETURN
    0 - OK
unknown's avatar
unknown committed
5176
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
5177 5178
*/

5179 5180
bool check_single_table_access(THD *thd, ulong privilege, 
                               TABLE_LIST *all_tables)
unknown's avatar
unknown committed
5181
{
5182 5183 5184 5185 5186 5187
  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;

5188 5189 5190 5191 5192 5193 5194 5195
  const char *db_name;
  if ((all_tables->view || all_tables->field_translation) &&
      !all_tables->schema_table)
    db_name= all_tables->view_db.str;
  else
    db_name= all_tables->db;

  if (check_access(thd, privilege, db_name,
5196 5197
		   &all_tables->grant.privilege, 0, 0,
                   test(all_tables->schema_table)))
5198
    goto deny;
unknown's avatar
unknown committed
5199

unknown's avatar
unknown committed
5200
  /* Show only 1 table for check_grant */
5201 5202 5203 5204
  if (grant_option &&
      !(all_tables->belong_to_view &&
        (thd->lex->sql_command == SQLCOM_SHOW_FIELDS)) &&
      check_grant(thd, privilege, all_tables, 0, 1, 0))
5205 5206 5207
    goto deny;

  thd->security_ctx= backup_ctx;
5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233
  return 0;

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

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

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

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

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

5235
  /* Check rights on tables of subselects and implictly opened tables */
unknown's avatar
unknown committed
5236
  TABLE_LIST *subselects_tables, *view= all_tables->view ? all_tables : 0;
unknown's avatar
VIEW  
unknown committed
5237
  if ((subselects_tables= all_tables->next_global))
unknown's avatar
unknown committed
5238
  {
unknown's avatar
unknown committed
5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250
    /*
      Access rights asked for the first table of a view should be the same
      as for the view
    */
    if (view && subselects_tables->belong_to_view == view)
    {
      if (check_single_table_access (thd, privilege, subselects_tables))
        return 1;
      subselects_tables= subselects_tables->next_global;
    }
    if (subselects_tables &&
        (check_table_access(thd, SELECT_ACL, subselects_tables, 0)))
5251
      return 1;
unknown's avatar
unknown committed
5252 5253
  }
  return 0;
unknown's avatar
unknown committed
5254 5255 5256
}


unknown's avatar
unknown committed
5257
/****************************************************************************
unknown's avatar
unknown committed
5258
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271

  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
5272 5273
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
5274 5275 5276
****************************************************************************/

bool
unknown's avatar
unknown committed
5277
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
5278
	     bool dont_check_global_grants, bool no_errors, bool schema_db)
unknown's avatar
unknown committed
5279
{
5280
  Security_context *sctx= thd->security_ctx;
unknown's avatar
unknown committed
5281 5282
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293
  /*
    GRANT command:
    In case of database level grant the database name may be a pattern,
    in case of table|column level grant the database name can not be a pattern.
    We use 'dont_check_global_grants' as a flag to determine
    if it's database level grant command 
    (see SQLCOM_GRANT case, mysql_execute_command() function) and
    set db_is_pattern according to 'dont_check_global_grants' value.
  */
  bool  db_is_pattern= (test(want_access & GRANT_ACL) &&
                        dont_check_global_grants);
unknown's avatar
unknown committed
5294 5295
#endif
  ulong dummy;
5296 5297
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
5298
                      db ? db : "", want_access, sctx->master_access));
unknown's avatar
unknown committed
5299 5300 5301 5302 5303
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

5304
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
5305
  {
5306
    DBUG_PRINT("error",("No database"));
5307
    if (!no_errors)
unknown's avatar
unknown committed
5308 5309
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                 MYF(0));                       /* purecov: tested */
unknown's avatar
unknown committed
5310
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5311 5312
  }

5313 5314
  if (schema_db)
  {
5315 5316
    if (!(sctx->master_access & FILE_ACL) && (want_access & FILE_ACL) ||
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5317 5318
    {
      if (!no_errors)
5319 5320
      {
        const char *db_name= db ? db : thd->db;
5321
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5322 5323
                 sctx->priv_user, sctx->priv_host, db_name);
      }
5324 5325 5326 5327 5328 5329 5330 5331 5332
      DBUG_RETURN(TRUE);
    }
    else
    {
      *save_priv= SELECT_ACL;
      DBUG_RETURN(FALSE);
    }
  }

unknown's avatar
unknown committed
5333 5334 5335
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
5336
  if ((sctx->master_access & want_access) == want_access)
unknown's avatar
unknown committed
5337
  {
5338 5339 5340 5341 5342
    /*
      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
    */
5343 5344
    db_access= sctx->db_access;
    if (!(sctx->master_access & SELECT_ACL) &&
unknown's avatar
unknown committed
5345
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
5346 5347 5348
      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
5349
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
5350
  }
5351
  if (((want_access & ~sctx->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
5352
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
5353
  {						// We can never grant this
5354
    DBUG_PRINT("error",("No possible access"));
5355
    if (!no_errors)
5356
      my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
5357 5358
               sctx->priv_user,
               sctx->priv_host,
5359 5360 5361
               (thd->password ?
                ER(ER_YES) :
                ER(ER_NO)));                    /* purecov: tested */
unknown's avatar
unknown committed
5362
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5363 5364 5365
  }

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

unknown's avatar
unknown committed
5368
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
5369 5370
    db_access= acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                       db_is_pattern);
unknown's avatar
unknown committed
5371
  else
5372
    db_access= sctx->db_access;
5373
  DBUG_PRINT("info",("db_access: %lu", db_access));
unknown's avatar
unknown committed
5374
  /* Remove SHOW attribute and access rights we already have */
5375
  want_access &= ~(sctx->master_access | EXTRA_ACL);
5376 5377
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
5378
  db_access= ((*save_priv=(db_access | sctx->master_access)) & want_access);
5379 5380

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
5381
  if (db_access == want_access ||
5382
      (grant_option && !dont_check_global_grants &&
5383
       !(want_access & ~(db_access | TABLE_ACLS | PROC_ACLS))))
unknown's avatar
unknown committed
5384
    DBUG_RETURN(FALSE);				/* Ok */
5385 5386

  DBUG_PRINT("error",("Access denied"));
5387
  if (!no_errors)
5388
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5389
             sctx->priv_user, sctx->priv_host,
5390 5391 5392
             (db ? db : (thd->db ?
                         thd->db :
                         "unknown")));          /* purecov: tested */
unknown's avatar
unknown committed
5393
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
5394
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
5395 5396 5397
}


5398 5399 5400 5401 5402 5403 5404 5405 5406
/*
  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
5407
    One gets access right if one has ANY of the rights in want_access
5408 5409 5410 5411 5412 5413 5414 5415
    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
5416 5417

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
5418
{
unknown's avatar
unknown committed
5419 5420 5421
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
5422
  char command[128];
5423
  if ((thd->security_ctx->master_access & want_access))
unknown's avatar
unknown committed
5424 5425
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
5426
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
unknown's avatar
unknown committed
5427
  return 1;
unknown's avatar
unknown committed
5428
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
5429 5430 5431
}


5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508
static bool check_show_access(THD *thd, TABLE_LIST *table)
{
  switch (get_schema_table_idx(table->schema_table))
  {
  case SCH_SCHEMATA:
    return (specialflag & SPECIAL_SKIP_SHOW_DB) &&
           check_global_access(thd, SHOW_DB_ACL);

  case SCH_TABLE_NAMES:
  case SCH_TABLES:
  case SCH_VIEWS:
  case SCH_TRIGGERS:
    {
      const char *dst_db_name= table->schema_select_lex->db;

      DBUG_ASSERT(dst_db_name);

      if (check_access(thd, SELECT_ACL, dst_db_name,
                       &thd->col_access, FALSE, FALSE,
                       is_schema_db(dst_db_name)))
      {
        return TRUE;
      }

      if (!thd->col_access && check_grant_db(thd, dst_db_name))
      {
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
                 thd->security_ctx->priv_user,
                 thd->security_ctx->priv_host,
                 dst_db_name);
        return TRUE;
      }

      return FALSE;
    }

  case SCH_COLUMNS:
  case SCH_STATISTICS:
    {
      TABLE_LIST *dst_table=
        (TABLE_LIST *) table->schema_select_lex->table_list.first;

      DBUG_ASSERT(dst_table);

      if (check_access(thd, SELECT_ACL | EXTRA_ACL,
                       dst_table->db,
                       &dst_table->grant.privilege,
                       FALSE, FALSE,
                       test(dst_table->schema_table)))
      {
        return FALSE;
      }

      return grant_option &&
             check_grant(thd, SELECT_ACL, dst_table, 2, UINT_MAX, FALSE);
    }

  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
  case SCH_PROCEDURES:
  case SCH_CHARSETS:
  case SCH_COLLATIONS:
  case SCH_COLLATION_CHARACTER_SET_APPLICABILITY:
  case SCH_USER_PRIVILEGES:
  case SCH_SCHEMA_PRIVILEGES:
  case SCH_TABLE_PRIVILEGES:
  case SCH_COLUMN_PRIVILEGES:
  case SCH_TABLE_CONSTRAINTS:
  case SCH_KEY_COLUMN_USAGE:
    break;
  }

  return FALSE;
}


unknown's avatar
unknown committed
5509
/*
5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529
  Check the privilege for all used tables.

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

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

  RETURN VALUE
    FALSE - OK
    TRUE  - Access denied
unknown's avatar
unknown committed
5530 5531
*/

5532
bool
unknown's avatar
unknown committed
5533
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
5534
		   bool no_errors)
unknown's avatar
unknown committed
5535
{
unknown's avatar
unknown committed
5536 5537
  uint found=0;
  ulong found_access=0;
5538
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5539
  TABLE_LIST *org_tables= tables;
5540
#endif
5541
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
5542
  Security_context *sctx= thd->security_ctx, *backup_ctx= thd->security_ctx;
5543
  /*
unknown's avatar
unknown committed
5544 5545 5546
    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.
5547
  */
unknown's avatar
unknown committed
5548
  for (; tables != first_not_own_table; tables= tables->next_global)
unknown's avatar
unknown committed
5549
  {
5550 5551 5552 5553 5554
    if (tables->security_ctx)
      sctx= tables->security_ctx;
    else
      sctx= backup_ctx;

5555
    if (tables->schema_table && 
5556
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5557 5558 5559
    {
      if (!no_errors)
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5560
                 sctx->priv_user, sctx->priv_host,
5561
                 INFORMATION_SCHEMA_NAME.str);
5562 5563
      return TRUE;
    }
5564 5565 5566 5567 5568
    /*
       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);
5569 5570 5571 5572 5573 5574 5575 5576 5577 5578

    if (tables->schema_table_reformed)
    {
      if (check_show_access(thd, tables))
        goto deny;

      continue;
    }

    if (tables->derived ||
5579
        (tables->table && (int)tables->table->s->tmp_table) ||
5580 5581
        my_tz_check_n_skip_implicit_tables(&tables,
                                           thd->lex->time_zone_tables_used))
unknown's avatar
unknown committed
5582
      continue;
5583 5584
    thd->security_ctx= sctx;
    if ((sctx->master_access & want_access) ==
5585
        (want_access & ~EXTRA_ACL) &&
unknown's avatar
unknown committed
5586
	thd->db)
unknown's avatar
unknown committed
5587
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
5588
    else if (tables->db && thd->db && strcmp(tables->db, thd->db) == 0)
unknown's avatar
unknown committed
5589 5590 5591 5592 5593
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
5594
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5595
			 0, no_errors, test(tables->schema_table)))
5596
	  goto deny;                            // Access denied
unknown's avatar
unknown committed
5597
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
5598
	found=1;
unknown's avatar
unknown committed
5599 5600
      }
    }
5601
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5602
			  0, no_errors, test(tables->schema_table)))
5603
      goto deny;
unknown's avatar
unknown committed
5604
  }
5605
  thd->security_ctx= backup_ctx;
unknown's avatar
unknown committed
5606
  if (grant_option)
5607
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
unknown's avatar
unknown committed
5608
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
unknown's avatar
unknown committed
5609
  return FALSE;
5610 5611 5612
deny:
  thd->security_ctx= backup_ctx;
  return TRUE;
unknown's avatar
unknown committed
5613 5614
}

5615

5616
bool
5617 5618
check_routine_access(THD *thd, ulong want_access,char *db, char *name,
		     bool is_proc, bool no_errors)
5619 5620 5621 5622 5623
{
  TABLE_LIST tables[1];
  
  bzero((char *)tables, sizeof(TABLE_LIST));
  tables->db= db;
5624
  tables->table_name= tables->alias= name;
5625
  
unknown's avatar
unknown committed
5626 5627 5628 5629 5630 5631 5632
  /*
    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)
5633 5634
    tables->grant.privilege= want_access;
  else if (check_access(thd,want_access,db,&tables->grant.privilege,
unknown's avatar
unknown committed
5635
			0, no_errors, 0))
5636 5637
    return TRUE;
  
unknown's avatar
unknown committed
5638
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5639
  if (grant_option)
5640
    return check_grant_routine(thd, want_access, tables, is_proc, no_errors);
unknown's avatar
unknown committed
5641
#endif
5642 5643 5644 5645

  return FALSE;
}

5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660

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

5661 5662
bool check_some_routine_access(THD *thd, const char *db, const char *name,
                               bool is_proc)
5663 5664
{
  ulong save_priv;
5665
  if (thd->security_ctx->master_access & SHOW_PROC_ACLS)
5666
    return FALSE;
5667 5668 5669 5670 5671
  /*
    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) ||
5672 5673
      (save_priv & SHOW_PROC_ACLS))
    return FALSE;
5674
  return check_routine_level_acl(thd, db, name, is_proc);
5675 5676 5677
}


5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702
/*
  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,
5703 5704
                        &table->grant.privilege, 0, 1,
                        test(table->schema_table)) &&
5705 5706 5707 5708 5709 5710 5711 5712 5713
          !grant_option || !check_grant(thd, access, table, 0, 1, 1))
        DBUG_RETURN(0);
    }
  }
  DBUG_PRINT("exit",("no matching access rights"));
  DBUG_RETURN(1);
}


5714 5715
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
5716 5717 5718 5719
{
  int error=0;
  if (table_list)
  {
5720
    /* Check that all tables use the current database */
5721
    TABLE_LIST *tmp;
unknown's avatar
VIEW  
unknown committed
5722
    for (tmp= table_list; tmp; tmp= tmp->next_local)
5723 5724 5725 5726
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
5727
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
unknown's avatar
unknown committed
5728
			     table_list,0);
5729 5730 5731 5732
  }
  return error;
}

unknown's avatar
unknown committed
5733 5734 5735

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
unknown's avatar
unknown committed
5736
  char *current_db= NULL;
unknown's avatar
VIEW  
unknown committed
5737
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
5738
  {
unknown's avatar
unknown committed
5739
    if (tables->db == NULL)
unknown's avatar
unknown committed
5740
    {
unknown's avatar
unknown committed
5741 5742 5743 5744 5745 5746 5747 5748 5749
      /*
        This code never works and should be removed in 5.1.  All tables
        that are added to the list of tables should already have its
        database field initialized properly (see st_lex::add_table_to_list).
      */
      DBUG_ASSERT(0);
      if (thd->copy_db_to(&current_db, 0))
        return TRUE;
      tables->db= current_db;
unknown's avatar
unknown committed
5750 5751 5752 5753
    }
  }
  return FALSE;
}
5754

unknown's avatar
unknown committed
5755 5756 5757 5758 5759 5760 5761 5762 5763 5764
/****************************************************************************
	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
5765 5766 5767 5768
#ifndef DBUG_OFF
long max_stack_used;
#endif

5769
#ifndef EMBEDDED_LIBRARY
5770 5771 5772 5773 5774 5775 5776 5777
/*
  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
5778 5779
{
  long stack_used;
5780
  DBUG_ASSERT(thd == current_thd);
unknown's avatar
unknown committed
5781
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
unknown's avatar
unknown committed
5782
      (long) (thread_stack - margin))
unknown's avatar
unknown committed
5783
  {
5784 5785 5786
    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));
5787
    thd->fatal_error();
unknown's avatar
unknown committed
5788 5789
    return 1;
  }
unknown's avatar
unknown committed
5790 5791 5792
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
unknown's avatar
unknown committed
5793 5794
  return 0;
}
5795
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
5796 5797 5798 5799

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

5800
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
unknown's avatar
unknown committed
5801
{
5802
  LEX	*lex= current_thd->lex;
5803
  ulong old_info=0;
unknown's avatar
unknown committed
5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828
  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;
}


5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844
/*
 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");
5845
  thd->free_list= 0;
5846
  thd->select_number= 1;
5847
  thd->query_start_used= thd->insert_id_used=0;
5848
  thd->last_insert_id_used_bin_log= FALSE;
5849
  thd->is_fatal_error= thd->time_zone_used= 0;
unknown's avatar
unknown committed
5850
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
unknown's avatar
unknown committed
5851 5852
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
5853
  DBUG_ASSERT(thd->security_ctx== &thd->main_security_ctx);
unknown's avatar
unknown committed
5854
  thd->tmp_table_used= 0;
5855
  thd->thread_specific_used= FALSE;
5856 5857
  if (!thd->in_sub_stmt)
  {
5858
    if (opt_bin_log)
5859
    {
5860
      reset_dynamic(&thd->user_var_events);
5861 5862
      thd->user_var_events_alloc= thd->mem_root;
    }
5863
    thd->clear_error();
5864 5865 5866 5867
    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
5868 5869 5870
  DBUG_VOID_RETURN;
}

5871

5872 5873 5874
void
mysql_init_select(LEX *lex)
{
unknown's avatar
unknown committed
5875
  SELECT_LEX *select_lex= lex->current_select;
unknown's avatar
unknown committed
5876
  select_lex->init_select();
5877
  lex->wild= 0;
5878 5879
  if (select_lex == &lex->select_lex)
  {
5880
    DBUG_ASSERT(lex->result == 0);
5881 5882
    lex->exchange= 0;
  }
5883 5884
}

5885

unknown's avatar
unknown committed
5886
bool
unknown's avatar
unknown committed
5887
mysql_new_select(LEX *lex, bool move_down)
5888
{
unknown's avatar
unknown committed
5889
  SELECT_LEX *select_lex;
5890
  THD *thd= lex->thd;
unknown's avatar
unknown committed
5891 5892
  DBUG_ENTER("mysql_new_select");

5893
  if (!(select_lex= new (thd->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
5894
    DBUG_RETURN(1);
5895
  select_lex->select_number= ++thd->select_number;
unknown's avatar
unknown committed
5896
  select_lex->parent_lex= lex; /* Used in init_query. */
unknown's avatar
unknown committed
5897 5898
  select_lex->init_query();
  select_lex->init_select();
unknown's avatar
unknown committed
5899
  lex->nest_level++;
unknown's avatar
unknown committed
5900 5901 5902 5903 5904
  if (lex->nest_level > (int) MAX_SELECT_NESTING)
  {
    my_error(ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT,MYF(0),MAX_SELECT_NESTING);
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
5905
  select_lex->nest_level= lex->nest_level;
5906 5907 5908 5909 5910
  /*
    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
5911
  if (thd->stmt_arena->is_stmt_prepare())
5912
    select_lex->uncacheable|= UNCACHEABLE_PREPARE;
unknown's avatar
unknown committed
5913 5914
  if (move_down)
  {
unknown's avatar
unknown committed
5915
    SELECT_LEX_UNIT *unit;
5916
    lex->subqueries= TRUE;
unknown's avatar
unknown committed
5917
    /* first select_lex of subselect or derived table */
5918
    if (!(unit= new (thd->mem_root) SELECT_LEX_UNIT()))
unknown's avatar
unknown committed
5919
      DBUG_RETURN(1);
unknown's avatar
unknown committed
5920

unknown's avatar
unknown committed
5921 5922
    unit->init_query();
    unit->init_select();
5923
    unit->thd= thd;
unknown's avatar
unknown committed
5924
    unit->include_down(lex->current_select);
unknown's avatar
unknown committed
5925 5926
    unit->link_next= 0;
    unit->link_prev= 0;
5927
    unit->return_to= lex->current_select;
unknown's avatar
unknown committed
5928
    select_lex->include_down(unit);
5929 5930 5931 5932 5933
    /*
      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
5934 5935
  }
  else
unknown's avatar
unknown committed
5936
  {
unknown's avatar
VIEW  
unknown committed
5937 5938
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
unknown's avatar
unknown committed
5939
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
unknown's avatar
unknown committed
5940
      DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
5941
    }
5942
    select_lex->include_neighbour(lex->current_select);
5943 5944 5945 5946 5947
    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
5948
  }
unknown's avatar
unknown committed
5949

5950
  select_lex->master_unit()->global_parameters= select_lex;
5951
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
5952
  lex->current_select= select_lex;
5953 5954 5955 5956 5957
  /*
    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
5958
  DBUG_RETURN(0);
5959
}
unknown's avatar
unknown committed
5960

5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975
/*
  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)
{
5976
  THD *thd;
5977
  LEX *lex;
5978
  LEX_STRING tmp, null_lex_string;
5979 5980
  Item *var;
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
5981
  DBUG_ENTER("create_select_for_variable");
5982 5983

  thd= current_thd;
unknown's avatar
unknown committed
5984
  lex= thd->lex;
5985 5986 5987 5988
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
5989
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
5990 5991 5992 5993
  /*
    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
5994 5995 5996 5997 5998 5999
  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);
  }
6000 6001 6002
  DBUG_VOID_RETURN;
}

6003

unknown's avatar
unknown committed
6004 6005
void mysql_init_multi_delete(LEX *lex)
{
unknown's avatar
unknown committed
6006
  lex->sql_command=  SQLCOM_DELETE_MULTI;
unknown's avatar
unknown committed
6007
  mysql_init_select(lex);
6008 6009
  lex->select_lex.select_limit= 0;
  lex->unit.select_limit_cnt= HA_POS_ERROR;
unknown's avatar
unknown committed
6010
  lex->select_lex.table_list.save_and_clear(&lex->auxiliary_table_list);
6011
  lex->lock_option= using_update_log ? TL_READ_NO_INSERT : TL_READ;
unknown's avatar
VIEW  
unknown committed
6012 6013
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
unknown's avatar
unknown committed
6014
}
unknown's avatar
unknown committed
6015

6016 6017 6018 6019
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
6020

6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031
/**
  Parse a query.
  @param thd Current thread
  @param inBuf Begining of the query text
  @param length Length of the query text
  @param [out] semicolon For multi queries, position of the character of
  the next query in the query text.
*/

void mysql_parse(THD *thd, const char *inBuf, uint length,
                 const char ** found_semicolon)
unknown's avatar
unknown committed
6032 6033
{
  DBUG_ENTER("mysql_parse");
6034 6035 6036

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

6037 6038 6039 6040 6041 6042 6043 6044
  /*
    Warning.
    The purpose of query_cache_send_result_to_client() is to lookup the
    query in the query cache first, to avoid parsing and executing it.
    So, the natural implementation would be to:
    - first, call query_cache_send_result_to_client,
    - second, if caching failed, initialise the lexical and syntactic parser.
    The problem is that the query cache depends on a clean initialization
unknown's avatar
unknown committed
6045 6046
    of (among others) lex->safe_to_cache_query and thd->server_status,
    which are reset respectively in
6047 6048 6049 6050 6051 6052 6053 6054 6055 6056
    - lex_start()
    - mysql_reset_thd_for_next_command()
    So, initializing the lexical analyser *before* using the query cache
    is required for the cache to work properly.
    FIXME: cleanup the dependencies in the code to simplify this.
  */
  lex_start(thd);
  mysql_reset_thd_for_next_command(thd);

  if (query_cache_send_result_to_client(thd, (char*) inBuf, length) <= 0)
unknown's avatar
unknown committed
6057
  {
unknown's avatar
unknown committed
6058
    LEX *lex= thd->lex;
6059

6060 6061
    sp_cache_flush_obsolete(&thd->sp_proc_cache);
    sp_cache_flush_obsolete(&thd->sp_func_cache);
6062

unknown's avatar
unknown committed
6063 6064 6065
    Lex_input_stream lip(thd, inBuf, length);
    thd->m_lip= &lip;

6066 6067 6068 6069
    int err= MYSQLparse(thd);
    *found_semicolon= lip.found_semicolon;

    if (!err && ! thd->is_fatal_error)
unknown's avatar
unknown committed
6070
    {
unknown's avatar
unknown committed
6071
#ifndef NO_EMBEDDED_ACCESS_CHECKS
6072
      if (mqh_used && thd->user_connect &&
6073
	  check_mqh(thd, lex->sql_command))
6074 6075 6076 6077
      {
	thd->net.error = 0;
      }
      else
unknown's avatar
unknown committed
6078
#endif
6079
      {
6080
	if (! thd->net.report_error)
unknown's avatar
unknown committed
6081
	{
6082 6083 6084 6085 6086 6087 6088 6089 6090 6091
          /*
            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.
          */
6092 6093
          if (lip.found_semicolon &&
              (thd->query_length= (ulong)(lip.found_semicolon - thd->query)))
6094 6095
            thd->query_length--;
          /* Actually execute the query */
6096 6097 6098
          lex->set_trg_event_type_for_tables();
          mysql_execute_command(thd);
          query_cache_end_of_result(thd);
unknown's avatar
unknown committed
6099
	}
6100
      }
unknown's avatar
unknown committed
6101 6102
    }
    else
6103
    {
6104
      DBUG_ASSERT(thd->net.report_error);
6105
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
6106
			 thd->is_fatal_error));
6107 6108

      query_cache_abort(&thd->net);
6109
    }
6110 6111 6112 6113 6114 6115
    if (thd->lex->sphead)
    {
      delete thd->lex->sphead;
      thd->lex->sphead= 0;
    }
    lex->unit.cleanup();
unknown's avatar
unknown committed
6116
    thd->proc_info="freeing items";
6117
    thd->end_statement();
6118
    thd->cleanup_after_query();
6119
    DBUG_ASSERT(thd->change_list.is_empty());
unknown's avatar
unknown committed
6120
  }
6121 6122 6123 6124 6125 6126
  else
  {
    /* There are no multi queries in the cache. */
    *found_semicolon= NULL;
  }

unknown's avatar
unknown committed
6127 6128 6129 6130
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
6131
#ifdef HAVE_REPLICATION
6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142
/*
  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
6143
  LEX *lex= thd->lex;
6144
  bool error= 0;
unknown's avatar
unknown committed
6145
  DBUG_ENTER("mysql_test_parse_for_slave");
6146

6147 6148 6149 6150 6151 6152 6153
  Lex_input_stream lip(thd, inBuf, length);
  thd->m_lip= &lip;
  lex_start(thd);
  mysql_reset_thd_for_next_command(thd);
  int err= MYSQLparse((void*) thd);

  if (!err && ! thd->is_fatal_error &&
6154
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
unknown's avatar
unknown committed
6155
    error= 1;                  /* Ignore question */
6156
  thd->end_statement();
6157
  thd->cleanup_after_query();
unknown's avatar
unknown committed
6158
  DBUG_RETURN(error);
6159
}
unknown's avatar
unknown committed
6160
#endif
unknown's avatar
unknown committed
6161

6162

unknown's avatar
unknown committed
6163

unknown's avatar
unknown committed
6164 6165 6166 6167 6168
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

unknown's avatar
unknown committed
6169
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
unknown's avatar
unknown committed
6170
		       char *length, char *decimals,
6171
		       uint type_modifier,
6172 6173
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
6174 6175
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
unknown's avatar
unknown committed
6176
		       uint uint_geom_type)
unknown's avatar
unknown committed
6177 6178
{
  register create_field *new_field;
unknown's avatar
unknown committed
6179
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
6180 6181 6182 6183
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
6184
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
unknown's avatar
unknown committed
6185 6186 6187 6188 6189
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
unknown's avatar
unknown committed
6190 6191 6192
    lex->alter_info.key_list.push_back(new Key(Key::PRIMARY, NullS,
                                               HA_KEY_ALG_UNDEF, 0,
                                               lex->col_list));
unknown's avatar
unknown committed
6193 6194 6195 6196 6197
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
unknown's avatar
unknown committed
6198 6199 6200
    lex->alter_info.key_list.push_back(new Key(Key::UNIQUE, NullS,
                                               HA_KEY_ALG_UNDEF, 0,
                                               lex->col_list));
unknown's avatar
unknown committed
6201 6202 6203
    lex->col_list.empty();
  }

6204
  if (default_value)
unknown's avatar
unknown committed
6205
  {
6206
    /* 
unknown's avatar
unknown committed
6207 6208
      Default value should be literal => basic constants =>
      no need fix_fields()
6209 6210 6211
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
6212
    */
6213 6214 6215
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
6216
    {
6217
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
6218 6219 6220
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
unknown's avatar
unknown committed
6221
    {
6222
      default_value= 0;
6223 6224 6225
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
6226
	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
6227 6228 6229 6230 6231
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
6232
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
unknown's avatar
unknown committed
6233 6234 6235
      DBUG_RETURN(1);
    }
  }
6236 6237 6238

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
6239
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
6240 6241
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
6242

6243 6244 6245 6246 6247 6248
  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
6249
    char buf[32];
6250
    my_snprintf(buf, sizeof(buf), "TIMESTAMP(%s)", length);
6251 6252 6253
    push_warning_printf(thd,MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_WARN_DEPRECATED_SYNTAX,
                        ER(ER_WARN_DEPRECATED_SYNTAX),
unknown's avatar
unknown committed
6254
                        buf, "TIMESTAMP");
6255 6256
  }

6257 6258 6259 6260
  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
6261
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6262

unknown's avatar
unknown committed
6263
  lex->alter_info.create_list.push_back(new_field);
unknown's avatar
unknown committed
6264 6265 6266 6267
  lex->last_field=new_field;
  DBUG_RETURN(0);
}

6268

unknown's avatar
unknown committed
6269 6270 6271 6272
/* Store position for column in ALTER TABLE .. ADD column */

void store_position_for_column(const char *name)
{
6273
  current_thd->lex->last_field->after=my_const_cast(char*) (name);
unknown's avatar
unknown committed
6274 6275 6276
}

bool
unknown's avatar
unknown committed
6277
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
6278 6279 6280 6281
{
  ORDER *order;
  Item	**item_ptr;

unknown's avatar
unknown committed
6282
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
unknown's avatar
unknown committed
6283 6284 6285 6286 6287
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
unknown's avatar
unknown committed
6288
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
6289 6290 6291 6292 6293 6294 6295 6296
  return 0;
}


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

static void remove_escape(char *name)
{
6297 6298
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
6299 6300
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
6301
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
6302 6303 6304 6305 6306
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
6307 6308
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
unknown's avatar
unknown committed
6309 6310 6311 6312 6313 6314 6315 6316
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
6317
      name++;					// Skip '\\'
unknown's avatar
unknown committed
6318 6319 6320 6321 6322 6323 6324 6325 6326 6327
    *to++= *name;
  }
  *to=0;
}

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


unknown's avatar
unknown committed
6328
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
unknown's avatar
unknown committed
6329 6330 6331
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
unknown's avatar
unknown committed
6332
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
unknown's avatar
unknown committed
6333
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6334 6335
  order->item_ptr= item;
  order->item= &order->item_ptr;
unknown's avatar
unknown committed
6336 6337 6338
  order->asc = asc;
  order->free_me=0;
  order->used=0;
6339
  order->counter_used= 0;
unknown's avatar
unknown committed
6340
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
6341 6342 6343 6344
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
6345 6346 6347 6348 6349 6350 6351 6352 6353 6354
/*
  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
6355
			TL_OPTION_ALIAS	        an alias in multi table DELETE
unknown's avatar
unknown committed
6356 6357 6358 6359 6360 6361 6362 6363 6364
    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
6365 6366
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
6367
					     LEX_STRING *alias,
unknown's avatar
unknown committed
6368 6369
					     ulong table_options,
					     thr_lock_type lock_type,
6370 6371
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
unknown's avatar
unknown committed
6372
                                             LEX_STRING *option)
unknown's avatar
unknown committed
6373 6374
{
  register TABLE_LIST *ptr;
unknown's avatar
unknown committed
6375
  TABLE_LIST *previous_table_ref; /* The table preceding the current one. */
unknown's avatar
unknown committed
6376
  char *alias_str;
6377
  LEX *lex= thd->lex;
unknown's avatar
unknown committed
6378
  DBUG_ENTER("add_table_to_list");
6379
  LINT_INIT(previous_table_ref);
unknown's avatar
unknown committed
6380 6381 6382 6383

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
6384 6385
  if (!test(table_options & TL_OPTION_ALIAS) && 
      check_table_name(table->table.str, table->table.length))
unknown's avatar
unknown committed
6386
  {
6387
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
unknown's avatar
unknown committed
6388 6389 6390 6391
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
6392 6393 6394
  {
    if (table->sel)
    {
unknown's avatar
unknown committed
6395 6396
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
6397 6398
      DBUG_RETURN(0);
    }
6399
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
6400
      DBUG_RETURN(0);
6401
  }
unknown's avatar
unknown committed
6402
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
6403
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
6404
  if (table->db.str)
6405
  {
6406 6407 6408 6409 6410
    if (table->is_derived_table() == FALSE && check_db_name(table->db.str))
    {
      my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
      DBUG_RETURN(0);
    }
6411 6412 6413
    ptr->db= table->db.str;
    ptr->db_length= table->db.length;
  }
6414
  else if (lex->copy_db_to(&ptr->db, &ptr->db_length))
unknown's avatar
unknown committed
6415
    DBUG_RETURN(0);
unknown's avatar
unknown committed
6416

6417
  ptr->alias= alias_str;
6418
  if (lower_case_table_names && table->table.length)
6419
    table->table.length= my_casedn_str(files_charset_info, table->table.str);
6420 6421
  ptr->table_name=table->table.str;
  ptr->table_name_length=table->table.length;
6422
  ptr->lock_type=   lock_type;
unknown's avatar
unknown committed
6423 6424
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
6425
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
6426
  ptr->derived=	    table->sel;
6427
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
6428
                                      INFORMATION_SCHEMA_NAME.str))
6429
  {
6430
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
6431 6432
    if (!schema_table ||
        (schema_table->hidden && 
6433 6434 6435 6436 6437 6438
         (lex->orig_sql_command == SQLCOM_END ||         // not a 'show' command
          /*
            this check is used for show columns|keys from I_S hidden table
          */
          lex->orig_sql_command == SQLCOM_SHOW_FIELDS ||
          lex->orig_sql_command == SQLCOM_SHOW_KEYS)))
6439
    {
unknown's avatar
unknown committed
6440
      my_error(ER_UNKNOWN_TABLE, MYF(0),
6441
               ptr->table_name, INFORMATION_SCHEMA_NAME.str);
6442 6443
      DBUG_RETURN(0);
    }
6444
    ptr->schema_table_name= ptr->table_name;
6445 6446
    ptr->schema_table= schema_table;
  }
6447
  ptr->select_lex=  lex->current_select;
unknown's avatar
unknown committed
6448
  ptr->cacheable_table= 1;
6449 6450 6451 6452 6453 6454
  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
6455
  ptr->option= option ? option->str : 0;
unknown's avatar
unknown committed
6456
  /* check that used name is unique */
6457
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
6458
  {
unknown's avatar
unknown committed
6459 6460 6461 6462
    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
6463
	 tables ;
unknown's avatar
VIEW  
unknown committed
6464
	 tables=tables->next_local)
unknown's avatar
unknown committed
6465
    {
6466 6467
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
6468
      {
6469
	my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
unknown's avatar
unknown committed
6470 6471
	DBUG_RETURN(0);				/* purecov: tested */
      }
unknown's avatar
unknown committed
6472 6473
    }
  }
unknown's avatar
unknown committed
6474 6475 6476
  /* Store the table reference preceding the current one. */
  if (table_list.elements > 0)
  {
6477 6478 6479
    /*
      table_list.next points to the last inserted TABLE_LIST->next_local'
      element
6480
      We don't use the offsetof() macro here to avoid warnings from gcc
6481
    */
6482 6483 6484
    previous_table_ref= (TABLE_LIST*) ((char*) table_list.next -
                                       ((char*) &(ptr->next_local) -
                                        (char*) ptr));
6485 6486 6487 6488 6489 6490 6491 6492
    /*
      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
6493
  }
6494

unknown's avatar
unknown committed
6495 6496 6497 6498 6499 6500
  /*
    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
6501
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
unknown's avatar
unknown committed
6502
  ptr->next_name_resolution_table= NULL;
6503
  /* Link table in global list (all used tables) */
6504
  lex->add_to_query_tables(ptr);
unknown's avatar
unknown committed
6505 6506 6507
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
6508

6509 6510 6511 6512
/*
  Initialize a new table list for a nested join

  SYNOPSIS
unknown's avatar
unknown committed
6513
    init_nested_join()
6514
    thd         current thread
6515

6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534
  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");
6535

6536 6537
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6538
    DBUG_RETURN(1);
6539 6540 6541
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561
  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
6562
    moves it one level up, eliminating the nest.
6563 6564 6565 6566 6567 6568 6569 6570 6571

  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;
6572
  NESTED_JOIN *nested_join;
6573
  DBUG_ENTER("end_nested_join");
6574

unknown's avatar
unknown committed
6575
  DBUG_ASSERT(embedding);
6576 6577 6578
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
6579
  nested_join= ptr->nested_join;
6580 6581 6582 6583 6584 6585 6586 6587 6588
  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;
  }
6589
  else if (nested_join->join_list.elements == 0)
unknown's avatar
unknown committed
6590 6591
  {
    join_list->pop();
6592
    ptr= 0;                                     // return value
unknown's avatar
unknown committed
6593
  }
6594 6595 6596 6597 6598 6599 6600 6601
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
6602
    nest_last_join()
6603 6604 6605 6606 6607 6608
    thd         current thread

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

  RETURN VALUE
6609 6610 6611
    0  Error
    #  Pointer to TABLE_LIST element created for the new nested join

6612 6613 6614 6615 6616 6617
*/

TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
6618
  List<TABLE_LIST> *embedded_list;
6619
  DBUG_ENTER("nest_last_join");
6620

6621 6622
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6623
    DBUG_RETURN(0);
6624 6625 6626
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6627 6628
  ptr->embedding= embedding;
  ptr->join_list= join_list;
6629
  embedded_list= &nested_join->join_list;
6630
  embedded_list->empty();
6631 6632

  for (uint i=0; i < 2; i++)
6633 6634 6635 6636 6637
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
unknown's avatar
unknown committed
6638 6639 6640 6641 6642 6643 6644
    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.
      */
6645 6646
      if (prev_join_using)
        ptr->join_using_fields= prev_join_using;
unknown's avatar
unknown committed
6647
    }
6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687
  }
  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
6688 6689 6690

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713
    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
*/

6714
TABLE_LIST *st_select_lex::convert_right_join()
6715 6716
{
  TABLE_LIST *tab2= join_list->pop();
6717
  TABLE_LIST *tab1= join_list->pop();
6718 6719 6720 6721 6722 6723 6724 6725 6726
  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
6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739
/*
  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
6740
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
unknown's avatar
unknown committed
6741 6742 6743 6744 6745 6746
{
  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
6747 6748 6749
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
unknown's avatar
unknown committed
6750 6751 6752 6753 6754 6755 6756
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
6757

unknown's avatar
unknown committed
6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781
/*
  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
*/

6782
bool st_select_lex_unit::add_fake_select_lex(THD *thd_arg)
unknown's avatar
unknown committed
6783 6784 6785 6786
{
  SELECT_LEX *first_sl= first_select();
  DBUG_ENTER("add_fake_select_lex");
  DBUG_ASSERT(!fake_select_lex);
unknown's avatar
unknown committed
6787

6788
  if (!(fake_select_lex= new (thd_arg->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
6789 6790 6791 6792
      DBUG_RETURN(1);
  fake_select_lex->include_standalone(this, 
                                      (SELECT_LEX_NODE**)&fake_select_lex);
  fake_select_lex->select_number= INT_MAX;
6793
  fake_select_lex->parent_lex= thd_arg->lex; /* Used in init_query. */
unknown's avatar
unknown committed
6794 6795
  fake_select_lex->make_empty_select();
  fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
6796 6797
  fake_select_lex->select_limit= 0;

unknown's avatar
unknown committed
6798
  fake_select_lex->context.outer_context=first_sl->context.outer_context;
6799 6800 6801
  /* 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
6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812

  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;
6813
    thd_arg->lex->current_select= fake_select_lex;
unknown's avatar
unknown committed
6814
  }
6815
  thd_arg->lex->pop_context();
unknown's avatar
unknown committed
6816 6817 6818
  DBUG_RETURN(0);
}

6819

unknown's avatar
unknown committed
6820
/*
6821 6822
  Push a new name resolution context for a JOIN ... ON clause to the
  context stack of a query block.
unknown's avatar
unknown committed
6823 6824

  SYNOPSIS
6825
    push_new_name_resolution_context()
unknown's avatar
unknown committed
6826
    thd       pointer to current thread
unknown's avatar
unknown committed
6827
    left_op   left  operand of the JOIN
unknown's avatar
unknown committed
6828 6829 6830 6831
    right_op  rigth operand of the JOIN

  DESCRIPTION
    Create a new name resolution context for a JOIN ... ON clause,
6832 6833 6834
    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
6835 6836

  RETURN
6837 6838
    FALSE  if all is OK
    TRUE   if a memory allocation error occured
unknown's avatar
unknown committed
6839 6840
*/

6841 6842 6843
bool
push_new_name_resolution_context(THD *thd,
                                 TABLE_LIST *left_op, TABLE_LIST *right_op)
unknown's avatar
unknown committed
6844 6845
{
  Name_resolution_context *on_context;
6846
  if (!(on_context= new (thd->mem_root) Name_resolution_context))
6847
    return TRUE;
unknown's avatar
unknown committed
6848 6849 6850 6851 6852
  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();
6853
  return thd->lex->push_context(on_context);
unknown's avatar
unknown committed
6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873
}


/*
  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
6874
{
6875
  if (expr)
6876
  {
6877
    if (!b->on_expr)
unknown's avatar
unknown committed
6878
      b->on_expr= expr;
6879 6880
    else
    {
unknown's avatar
unknown committed
6881 6882 6883 6884 6885 6886
      /*
        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);
6887 6888
    }
    b->on_expr->top_level_item();
6889
  }
unknown's avatar
unknown committed
6890 6891 6892
}


6893
/*
unknown's avatar
unknown committed
6894 6895
  Mark that there is a NATURAL JOIN or JOIN ... USING between two
  tables.
6896 6897 6898

  SYNOPSIS
    add_join_natural()
unknown's avatar
unknown committed
6899 6900 6901
    a			Left join argument
    b			Right join argument
    using_fields        Field names from USING clause
6902
    lex                 The current st_select_lex
unknown's avatar
unknown committed
6903
  
6904
  IMPLEMENTATION
unknown's avatar
unknown committed
6905 6906 6907 6908 6909 6910 6911 6912 6913 6914
    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
6915 6916 6917
    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
6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928

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

6931 6932
void add_join_natural(TABLE_LIST *a, TABLE_LIST *b, List<String> *using_fields,
                      SELECT_LEX *lex)
unknown's avatar
unknown committed
6933
{
unknown's avatar
unknown committed
6934
  b->natural_join= a;
6935
  lex->prev_join_using= using_fields;
unknown's avatar
unknown committed
6936 6937
}

unknown's avatar
unknown committed
6938

6939
/*
6940 6941 6942 6943
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
6944
    thd			Thread handler (can be NULL!)
6945 6946 6947 6948 6949
    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
6950 6951 6952
                        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.
6953 6954 6955

  RETURN
    0	 ok
unknown's avatar
unknown committed
6956
    !=0  error.  thd->killed or thd->net.report_error is set
6957 6958
*/

6959 6960
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
unknown's avatar
unknown committed
6961 6962 6963
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
6964
  bool tmp_write_to_binlog= 1;
6965

6966
  DBUG_ASSERT(!thd || !thd->in_sub_stmt);
6967

unknown's avatar
SCRUM  
unknown committed
6968
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
6969 6970
  if (options & REFRESH_GRANT)
  {
6971 6972 6973 6974 6975 6976
    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)))
6977 6978
    {
      thd->thread_stack= (char*) &tmp_thd;
6979
      thd->store_globals();
6980
    }
6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992
    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;
    }
6993
    reset_mqh((LEX_USER *)NULL, TRUE);
unknown's avatar
unknown committed
6994
  }
unknown's avatar
SCRUM  
unknown committed
6995
#endif
unknown's avatar
unknown committed
6996 6997
  if (options & REFRESH_LOG)
  {
6998
    /*
unknown's avatar
unknown committed
6999 7000
      Flush the normal query log, the update log, the binary log,
      the slow query log, and the relay log (if it exists).
7001
    */
unknown's avatar
unknown committed
7002

7003
    /*
unknown's avatar
unknown committed
7004 7005 7006 7007
      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)
7008 7009
    */
    tmp_write_to_binlog= 0;
unknown's avatar
unknown committed
7010 7011
    mysql_log.new_file(1);
    mysql_slow_log.new_file(1);
7012 7013 7014 7015
    if( mysql_bin_log.is_open() )
    {
      mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
    }
unknown's avatar
unknown committed
7016
#ifdef HAVE_REPLICATION
7017
    pthread_mutex_lock(&LOCK_active_mi);
7018
    rotate_relay_log(active_mi);
7019
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
7020
#endif
unknown's avatar
unknown committed
7021 7022
    if (ha_flush_logs())
      result=1;
unknown's avatar
unknown committed
7023 7024
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
7025
  }
unknown's avatar
unknown committed
7026
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
7027 7028
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
7029
    query_cache.pack();				// FLUSH QUERY CACHE
7030
    options &= ~REFRESH_QUERY_CACHE;    // Don't flush cache, just free memory
unknown's avatar
unknown committed
7031 7032 7033
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
7034
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
7035
  }
unknown's avatar
unknown committed
7036
#endif /*HAVE_QUERY_CACHE*/
7037 7038 7039 7040 7041
  /*
    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
7042
  {
7043
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
7044
    {
7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055
      /*
        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
7056
        {
7057
          if ((*lock_p)->type >= TL_WRITE_ALLOW_WRITE)
7058 7059 7060 7061
          {
            my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
            return 1;
          }
unknown's avatar
unknown committed
7062
        }
7063
      }
unknown's avatar
unknown committed
7064 7065 7066 7067
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
7068
      tmp_write_to_binlog= 0;
7069
      if (lock_global_read_lock(thd))
unknown's avatar
unknown committed
7070
	return 1;                               // Killed
7071 7072
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
unknown's avatar
unknown committed
7073
      if (make_global_read_lock_block_commit(thd)) // Killed
7074 7075 7076 7077 7078
      {
        /* Don't leave things in a half-locked state */
        unlock_global_read_lock(thd);
        return 1;
      }
unknown's avatar
unknown committed
7079
    }
7080 7081
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
7082
    my_dbopt_cleanup();
unknown's avatar
unknown committed
7083 7084 7085
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
unknown's avatar
unknown committed
7086
  if (thd && (options & REFRESH_STATUS))
unknown's avatar
unknown committed
7087
    refresh_status(thd);
unknown's avatar
unknown committed
7088 7089
  if (options & REFRESH_THREADS)
    flush_thread_cache();
unknown's avatar
unknown committed
7090
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
7091
  if (options & REFRESH_MASTER)
7092
  {
7093
    DBUG_ASSERT(thd);
7094
    tmp_write_to_binlog= 0;
7095
    if (reset_master(thd))
unknown's avatar
unknown committed
7096
    {
7097
      result=1;
unknown's avatar
unknown committed
7098 7099
      thd->fatal_error();                       // Ensure client get error
    }
7100
  }
7101
#endif
unknown's avatar
unknown committed
7102
#ifdef OPENSSL
7103 7104 7105 7106 7107 7108
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
unknown's avatar
unknown committed
7109
#ifdef HAVE_REPLICATION
7110 7111
 if (options & REFRESH_SLAVE)
 {
7112
   tmp_write_to_binlog= 0;
7113
   pthread_mutex_lock(&LOCK_active_mi);
7114
   if (reset_slave(thd, active_mi))
7115
     result=1;
7116
   pthread_mutex_unlock(&LOCK_active_mi);
7117
 }
7118
#endif
7119
 if (options & REFRESH_USER_RESOURCES)
unknown's avatar
unknown committed
7120
   reset_mqh((LEX_USER *) NULL);
unknown's avatar
unknown committed
7121
 *write_to_binlog= tmp_write_to_binlog;
7122
 return result;
unknown's avatar
unknown committed
7123 7124
}

7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136
/*
  kill on thread

  SYNOPSIS
    kill_one_thread()
    thd			Thread class
    id			Thread id

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

unknown's avatar
SCRUM  
unknown committed
7137
void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
unknown's avatar
unknown committed
7138 7139 7140
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
7141 7142
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
7143 7144 7145 7146
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
7147 7148
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
7149 7150 7151
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
7152 7153
  if (tmp)
  {
7154 7155
    if ((thd->security_ctx->master_access & SUPER_ACL) ||
	!strcmp(thd->security_ctx->user, tmp->security_ctx->user))
7156
    {
unknown's avatar
SCRUM  
unknown committed
7157
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
7158 7159 7160 7161 7162 7163 7164
      error=0;
    }
    else
      error=ER_KILL_DENIED_ERROR;
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }

unknown's avatar
unknown committed
7165
  if (!error)
7166
    send_ok(thd);
unknown's avatar
unknown committed
7167
  else
unknown's avatar
unknown committed
7168
    my_error(error, MYF(0), id);
unknown's avatar
unknown committed
7169 7170
}

unknown's avatar
unknown committed
7171

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

unknown's avatar
unknown committed
7174 7175
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name)
7176
{
7177
  char buff[FN_REFLEN],*ptr, *end;
7178 7179 7180 7181 7182 7183 7184
  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))
  {
7185
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
7186 7187 7188 7189
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
7190
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
7191
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
7192 7193
    return 1;					// End of memory
  *filename_ptr=ptr;
7194
  strxmov(ptr,buff,table_name,NullS);
7195 7196
  return 0;
}
7197

7198

7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212
/*
  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;
7213 7214
  LEX *lex= thd->lex;
  if (lex->current_select != &lex->select_lex)
7215 7216
  {
    char command[80];
7217 7218 7219
    Lex_input_stream *lip= thd->m_lip;
    strmake(command, lip->yylval->symbol.str,
	    min(lip->yylval->symbol.length, sizeof(command)-1));
7220
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
7221 7222 7223 7224
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
7225

unknown's avatar
unknown committed
7226

unknown's avatar
unknown committed
7227
Comp_creator *comp_eq_creator(bool invert)
unknown's avatar
unknown committed
7228
{
unknown's avatar
unknown committed
7229
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
unknown's avatar
unknown committed
7230 7231
}

unknown's avatar
unknown committed
7232

unknown's avatar
unknown committed
7233
Comp_creator *comp_ge_creator(bool invert)
unknown's avatar
unknown committed
7234
{
unknown's avatar
unknown committed
7235
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
unknown's avatar
unknown committed
7236 7237
}

unknown's avatar
unknown committed
7238

unknown's avatar
unknown committed
7239
Comp_creator *comp_gt_creator(bool invert)
unknown's avatar
unknown committed
7240
{
unknown's avatar
unknown committed
7241
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
unknown's avatar
unknown committed
7242 7243
}

unknown's avatar
unknown committed
7244

unknown's avatar
unknown committed
7245
Comp_creator *comp_le_creator(bool invert)
unknown's avatar
unknown committed
7246
{
unknown's avatar
unknown committed
7247
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
unknown's avatar
unknown committed
7248 7249
}

unknown's avatar
unknown committed
7250

unknown's avatar
unknown committed
7251
Comp_creator *comp_lt_creator(bool invert)
unknown's avatar
unknown committed
7252
{
unknown's avatar
unknown committed
7253
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
unknown's avatar
unknown committed
7254 7255
}

unknown's avatar
unknown committed
7256

unknown's avatar
unknown committed
7257
Comp_creator *comp_ne_creator(bool invert)
unknown's avatar
unknown committed
7258
{
unknown's avatar
unknown committed
7259
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
unknown's avatar
unknown committed
7260
}
unknown's avatar
unknown committed
7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280


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

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

  Item_allany_subselect *it=
7288
    new Item_allany_subselect(left_expr, cmp, select_lex, all);
unknown's avatar
unknown committed
7289
  if (all)
7290
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
unknown's avatar
unknown committed
7291

7292
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
unknown's avatar
unknown committed
7293
}
7294 7295 7296 7297 7298 7299 7300


/*
  Multi update query pre-check

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

unknown's avatar
unknown committed
7304
  RETURN VALUE
unknown's avatar
unknown committed
7305 7306
    FALSE OK
    TRUE  Error
7307
*/
unknown's avatar
unknown committed
7308

unknown's avatar
unknown committed
7309
bool multi_update_precheck(THD *thd, TABLE_LIST *tables)
7310 7311 7312 7313 7314
{
  const char *msg= 0;
  TABLE_LIST *table;
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
7315
  DBUG_ENTER("multi_update_precheck");
7316 7317 7318

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
7319
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7320
    DBUG_RETURN(TRUE);
7321 7322 7323 7324 7325
  }
  /*
    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
7326
  for (table= tables; table; table= table->next_local)
7327
  {
7328 7329 7330
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
7331 7332
                           &table->grant.privilege, 0, 1,
                           test(table->schema_table)) ||
7333 7334
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
unknown's avatar
unknown committed
7335
             (check_access(thd, SELECT_ACL, table->db,
7336 7337
                           &table->grant.privilege, 0, 0,
                           test(table->schema_table)) ||
unknown's avatar
unknown committed
7338
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
unknown's avatar
unknown committed
7339
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7340

unknown's avatar
VIEW  
unknown committed
7341
    table->table_in_first_from_clause= 1;
7342
  }
unknown's avatar
unknown committed
7343 7344 7345
  /*
    Is there tables of subqueries?
  */
7346
  if (&lex->select_lex != lex->all_selects_list || lex->time_zone_tables_used)
7347
  {
7348
    DBUG_PRINT("info",("Checking sub query list"));
unknown's avatar
VIEW  
unknown committed
7349
    for (table= tables; table; table= table->next_global)
7350
    {
unknown's avatar
unknown committed
7351 7352 7353
      if (!my_tz_check_n_skip_implicit_tables(&table,
                                              lex->time_zone_tables_used) &&
          !table->table_in_first_from_clause)
7354 7355
      {
	if (check_access(thd, SELECT_ACL, table->db,
7356 7357
			 &table->grant.privilege, 0, 0,
                         test(table->schema_table)) ||
unknown's avatar
unknown committed
7358
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
unknown's avatar
unknown committed
7359
	  DBUG_RETURN(TRUE);
7360 7361 7362 7363 7364 7365
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
7366
  else if (select_lex->select_limit)
7367 7368 7369 7370
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
unknown's avatar
unknown committed
7371
    DBUG_RETURN(TRUE);
7372
  }
unknown's avatar
unknown committed
7373
  DBUG_RETURN(FALSE);
7374 7375 7376 7377 7378 7379 7380
}

/*
  Multi delete query pre-check

  SYNOPSIS
    multi_delete_precheck()
unknown's avatar
unknown committed
7381
    thd			Thread handler
unknown's avatar
VIEW  
unknown committed
7382
    tables		Global/local table list
7383

unknown's avatar
unknown committed
7384
  RETURN VALUE
unknown's avatar
unknown committed
7385 7386
    FALSE OK
    TRUE  error
7387
*/
unknown's avatar
unknown committed
7388

7389
bool multi_delete_precheck(THD *thd, TABLE_LIST *tables)
7390 7391 7392
{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  TABLE_LIST *aux_tables=
unknown's avatar
unknown committed
7393
    (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
7394
  TABLE_LIST **save_query_tables_own_last= thd->lex->query_tables_own_last;
unknown's avatar
VIEW  
unknown committed
7395
  DBUG_ENTER("multi_delete_precheck");
unknown's avatar
unknown committed
7396

7397 7398 7399
  /* 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) ||
7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411
      check_table_access(thd, SELECT_ACL, tables, 0))
    DBUG_RETURN(TRUE);

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

7416 7417
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
unknown's avatar
unknown committed
7418 7419
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
unknown's avatar
unknown committed
7420
    DBUG_RETURN(TRUE);
7421
  }
7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446
  DBUG_RETURN(FALSE);
}


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

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

  RETURN VALUE
    FALSE - success
    TRUE  - error
*/

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

  lex->table_count= 0;

unknown's avatar
unknown committed
7447
  for (target_tbl= (TABLE_LIST *)lex->auxiliary_table_list.first;
7448
       target_tbl; target_tbl= target_tbl->next_local)
7449
  {
7450
    lex->table_count++;
7451 7452
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
unknown's avatar
VIEW  
unknown committed
7453
    for (walk= tables; walk; walk= walk->next_local)
7454
    {
unknown's avatar
unknown committed
7455 7456 7457
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
7458 7459 7460 7461
	break;
    }
    if (!walk)
    {
7462
      my_error(ER_UNKNOWN_TABLE, MYF(0),
7463
               target_tbl->table_name, "MULTI DELETE");
unknown's avatar
unknown committed
7464
      DBUG_RETURN(TRUE);
7465
    }
unknown's avatar
unknown committed
7466 7467 7468 7469 7470
    if (!walk->derived)
    {
      target_tbl->table_name= walk->table_name;
      target_tbl->table_name_length= walk->table_name_length;
    }
unknown's avatar
unknown committed
7471
    walk->updating= target_tbl->updating;
unknown's avatar
unknown committed
7472
    walk->lock_type= target_tbl->lock_type;
unknown's avatar
VIEW  
unknown committed
7473
    target_tbl->correspondent_table= walk;	// Remember corresponding table
7474
  }
unknown's avatar
unknown committed
7475
  DBUG_RETURN(FALSE);
7476 7477 7478
}


unknown's avatar
unknown committed
7479 7480 7481 7482 7483
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
unknown's avatar
unknown committed
7484 7485
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7486 7487

  RETURN VALUE
unknown's avatar
unknown committed
7488 7489
    FALSE OK
    TRUE  Error
unknown's avatar
unknown committed
7490
*/
unknown's avatar
unknown committed
7491

unknown's avatar
unknown committed
7492
bool update_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7493 7494 7495 7496
{
  DBUG_ENTER("update_precheck");
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
  {
unknown's avatar
unknown committed
7497
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7498
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7499
  }
unknown's avatar
unknown committed
7500 7501
  DBUG_RETURN(check_db_used(thd, tables) ||
	       check_one_table_access(thd, UPDATE_ACL, tables));
unknown's avatar
unknown committed
7502 7503 7504 7505 7506 7507 7508 7509
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
unknown's avatar
unknown committed
7510 7511
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7512 7513

  RETURN VALUE
unknown's avatar
unknown committed
7514 7515
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
7516
*/
unknown's avatar
unknown committed
7517

unknown's avatar
unknown committed
7518
bool delete_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7519 7520 7521
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
unknown's avatar
unknown committed
7522
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7523
  /* Set privilege for the WHERE clause */
unknown's avatar
unknown committed
7524
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
unknown's avatar
unknown committed
7525
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
7526 7527 7528 7529 7530 7531 7532 7533
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
unknown's avatar
unknown committed
7534 7535
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
7536 7537

  RETURN VALUE
unknown's avatar
unknown committed
7538 7539
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
7540
*/
unknown's avatar
unknown committed
7541

unknown's avatar
merge  
unknown committed
7542
bool insert_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
7543 7544 7545 7546
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

unknown's avatar
unknown committed
7547 7548 7549 7550
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
unknown's avatar
unknown committed
7551 7552 7553
  ulong privilege= (INSERT_ACL |
                    (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                    (lex->value_list.elements ? UPDATE_ACL : 0));
unknown's avatar
unknown committed
7554 7555

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

unknown's avatar
unknown committed
7558
  if (lex->update_list.elements != lex->value_list.elements)
unknown's avatar
unknown committed
7559
  {
unknown's avatar
unknown committed
7560
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
7561
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7562
  }
unknown's avatar
unknown committed
7563 7564
  if (check_db_used(thd, tables))
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
7565
  DBUG_RETURN(FALSE);
7566
}
unknown's avatar
unknown committed
7567 7568


unknown's avatar
unknown committed
7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587
/**
   @brief  Check privileges for SHOW CREATE TABLE statement.

   @param  thd    Thread context
   @param  table  Target table

   @retval TRUE  Failure
   @retval FALSE Success
*/

static bool check_show_create_table_access(THD *thd, TABLE_LIST *table)
{
  return check_access(thd, SELECT_ACL | EXTRA_ACL, table->db,
                      &table->grant.privilege, 0, 0,
                      test(table->schema_table)) ||
         grant_option && check_grant(thd, SELECT_ACL, table, 2, UINT_MAX, 0);
}


unknown's avatar
unknown committed
7588 7589 7590 7591 7592
/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
unknown's avatar
unknown committed
7593 7594 7595
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
unknown's avatar
unknown committed
7596 7597

  RETURN VALUE
unknown's avatar
unknown committed
7598 7599
    FALSE   OK
    TRUE   Error
unknown's avatar
unknown committed
7600
*/
unknown's avatar
unknown committed
7601

unknown's avatar
unknown committed
7602 7603
bool create_table_precheck(THD *thd, TABLE_LIST *tables,
                           TABLE_LIST *create_table)
unknown's avatar
unknown committed
7604 7605
{
  LEX *lex= thd->lex;
7606 7607
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
unknown's avatar
merge  
unknown committed
7608
  bool error= TRUE;                                 // Error message is given
unknown's avatar
unknown committed
7609
  DBUG_ENTER("create_table_precheck");
7610 7611 7612

  want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
              CREATE_TMP_ACL : CREATE_ACL);
unknown's avatar
unknown committed
7613
  if (check_access(thd, want_priv, create_table->db,
7614 7615
		   &create_table->grant.privilege, 0, 0,
                   test(create_table->schema_table)) ||
unknown's avatar
unknown committed
7616 7617 7618
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
7619 7620
    goto err;
  if (grant_option && want_priv != CREATE_TMP_ACL &&
7621
      check_grant(thd, want_priv, create_table, 0, 1, 0))
7622 7623 7624 7625 7626 7627
    goto err;

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

7628 7629
#ifdef NOT_NECESSARY_TO_CHECK_CREATE_TABLE_EXIST_WHEN_PREPARING_STATEMENT
    /* This code throws an ill error for CREATE TABLE t1 SELECT * FROM t1 */
7630
    /*
unknown's avatar
unknown committed
7631 7632 7633
      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).
7634
    */
unknown's avatar
unknown committed
7635
    if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
7636
    {
unknown's avatar
unknown committed
7637 7638 7639 7640
      /*
        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
7641
          find_table_in_global_list(tables, create_table->db,
7642
                                    create_table->table_name))
unknown's avatar
unknown committed
7643
      {
7644
	error= FALSE;
unknown's avatar
unknown committed
7645 7646 7647
        goto err;
      }
    }
7648
#endif
7649 7650 7651
    if (tables && check_table_access(thd, SELECT_ACL, tables,0))
      goto err;
  }
unknown's avatar
unknown committed
7652 7653 7654 7655 7656
  else if (lex->create_info.options & HA_LEX_CREATE_TABLE_LIKE)
  {
    if (check_show_create_table_access(thd, tables))
      goto err;
  }
unknown's avatar
merge  
unknown committed
7657
  error= FALSE;
7658 7659 7660

err:
  DBUG_RETURN(error);
unknown's avatar
unknown committed
7661
}
unknown's avatar
unknown committed
7662 7663 7664 7665 7666 7667 7668


/*
  negate given expression

  SYNOPSIS
    negate_expression()
7669
    thd  thread handler
unknown's avatar
unknown committed
7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697
    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);
}
7698

7699 7700
/*
  Set the specified definer to the default value, which is the current user in
7701
  the thread.
7702 7703 7704 7705 7706 7707 7708
 
  SYNOPSIS
    get_default_definer()
    thd       [in] thread handler
    definer   [out] definer
*/
 
7709
void get_default_definer(THD *thd, LEX_USER *definer)
7710 7711 7712 7713 7714 7715 7716 7717 7718 7719
{
  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);
}

7720

7721
/*
7722
  Create default definer for the specified THD.
7723 7724 7725 7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736 7737 7738 7739 7740

  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;

7741
  get_default_definer(thd, definer);
7742 7743 7744 7745 7746

  return definer;
}


7747
/*
7748
  Create definer with the given user and host names.
7749 7750

  SYNOPSIS
7751 7752 7753 7754
    create_definer()
    thd         [in] thread handler
    user_name   [in] user name
    host_name   [in] host name
7755 7756

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

7762
LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name)
7763
{
7764 7765 7766 7767
  LEX_USER *definer;

  /* Create and initialize. */

unknown's avatar
unknown committed
7768
  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
7769 7770 7771 7772 7773 7774
    return 0;

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

  return definer;
7775
}
7776 7777 7778 7779 7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794


/*
  Retuns information about user or current user.

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

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

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

7797 7798
  return user;
}
7799 7800 7801 7802 7803 7804 7805 7806 7807 7808 7809 7810 7811 7812 7813 7814


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

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

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

unknown's avatar
unknown committed
7815 7816
bool check_string_length(LEX_STRING *str, const char *err_msg,
                         uint max_length)
7817
{
unknown's avatar
unknown committed
7818 7819
  if (str->length <= max_length)
    return FALSE;
7820 7821

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

7823 7824
  return TRUE;
}