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

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

125

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

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

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


196 197 198 199 200 201 202 203 204 205 206 207
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;
}

208
#ifndef NO_EMBEDDED_ACCESS_CHECKS
209 210
static HASH hash_user_connections;

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

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

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

259
}
260
#endif /* !NO_EMBEDDED_ACCESS_CHECKS */
261 262 263


/*
264 265
  Check if user exist and password supplied is correct. 

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

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

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

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

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

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

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

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

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

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

421
      /*
422 423 424
        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.
425
      */
426
      thd->main_security_ctx.db_access=0;
unknown's avatar
unknown committed
427 428

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

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

unknown's avatar
unknown committed
481
/*
unknown's avatar
unknown committed
482 483
  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
484 485
*/

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

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

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


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

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

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

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

unknown's avatar
unknown committed
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
/*
  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.
*/

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

601 602
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

603

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

unknown's avatar
unknown committed
611

612

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

  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
619 620 621 622 623 624

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

unknown's avatar
unknown committed
627
char  uc_update_queries[SQLCOM_END+1];
628 629 630

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

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

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

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

667 668 669 670
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
unknown's avatar
unknown committed
671

672 673 674 675
  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.
*/
676

677 678
#ifndef NO_EMBEDDED_ACCESS_CHECKS

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

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

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

738 739
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

unknown's avatar
unknown committed
740

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

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

781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
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
812
/*
813
    Perform handshake, authorize client and update thd ACL variables.
814
  SYNOPSIS
815
    check_connection()
816
    thd  thread handle
817 818

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

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

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

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

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

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

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

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

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

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

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

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

  /*
unknown's avatar
unknown committed
1009 1010 1011
    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'.
1012 1013 1014

    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
1015
  */
1016
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
1017
    (uchar)(*passwd++) : strlen(passwd);
unknown's avatar
unknown committed
1018 1019
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
unknown's avatar
unknown committed
1020 1021
  uint db_len= db ? strlen(db) : 0;

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

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

1038 1039 1040
  user_buff[user_len= copy_and_convert(user_buff, sizeof(user_buff)-1,
                                       system_charset_info, user, user_len,
                                       thd->charset(), &dummy_errors)]= '\0';
1041
  user= user_buff;
unknown's avatar
unknown committed
1042

1043 1044 1045 1046 1047 1048 1049 1050
  /* 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;
  }

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

1058

1059 1060
void execute_init_command(THD *thd, sys_var_str *init_command_var,
			  rw_lock_t *var_mutex)
unknown's avatar
unknown committed
1061 1062 1063 1064
{
  Vio* save_vio;
  ulong save_client_capabilities;

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


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

  pthread_detach_this_thread();

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

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

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

  do
  {
    int error;
    NET *net= &thd->net;
1142
    Security_context *sctx= thd->security_ctx;
1143
    net->no_send_error= 0;
unknown's avatar
unknown committed
1144

1145
    /* Use "connect_timeout" value during connection phase */
1146 1147
    my_net_set_read_timeout(net, connect_timeout);
    my_net_set_write_timeout(net, connect_timeout);
1148

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

unknown's avatar
unknown committed
1168
    thd->version= refresh_version;
1169
    thd->proc_info= 0;
1170
    thd->command= COM_SLEEP;
1171
    thd->init_for_queries();
unknown's avatar
unknown committed
1172

1173
    if (sys_init_connect.value_length && !(sctx->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1174
    {
1175 1176
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
1177
      {
unknown's avatar
unknown committed
1178
	thd->killed= THD::KILL_CONNECTION;
1179 1180 1181 1182 1183 1184
        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);
      }
1185 1186
      thd->proc_info=0;
      thd->init_for_queries();
unknown's avatar
unknown committed
1187 1188
    }

1189
    /* Connect completed, set read/write timeouts back to tdefault */
1190 1191
    my_net_set_read_timeout(net, thd->variables.net_read_timeout);
    my_net_set_write_timeout(net, thd->variables.net_write_timeout);
1192

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

1235 1236 1237 1238
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
1239

1240
pthread_handler_t handle_bootstrap(void *arg)
unknown's avatar
unknown committed
1241
{
1242 1243 1244
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
1245
  const char* found_semicolon= NULL;
unknown's avatar
unknown committed
1246

1247
  /* The following must be called before DBUG_ENTER */
1248
  thd->thread_stack= (char*) &thd;
1249
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
1250
  {
unknown's avatar
unknown committed
1251
#ifndef EMBEDDED_LIBRARY
1252
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
1253
#endif
1254
    thd->fatal_error();
1255
    goto end;
unknown's avatar
unknown committed
1256
  }
1257 1258
  DBUG_ENTER("handle_bootstrap");

unknown's avatar
unknown committed
1259
#ifndef EMBEDDED_LIBRARY
1260 1261
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1262
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1263
  sigset_t set;
1264 1265
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
1266
#endif
unknown's avatar
unknown committed
1267
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1268

1269
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1270 1271 1272 1273
    thd->options |= OPTION_BIG_SELECTS;

  thd->proc_info=0;
  thd->version=refresh_version;
1274 1275
  thd->security_ctx->priv_user=
    thd->security_ctx->user= (char*) my_strdup("boot", MYF(MY_WME));
1276 1277 1278 1279 1280 1281
  /*
    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
1282

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

1325
    if (thd->is_fatal_error)
1326
      break;
1327 1328 1329 1330 1331 1332 1333 1334 1335

    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
1336
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1337
#ifdef USING_TRANSACTIONS
1338
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
1339
#endif
unknown's avatar
unknown committed
1340
  }
1341 1342

end:
1343
  /* Remember the exit code of bootstrap */
1344 1345 1346 1347 1348 1349
  bootstrap_error= thd->is_fatal_error;

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

unknown's avatar
unknown committed
1350
#ifndef EMBEDDED_LIBRARY
1351 1352 1353
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1354
  (void) pthread_cond_broadcast(&COND_thread_count);
1355 1356
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1357
#endif
1358
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1359 1360 1361
}


1362 1363 1364 1365
    /* This works because items are allocated with sql_alloc() */

void cleanup_items(Item *item)
{
unknown's avatar
unknown committed
1366
  DBUG_ENTER("cleanup_items");  
1367 1368
  for (; item ; item=item->next)
    item->cleanup();
unknown's avatar
unknown committed
1369
  DBUG_VOID_RETURN;
1370 1371
}

unknown's avatar
unknown committed
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
/*
  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
1392 1393 1394 1395 1396 1397
{
  TABLE* table;
  TABLE_LIST* table_list;
  int error = 0;
  DBUG_ENTER("mysql_table_dump");
  db = (db && db[0]) ? db : thd->db;
1398
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1399
    DBUG_RETURN(1); // out of memory
unknown's avatar
VIEW  
unknown committed
1400
  table_list->db= db;
1401
  table_list->table_name= table_list->alias= tbl_name;
unknown's avatar
VIEW  
unknown committed
1402 1403
  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
1404

1405 1406
  if (!db || check_db_name(db))
  {
1407
    my_error(ER_WRONG_DB_NAME ,MYF(0), db ? db : "NULL");
1408 1409
    goto err;
  }
1410
  if (lower_case_table_names)
1411
    my_casedn_str(files_charset_info, tbl_name);
1412
  remove_escape(table_list->table_name);
1413 1414 1415 1416

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

unknown's avatar
unknown committed
1417
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1418 1419
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1420
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1421
  thd->query = tbl_name;
unknown's avatar
unknown committed
1422
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1423
  {
1424
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1425 1426
    goto err;
  }
unknown's avatar
unknown committed
1427
  net_flush(&thd->net);
unknown's avatar
unknown committed
1428
  if ((error= table->file->dump(thd,-1)))
1429
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1430

unknown's avatar
unknown committed
1431
err:
unknown's avatar
unknown committed
1432
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1433 1434
}

unknown's avatar
unknown committed
1435 1436 1437 1438
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1439
    end_trans()
unknown's avatar
unknown committed
1440 1441 1442 1443 1444 1445 1446
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1447
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
unknown's avatar
unknown committed
1448 1449 1450
{
  bool do_release= 0;
  int res= 0;
1451
  DBUG_ENTER("end_trans");
unknown's avatar
unknown committed
1452

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

unknown's avatar
unknown committed
1503 1504 1505
  if (res < 0)
    my_error(thd->killed_errno(), MYF(0));
  else if ((res == 0) && do_release)
unknown's avatar
unknown committed
1506 1507
    thd->killed= THD::KILL_CONNECTION;

unknown's avatar
unknown committed
1508 1509
  DBUG_RETURN(res);
}
unknown's avatar
unknown committed
1510

1511
#ifndef EMBEDDED_LIBRARY
1512 1513

/*
1514
  Read one command from connection and execute it (query or simple command).
1515 1516 1517 1518 1519 1520 1521 1522
  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
1523 1524
bool do_command(THD *thd)
{
1525
  char *packet= 0;
unknown's avatar
unknown committed
1526
  ulong packet_length;
1527
  NET *net= &thd->net;
unknown's avatar
unknown committed
1528 1529 1530
  enum enum_server_command command;
  DBUG_ENTER("do_command");

unknown's avatar
unknown committed
1531 1532 1533 1534
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1535
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1536

1537 1538 1539 1540 1541 1542
  /*
    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
  */
1543
  my_net_set_read_timeout(net, thd->variables.net_wait_timeout);
1544

unknown's avatar
unknown committed
1545
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1546 1547 1548 1549

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

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

1577 1578 1579 1580 1581 1582 1583 1584 1585
  /*
    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
1586
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1587
}
1588
#endif  /* EMBEDDED_LIBRARY */
1589

1590

1591 1592
/*
   Perform one connection-level (COM_XXXX) command.
1593

1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
  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
*/
1607

1608 1609 1610 1611
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1612
  bool error= 0;
1613 1614
  DBUG_ENTER("dispatch_command");

1615
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
1616
  {
1617
    thd->killed= THD::NOT_KILLED;
1618 1619
    thd->mysys_var->abort= 0;
  }
1620

1621
  thd->command=command;
unknown's avatar
unknown committed
1622
  /*
1623 1624
    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
1625
  */
1626
  thd->enable_slow_log= TRUE;
1627
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
unknown's avatar
unknown committed
1628
  thd->set_time();
unknown's avatar
unknown committed
1629
  VOID(pthread_mutex_lock(&LOCK_thread_count));
1630
  thd->query_id= global_query_id;
unknown's avatar
unknown committed
1631
  if (command != COM_STATISTICS && command != COM_PING)
1632
    next_query_id();
unknown's avatar
unknown committed
1633
  thread_running++;
1634
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1635
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1636

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

1678
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1679
    thd->enable_slow_log= opt_log_slow_admin_statements;
1680
    db= thd->alloc(db_len + tbl_len + 2);
1681 1682 1683 1684 1685
    if (!db)
    {
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
      break;
    }
1686 1687
    tbl_name= strmake(db, packet + 1, db_len)+1;
    strmake(tbl_name, packet + db_len + 2, tbl_len);
unknown's avatar
unknown committed
1688
    mysql_table_dump(thd, db, tbl_name);
1689 1690
    break;
  }
unknown's avatar
unknown committed
1691 1692
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1693
    thd->change_user();
1694
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1695

1696
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1697
    char *user= (char*) packet;
unknown's avatar
unknown committed
1698
    char *passwd= strend(user)+1;
1699
    /*
unknown's avatar
unknown committed
1700 1701 1702
      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).
1703 1704 1705

      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
1706
    */
unknown's avatar
unknown committed
1707
    char db_buff[NAME_LEN+1];               // buffer to store db in utf8
unknown's avatar
unknown committed
1708
    char *db= passwd;
1709
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
1710
      (uchar)(*passwd++) : strlen(passwd);
unknown's avatar
unknown committed
1711
    db+= passwd_len + 1;
1712
#ifndef EMBEDDED_LIBRARY
1713
    /* Small check for incoming packet */
unknown's avatar
unknown committed
1714
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1715
    {
unknown's avatar
unknown committed
1716
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1717 1718
      break;
    }
1719
#endif
1720
    /* Convert database name to utf8 */
1721
    uint dummy_errors;
1722 1723
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1724
                             thd->charset(), &dummy_errors)]= 0;
1725
    db= db_buff;
unknown's avatar
unknown committed
1726

1727 1728 1729
    /* Save user and privileges */
    uint save_db_length= thd->db_length;
    char *save_db= thd->db;
1730
    Security_context save_security_ctx= *thd->security_ctx;
unknown's avatar
unknown committed
1731
    USER_CONN *save_user_connect= thd->user_connect;
1732 1733

    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
1734
    {
1735
      thd->security_ctx->user= save_security_ctx.user;
unknown's avatar
unknown committed
1736
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1737 1738
      break;
    }
unknown's avatar
unknown committed
1739

unknown's avatar
unknown committed
1740 1741
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1742
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1743

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

unknown's avatar
unknown committed
1806
    mysql_log.write(thd,command, format, thd->query_length, thd->query);
1807
    DBUG_PRINT("query",("%-.4096s",thd->query));
1808 1809 1810 1811

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

1812
    mysql_parse(thd, thd->query, thd->query_length, & found_semicolon);
1813

1814
    while (!thd->killed && found_semicolon && !thd->net.report_error)
1815
    {
1816
      char *next_packet= (char*) found_semicolon;
1817
      net->no_send_error= 0;
1818
      /*
1819 1820
        Multiple queries exits, execute them individually
      */
1821 1822
      if (thd->lock || thd->open_tables || thd->derived_tables ||
          thd->prelocked_mode)
1823
        close_thread_tables(thd);
1824
      ulong length= (ulong)(packet_end - next_packet);
1825

1826
      log_slow_statement(thd);
1827

1828
      /* Remove garbage at start of query */
1829
      while (my_isspace(thd->charset(), *next_packet) && length > 0)
1830
      {
1831
        next_packet++;
1832 1833
        length--;
      }
unknown's avatar
unknown committed
1834
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1835
      thd->query_length= length;
1836
      thd->query= next_packet;
1837
      thd->query_id= next_query_id();
1838
      thd->set_time(); /* Reset the query start time. */
1839
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1840
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1841
      mysql_parse(thd, next_packet, length, & found_semicolon);
1842 1843
    }

unknown's avatar
unknown committed
1844 1845 1846 1847 1848
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1849
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1850
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
1851 1852
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
unknown's avatar
unknown committed
1853 1854 1855
    break;
#else
  {
1856
    char *fields, *pend;
1857
    /* Locked closure of all tables */
unknown's avatar
unknown committed
1858
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1859
    LEX_STRING conv_name;
1860

unknown's avatar
unknown committed
1861
    /* used as fields initializator */
1862
    lex_start(thd);
1863

1864 1865
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
unknown's avatar
unknown committed
1866
    bzero((char*) &table_list,sizeof(table_list));
unknown's avatar
unknown committed
1867
    if (thd->copy_db_to(&table_list.db, 0))
unknown's avatar
unknown committed
1868
      break;
1869
    pend= strend(packet);
unknown's avatar
unknown committed
1870 1871
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1872
    table_list.alias= table_list.table_name= conv_name.str;
1873
    packet= pend+1;
1874 1875

    if (!my_strcasecmp(system_charset_info, table_list.db,
1876
                       INFORMATION_SCHEMA_NAME.str))
1877 1878 1879 1880 1881 1882
    {
      ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, table_list.alias);
      if (schema_table)
        table_list.schema_table= schema_table;
    }

1883
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
unknown's avatar
unknown committed
1884 1885
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1886
    mysql_log.write(thd,command,"%s %s",table_list.table_name, fields);
1887
    if (lower_case_table_names)
1888 1889
      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
1890

unknown's avatar
unknown committed
1891
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
1892
		     0, 0, test(table_list.schema_table)))
unknown's avatar
unknown committed
1893
      break;
unknown's avatar
unknown committed
1894 1895
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1896
      break;
1897 1898
    /* init structures for VIEW processing */
    table_list.select_lex= &(thd->lex->select_lex);
1899 1900 1901 1902

    lex_start(thd);
    mysql_reset_thd_for_next_command(thd);

1903 1904 1905
    thd->lex->
      select_lex.table_list.link_in_list((byte*) &table_list,
                                         (byte**) &table_list.next_local);
unknown's avatar
unknown committed
1906
    thd->lex->add_to_query_tables(&table_list);
1907

1908 1909
    /* switch on VIEW optimisation: do not fill temporary tables */
    thd->lex->sql_command= SQLCOM_SHOW_FIELDS;
unknown's avatar
unknown committed
1910
    mysqld_list_fields(thd,&table_list,fields);
1911
    thd->lex->unit.cleanup();
1912
    thd->cleanup_after_query();
unknown's avatar
unknown committed
1913 1914 1915 1916
    break;
  }
#endif
  case COM_QUIT:
1917
    /* We don't calculate statistics for this command */
1918
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1919 1920 1921 1922
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1923
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1924
    {
unknown's avatar
unknown committed
1925
      char *db=thd->strdup(packet), *alias;
1926
      HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1927

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

1974
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1975
      thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
unknown committed
1976
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1977
	break;
unknown's avatar
unknown committed
1978

1979
      /* TODO: The following has to be changed to an 8 byte integer */
1980 1981
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1982
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1983
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1984
	kill_zombie_dump_threads(slave_server_id);
1985
      thd->server_id = slave_server_id;
unknown's avatar
unknown committed
1986 1987 1988

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

    STATUS_VAR current_global_status_var;
    calc_sum_of_all_status(&current_global_status_var);

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

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

unknown's avatar
unknown committed
2161 2162 2163
  /* report error issued during command execution */
  if (thd->killed_errno() && !thd->net.report_error)
    thd->send_kill_message();
unknown's avatar
unknown committed
2164
  if (thd->net.report_error)
2165
    net_send_error(thd);
unknown's avatar
unknown committed
2166

2167
  log_slow_statement(thd);
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182

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


2183
void log_slow_statement(THD *thd)
2184
{
2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
  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;
2196
  thd->end_time();				// Set start time
2197

2198 2199 2200 2201 2202
  /*
    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
2203
  {
2204 2205
    thd->proc_info="logging slow query";

2206 2207
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2208
        (thd->server_status &
2209
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2210
        opt_log_queries_not_using_indexes &&
2211 2212
        /* == SQLCOM_END unless this is a SHOW command */
        thd->lex->orig_sql_command == SQLCOM_END)
2213
    {
2214
      thd->status_var.long_query_count++;
2215 2216
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
unknown's avatar
unknown committed
2217 2218 2219
  }
}

2220

unknown's avatar
unknown committed
2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
/*
  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.
*/

2249 2250 2251 2252
int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
                         enum enum_schema_tables schema_table_idx)
{
  DBUG_ENTER("prepare_schema_table");
2253 2254
  SELECT_LEX *schema_select_lex= NULL;

2255
  switch (schema_table_idx) {
2256 2257
  case SCH_SCHEMATA:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
2258 2259
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0));   /* purecov: inspected */
2260 2261 2262 2263
    DBUG_RETURN(1);
#else
    break;
#endif
2264

2265 2266 2267
  case SCH_TABLE_NAMES:
  case SCH_TABLES:
  case SCH_VIEWS:
2268
  case SCH_TRIGGERS:
2269
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2270 2271
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2272 2273
    DBUG_RETURN(1);
#else
2274
    if (lex->select_lex.db == NULL &&
2275
        lex->copy_db_to(&lex->select_lex.db, NULL))
2276
    {
2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288
      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);
2289
    }
2290 2291 2292


    break;
2293 2294 2295 2296
#endif
  case SCH_COLUMNS:
  case SCH_STATISTICS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2297 2298
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2299 2300 2301
    DBUG_RETURN(1);
#else
    {
2302 2303
      DBUG_ASSERT(table_ident);

2304
      TABLE_LIST **query_tables_last= lex->query_tables_last;
2305
      schema_select_lex= new SELECT_LEX();
unknown's avatar
unknown committed
2306
      /* 'parent_lex' is used in init_query() so it must be before it. */
2307 2308 2309 2310
      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))
2311 2312
        DBUG_RETURN(1);
      lex->query_tables_last= query_tables_last;
2313 2314 2315 2316 2317

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

2318 2319 2320
      break;
    }
#endif
2321 2322 2323
  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
  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;
2344
  table_list->schema_select_lex= schema_select_lex;
2345
  table_list->schema_table_reformed= 1;
2346 2347
  statistic_increment(thd->status_var.com_stat[lex->orig_sql_command],
                      &LOCK_status);
2348 2349 2350 2351
  DBUG_RETURN(0);
}


2352 2353
/*
  Read query from packet and store in thd->query
2354
  Used in COM_QUERY and COM_STMT_PREPARE
2355 2356 2357 2358 2359 2360 2361

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

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

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

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

unknown's avatar
unknown committed
2396
  return FALSE;
2397 2398
}

2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411
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;
2412
  thd->variables.lc_time_names= &my_locale_en_US;
2413 2414 2415
  thd->one_shot_set= 0;
}

2416

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

  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
2440

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

2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473
  /*
    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
2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489
  /*
    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();
2490
  /* should be assigned after making first tables same */
unknown's avatar
VIEW  
unknown committed
2491
  all_tables= lex->query_tables;
2492 2493 2494 2495
  /* 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
2496

2497 2498 2499 2500 2501
  /*
    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.
2502
    Don't reset warnings when executing a stored routine.
2503
  */
2504
  if ((all_tables || &lex->select_lex != lex->all_selects_list ||
2505
       lex->sroutines.records) && !thd->spcont ||
2506
      lex->time_zone_tables_used)
unknown's avatar
unknown committed
2507
    mysql_reset_errors(thd, 0);
2508

unknown's avatar
SCRUM  
unknown committed
2509
#ifdef HAVE_REPLICATION
2510
  if (unlikely(thd->slave_thread))
2511
  {
2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535
    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
2536
    /*
unknown's avatar
unknown committed
2537 2538
      Check if statment should be skipped because of slave filtering
      rules
2539 2540

      Exceptions are:
unknown's avatar
unknown committed
2541 2542
      - UPDATE MULTI: For this statement, we want to check the filtering
        rules later in the code
2543
      - SET: we always execute it (Not that many SET commands exists in
unknown's avatar
unknown committed
2544 2545
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
2546 2547
      - 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
2548
    */
unknown's avatar
unknown committed
2549 2550
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
	!(lex->sql_command == SQLCOM_SET_OPTION) &&
2551
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2552
          lex->drop_temporary && lex->drop_if_exists) &&
unknown's avatar
Merge  
unknown committed
2553
        all_tables_not_ok(thd, all_tables))
unknown's avatar
unknown committed
2554 2555
    {
      /* we warn the slave SQL thread */
unknown's avatar
unknown committed
2556
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573
      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);
      }
2574
      DBUG_RETURN(0);
unknown's avatar
unknown committed
2575
    }
2576
  }
2577
  else
2578
  {
2579
#endif /* HAVE_REPLICATION */
2580 2581 2582 2583 2584
    /*
      When option readonly is set deny operations which change non-temporary
      tables. Except for the replication thread and the 'super' users.
    */
    if (opt_readonly &&
2585 2586 2587 2588 2589 2590 2591
        !(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)))
2592 2593 2594 2595 2596 2597 2598
    {
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
      DBUG_RETURN(-1);
    }
#ifdef HAVE_REPLICATION
  } /* endif unlikely slave */
#endif
2599 2600 2601
  if(lex->orig_sql_command == SQLCOM_END)
    statistic_increment(thd->status_var.com_stat[lex->sql_command],
                        &LOCK_status);
2602

unknown's avatar
unknown committed
2603 2604
  DBUG_ASSERT(thd->transaction.stmt.modified_non_trans_table == FALSE);
  
unknown's avatar
unknown committed
2605 2606 2607
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2608 2609 2610 2611
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
2612 2613
	param->select_limit=
          new Item_int((ulonglong)thd->variables.select_limit);
2614 2615
    }

2616
    select_result *sel_result=lex->result;
unknown's avatar
VIEW  
unknown committed
2617
    if (all_tables)
unknown's avatar
unknown committed
2618
    {
2619 2620 2621 2622 2623 2624
      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
2625 2626
    }
    else
unknown's avatar
VIEW  
unknown committed
2627 2628
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
2629
			any_db, 0, 0, 0, 0);
unknown's avatar
unknown committed
2630
    if (res)
unknown's avatar
unknown committed
2631
      goto error;
unknown's avatar
unknown committed
2632

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

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

2696
  case SQLCOM_EMPTY_QUERY:
2697
    send_ok(thd);
2698 2699
    break;

unknown's avatar
unknown committed
2700 2701 2702 2703
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

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

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

unknown's avatar
unknown committed
2766
#ifdef HAVE_REPLICATION
2767 2768
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2769
    if (check_global_access(thd, REPL_SLAVE_ACL))
2770 2771 2772 2773
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2774 2775
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2776
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2777
      goto error;
2778
    res = mysql_show_binlog_events(thd);
unknown's avatar
unknown committed
2779 2780
    break;
  }
2781 2782
#endif

unknown's avatar
unknown committed
2783
  case SQLCOM_BACKUP_TABLE:
2784
  {
unknown's avatar
VIEW  
unknown committed
2785 2786 2787
    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
2788
	check_global_access(thd, FILE_ACL))
2789
      goto error; /* purecov: inspected */
2790
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2791
    res = mysql_backup_table(thd, first_table);
2792
    select_lex->table_list.first= (byte*) first_table;
2793
    lex->query_tables=all_tables;
2794 2795
    break;
  }
unknown's avatar
unknown committed
2796
  case SQLCOM_RESTORE_TABLE:
2797
  {
unknown's avatar
VIEW  
unknown committed
2798 2799 2800
    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
2801
	check_global_access(thd, FILE_ACL))
2802
      goto error; /* purecov: inspected */
2803
    thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
VIEW  
unknown committed
2804
    res = mysql_restore_table(thd, first_table);
2805
    select_lex->table_list.first= (byte*) first_table;
2806
    lex->query_tables=all_tables;
2807 2808
    break;
  }
unknown's avatar
unknown committed
2809 2810
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
unknown's avatar
VIEW  
unknown committed
2811 2812 2813
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
2814 2815
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
unknown's avatar
unknown committed
2816
      goto error;
2817
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
unknown's avatar
unknown committed
2818 2819
    break;
  }
unknown's avatar
unknown committed
2820 2821
  case SQLCOM_PRELOAD_KEYS:
  {
unknown's avatar
VIEW  
unknown committed
2822 2823 2824
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
2825 2826
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
2827
      goto error;
unknown's avatar
VIEW  
unknown committed
2828
    res = mysql_preload_keys(thd, first_table);
unknown's avatar
unknown committed
2829 2830
    break;
  }
unknown's avatar
unknown committed
2831
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2832
  case SQLCOM_CHANGE_MASTER:
2833
  {
unknown's avatar
unknown committed
2834
    if (check_global_access(thd, SUPER_ACL))
2835
      goto error;
2836
    pthread_mutex_lock(&LOCK_active_mi);
2837
    res = change_master(thd,active_mi);
2838
    pthread_mutex_unlock(&LOCK_active_mi);
2839 2840
    break;
  }
unknown's avatar
unknown committed
2841
  case SQLCOM_SHOW_SLAVE_STAT:
2842
  {
2843 2844
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2845
      goto error;
2846
    pthread_mutex_lock(&LOCK_active_mi);
2847 2848 2849 2850 2851 2852 2853 2854 2855 2856
    if (active_mi != NULL)
    {
      res = show_master_info(thd, active_mi);
    }
    else
    {
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                   "the master info structure does not exist");
      send_ok(thd);
    }
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 4002 4003
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
4004
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
4005 4006
      break;
    }
4007
    if (check_access(thd,SELECT_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
unknown's avatar
unknown committed
4008
      break;
unknown's avatar
unknown committed
4009
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
unknown's avatar
unknown committed
4010 4011
    break;
  }
unknown's avatar
unknown committed
4012
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
unknown's avatar
unknown committed
4013
  {
4014
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0))
unknown's avatar
unknown committed
4015
      break;
unknown's avatar
unknown committed
4016
#ifdef HAVE_DLOPEN
4017 4018
    if (sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                        &thd->sp_func_cache, FALSE))
unknown's avatar
unknown committed
4019
    {
4020
      my_error(ER_UDF_EXISTS, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4021 4022
      goto error;
    }
4023
    if (!(res = mysql_create_function(thd, &lex->udf)))
unknown's avatar
unknown committed
4024
      send_ok(thd);
unknown's avatar
unknown committed
4025
#else
unknown's avatar
unknown committed
4026
    my_error(ER_CANT_OPEN_LIBRARY, MYF(0), lex->udf.dl, 0, "feature disabled");
unknown's avatar
unknown committed
4027
    res= TRUE;
unknown's avatar
unknown committed
4028 4029
#endif
    break;
unknown's avatar
unknown committed
4030
  }
unknown's avatar
unknown committed
4031
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4032 4033
  case SQLCOM_CREATE_USER:
  {
4034
    if (check_access(thd, INSERT_ACL, "mysql", 0, 1, 1, 0) &&
4035
        check_global_access(thd,CREATE_USER_ACL))
4036
      break;
4037 4038
    if (end_active_trans(thd))
      goto error;
4039
    /* Conditionally writes to binlog */
4040 4041 4042 4043
    if (!(res= mysql_create_user(thd, lex->users_list)))
      send_ok(thd);
    break;
  }
4044 4045
  case SQLCOM_DROP_USER:
  {
4046
    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 1, 0) &&
4047
        check_global_access(thd,CREATE_USER_ACL))
4048
      break;
4049 4050
    if (end_active_trans(thd))
      goto error;
4051
    /* Conditionally writes to binlog */
4052
    if (!(res= mysql_drop_user(thd, lex->users_list)))
4053 4054 4055 4056 4057
      send_ok(thd);
    break;
  }
  case SQLCOM_RENAME_USER:
  {
4058
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
4059
        check_global_access(thd,CREATE_USER_ACL))
4060
      break;
4061 4062
    if (end_active_trans(thd))
      goto error;
4063
    /* Conditionally writes to binlog */
4064
    if (!(res= mysql_rename_user(thd, lex->users_list)))
4065 4066 4067 4068 4069
      send_ok(thd);
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
4070
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
4071
        check_global_access(thd,CREATE_USER_ACL))
4072
      break;
4073
    /* Conditionally writes to binlog */
4074 4075 4076 4077
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
      send_ok(thd);
    break;
  }
4078 4079 4080 4081
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
unknown's avatar
unknown committed
4082
		     first_table ?  first_table->db : select_lex->db,
unknown's avatar
VIEW  
unknown committed
4083
		     first_table ? &first_table->grant.privilege : 0,
4084 4085 4086
		     first_table ? 0 : 1, 0,
                     first_table ? (bool) first_table->schema_table :
                     select_lex->db ? is_schema_db(select_lex->db) : 0))
4087 4088
      goto error;

4089
    if (thd->security_ctx->user)              // If not replication
unknown's avatar
unknown committed
4090
    {
4091
      LEX_USER *user, *tmp_user;
4092

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

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

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

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

4400
    DBUG_ASSERT(lex->sphead != 0);
unknown's avatar
unknown committed
4401
    DBUG_ASSERT(lex->sphead->m_db.str); /* Must be initialized in the parser */
4402 4403 4404 4405 4406 4407 4408
    /*
      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);
4409
      goto create_sp_error;
4410 4411 4412
    }

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

4423 4424
    if (check_access(thd, CREATE_PROC_ACL, lex->sphead->m_db.str, 0, 0, 0,
                     is_schema_db(lex->sphead->m_db.str)))
4425
      goto create_sp_error;
4426

4427 4428
    if (end_active_trans(thd))
      goto create_sp_error;
4429 4430

    name= lex->sphead->name(&namelen);
4431
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
4432 4433 4434
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
4435

unknown's avatar
unknown committed
4436
      if (udf)
4437
      {
4438 4439
        my_error(ER_UDF_EXISTS, MYF(0), name);
        goto create_sp_error;
4440
      }
unknown's avatar
unknown committed
4441 4442 4443
    }
#endif

4444 4445 4446
    /*
      If the definer is not specified, this means that CREATE-statement missed
      DEFINER-clause. DEFINER-clause can be missed in two cases:
4447

4448 4449 4450 4451 4452 4453 4454 4455
        - 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.
4456

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

      if (!(lex->definer= create_default_definer(thd)))
4476
        local_res= TRUE;
4477 4478 4479 4480

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

4481
      /* Error has been already reported. */
4482
      if (local_res)
4483
        goto create_sp_error;
4484 4485 4486 4487 4488 4489 4490 4491 4492 4493

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

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

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

4522
    res= (sp_result= lex->sphead->create(thd));
4523
    switch (sp_result) {
4524
    case SP_OK:
unknown's avatar
unknown committed
4525
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4526
      /* only add privileges if really neccessary */
4527
      if (sp_automatic_privileges && !opt_noacl &&
4528
          check_routine_access(thd, DEFAULT_CREATE_PROC_ACLS,
4529
                               lex->sphead->m_db.str, name,
4530
                               lex->sql_command == SQLCOM_CREATE_PROCEDURE, 1))
4531
      {
unknown's avatar
unknown committed
4532
        if (sp_grant_privileges(thd, lex->sphead->m_db.str, name,
4533
                                lex->sql_command == SQLCOM_CREATE_PROCEDURE))
4534 4535 4536 4537
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                       ER_PROC_AUTO_GRANT_FAIL,
                       ER(ER_PROC_AUTO_GRANT_FAIL));
        close_thread_tables(thd);
4538
      }
unknown's avatar
unknown committed
4539
#endif
unknown's avatar
unknown committed
4540
    break;
4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559
    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:
4560
    if (sp_result != SP_OK )
4561 4562 4563 4564
      goto error;
    send_ok(thd);
    break; /* break super switch */
  } /* end case group bracket */
4565 4566 4567 4568
  case SQLCOM_CALL:
    {
      sp_head *sp;

4569 4570 4571 4572 4573 4574 4575 4576 4577
      /*
        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;

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

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

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

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

unknown's avatar
unknown committed
4656
	thd->variables.select_limit= select_limit;
4657

4658
	thd->net.no_send_ok= save_no_send_ok;
unknown's avatar
unknown committed
4659
        thd->server_status&= ~bits_to_be_cleared;
4660

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

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

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

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

4760 4761
	if (check_routine_access(thd, ALTER_PROC_ACL, db, name,
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE, 0))
unknown's avatar
merge  
unknown committed
4762
          goto error;
4763 4764 4765

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

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

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

4931
    /* Conditionally writes to binlog. */
4932 4933
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

4934 4935 4936 4937
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
4938 4939 4940
    if (end_active_trans(thd))
      goto error;

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

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

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

  goto end;
unknown's avatar
unknown committed
5152 5153

error:
5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165
  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
5166 5167 5168
}


unknown's avatar
unknown committed
5169
/*
5170
  Check grants for commands which work only with one table.
unknown's avatar
unknown committed
5171

5172
  SYNOPSIS
5173
    check_single_table_access()
unknown's avatar
unknown committed
5174
    thd			Thread handler
5175
    privilege		requested privilege
unknown's avatar
VIEW  
unknown committed
5176
    all_tables		global table list of query
unknown's avatar
unknown committed
5177 5178 5179

  RETURN
    0 - OK
unknown's avatar
unknown committed
5180
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
5181 5182
*/

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

5192 5193 5194 5195 5196 5197 5198 5199
  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,
5200 5201
		   &all_tables->grant.privilege, 0, 0,
                   test(all_tables->schema_table)))
5202
    goto deny;
unknown's avatar
unknown committed
5203

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

  thd->security_ctx= backup_ctx;
5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237
  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
5238

5239
  /* Check rights on tables of subselects and implictly opened tables */
unknown's avatar
unknown committed
5240
  TABLE_LIST *subselects_tables, *view= all_tables->view ? all_tables : 0;
unknown's avatar
VIEW  
unknown committed
5241
  if ((subselects_tables= all_tables->next_global))
unknown's avatar
unknown committed
5242
  {
unknown's avatar
unknown committed
5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254
    /*
      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)))
5255
      return 1;
unknown's avatar
unknown committed
5256 5257
  }
  return 0;
unknown's avatar
unknown committed
5258 5259 5260
}


unknown's avatar
unknown committed
5261
/****************************************************************************
unknown's avatar
unknown committed
5262
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275

  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
5276 5277
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
5278 5279 5280
****************************************************************************/

bool
unknown's avatar
unknown committed
5281
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
5282
	     bool dont_check_global_grants, bool no_errors, bool schema_db)
unknown's avatar
unknown committed
5283
{
5284
  Security_context *sctx= thd->security_ctx;
unknown's avatar
unknown committed
5285 5286
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297
  /*
    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
5298 5299
#endif
  ulong dummy;
5300 5301
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
5302
                      db ? db : "", want_access, sctx->master_access));
unknown's avatar
unknown committed
5303 5304 5305 5306 5307
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

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

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

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

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

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

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

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


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

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
5422
{
unknown's avatar
unknown committed
5423 5424 5425
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
5426
  char command[128];
5427
  if ((thd->security_ctx->master_access & want_access))
unknown's avatar
unknown committed
5428 5429
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
5430
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
unknown's avatar
unknown committed
5431
  return 1;
unknown's avatar
unknown committed
5432
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
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 5509 5510 5511 5512
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
5513
/*
5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533
  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
5534 5535
*/

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

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

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

      continue;
    }

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

5619

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

  return FALSE;
}

5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664

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

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


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


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

unknown's avatar
unknown committed
5737 5738 5739

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
unknown's avatar
unknown committed
5740
  char *current_db= NULL;
unknown's avatar
VIEW  
unknown committed
5741
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
5742
  {
unknown's avatar
unknown committed
5743
    if (tables->db == NULL)
unknown's avatar
unknown committed
5744
    {
unknown's avatar
unknown committed
5745 5746 5747 5748 5749 5750 5751 5752 5753
      /*
        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
5754 5755 5756 5757
    }
  }
  return FALSE;
}
5758

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

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

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

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


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

5875

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

5889

unknown's avatar
unknown committed
5890
bool
unknown's avatar
unknown committed
5891
mysql_new_select(LEX *lex, bool move_down)
5892
{
unknown's avatar
unknown committed
5893
  SELECT_LEX *select_lex;
5894
  THD *thd= lex->thd;
unknown's avatar
unknown committed
5895 5896
  DBUG_ENTER("mysql_new_select");

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

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

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

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

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

6007

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

6020 6021 6022 6023
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
6024

6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035
/**
  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
6036 6037
{
  DBUG_ENTER("mysql_parse");
6038 6039 6040

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

6041 6042 6043 6044 6045 6046 6047 6048
  /*
    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
6049 6050
    of (among others) lex->safe_to_cache_query and thd->server_status,
    which are reset respectively in
6051 6052 6053 6054 6055 6056 6057 6058 6059 6060
    - 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
6061
  {
unknown's avatar
unknown committed
6062
    LEX *lex= thd->lex;
6063

6064 6065
    sp_cache_flush_obsolete(&thd->sp_proc_cache);
    sp_cache_flush_obsolete(&thd->sp_func_cache);
6066

unknown's avatar
unknown committed
6067 6068 6069
    Lex_input_stream lip(thd, inBuf, length);
    thd->m_lip= &lip;

6070 6071 6072 6073
    int err= MYSQLparse(thd);
    *found_semicolon= lip.found_semicolon;

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

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

unknown's avatar
unknown committed
6131 6132 6133 6134
  DBUG_VOID_RETURN;
}


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

6151 6152 6153 6154 6155 6156 6157
  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 &&
6158
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
unknown's avatar
unknown committed
6159
    error= 1;                  /* Ignore question */
6160
  thd->end_statement();
6161
  thd->cleanup_after_query();
unknown's avatar
unknown committed
6162
  DBUG_RETURN(error);
6163
}
unknown's avatar
unknown committed
6164
#endif
unknown's avatar
unknown committed
6165

6166

unknown's avatar
unknown committed
6167

unknown's avatar
unknown committed
6168 6169 6170 6171 6172
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

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

  if (strlen(field_name) > NAME_LEN)
  {
6188
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
unknown's avatar
unknown committed
6189 6190 6191 6192 6193
    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
6194 6195 6196
    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
6197 6198 6199 6200 6201
    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
6202 6203 6204
    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
6205 6206 6207
    lex->col_list.empty();
  }

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

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
6243
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
6244 6245
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
6246

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

6261 6262 6263 6264
  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
6265
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6266

unknown's avatar
unknown committed
6267
  lex->alter_info.create_list.push_back(new_field);
unknown's avatar
unknown committed
6268 6269 6270 6271
  lex->last_field=new_field;
  DBUG_RETURN(0);
}

6272

unknown's avatar
unknown committed
6273 6274 6275 6276
/* Store position for column in ALTER TABLE .. ADD column */

void store_position_for_column(const char *name)
{
6277
  current_thd->lex->last_field->after=my_const_cast(char*) (name);
unknown's avatar
unknown committed
6278 6279 6280
}

bool
unknown's avatar
unknown committed
6281
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
6282 6283 6284 6285
{
  ORDER *order;
  Item	**item_ptr;

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


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

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

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


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


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

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

  if (!alias)					/* Alias is case sensitive */
6396 6397 6398
  {
    if (table->sel)
    {
unknown's avatar
unknown committed
6399 6400
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
6401 6402
      DBUG_RETURN(0);
    }
6403
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
6404
      DBUG_RETURN(0);
6405
  }
unknown's avatar
unknown committed
6406
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
6407
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
6408
  if (table->db.str)
6409
  {
6410 6411 6412 6413 6414
    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);
    }
6415 6416 6417
    ptr->db= table->db.str;
    ptr->db_length= table->db.length;
  }
6418
  else if (lex->copy_db_to(&ptr->db, &ptr->db_length))
unknown's avatar
unknown committed
6419
    DBUG_RETURN(0);
unknown's avatar
unknown committed
6420

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

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

unknown's avatar
unknown committed
6507

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

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

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

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

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

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

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


/*
  Nest last join operation

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

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

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

6611 6612 6613 6614 6615 6616
*/

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

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

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

  for (uint i=0; i < 2; i++)
6632 6633 6634 6635 6636
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
unknown's avatar
unknown committed
6637 6638 6639 6640 6641 6642 6643
    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.
      */
6644 6645
      if (prev_join_using)
        ptr->join_using_fields= prev_join_using;
unknown's avatar
unknown committed
6646
    }
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
  }
  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
6687 6688 6689

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

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

unknown's avatar
unknown committed
6756

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

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

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

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

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

6818

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

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

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

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

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


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


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

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

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

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

unknown's avatar
unknown committed
6937

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

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

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

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

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

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

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

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

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

unknown's avatar
unknown committed
7170

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

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

7197

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

unknown's avatar
unknown committed
7225

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

unknown's avatar
unknown committed
7231

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

unknown's avatar
unknown committed
7237

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

unknown's avatar
unknown committed
7243

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

unknown's avatar
unknown committed
7249

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

unknown's avatar
unknown committed
7255

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


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

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

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

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


/*
  Multi update query pre-check

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

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

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

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

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

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

/*
  Multi delete query pre-check

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

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

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

7396 7397 7398
  /* 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) ||
7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410
      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
7411
    DBUG_RETURN(TRUE);
7412 7413 7414
  }
  thd->lex->query_tables_own_last= save_query_tables_own_last;

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


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

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

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

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


/*
  simple DELETE query pre-check

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

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

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


/*
  simple INSERT query pre-check

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

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

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

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

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

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


unknown's avatar
unknown committed
7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586
/**
   @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
7587 7588 7589 7590 7591
/*
  CREATE TABLE query pre-check

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

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

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

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

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

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

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


/*
  negate given expression

  SYNOPSIS
    negate_expression()
7668
    thd  thread handler
unknown's avatar
unknown committed
7669 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
    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);
}
7697

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

7719

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

  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;

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

  return definer;
}


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

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

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

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

  /* Create and initialize. */

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

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

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


/*
  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
7794 7795
    return create_default_definer(thd);

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


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

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

7822 7823
  return TRUE;
}