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

bk@work.mysql.com's avatar
bk@work.mysql.com 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
5
   the Free Software Foundation; version 2 of the License.
6

bk@work.mysql.com's avatar
bk@work.mysql.com 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

bk@work.mysql.com's avatar
bk@work.mysql.com 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
bk@work.mysql.com's avatar
bk@work.mysql.com committed
17
#include "mysql_priv.h"
18
#include "sql_repl.h"
19
#include "repl_failsafe.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
20 21 22 23
#include <m_ctype.h>
#include <myisam.h>
#include <my_dir.h>

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
24
#ifdef HAVE_INNOBASE_DB
25
#include "ha_innodb.h"
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi 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

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?
*/
48 49 50
#define SSL_HANDSHAKE_SIZE      2
#define NORMAL_HANDSHAKE_SIZE   6
#define MIN_HANDSHAKE_SIZE      2
51
#else
52
#define MIN_HANDSHAKE_SIZE      6
53
#endif /* HAVE_OPENSSL */
bk@work.mysql.com's avatar
bk@work.mysql.com 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
bk@work.mysql.com's avatar
bk@work.mysql.com committed
68

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 */
74
static bool check_db_used(THD *thd,TABLE_LIST *tables);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
75
static void remove_escape(char *name);
76 77
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
78

79
const char *any_db="*any*";	// Special symbol for check_access
bk@work.mysql.com's avatar
bk@work.mysql.com committed
80 81 82 83

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

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

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

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

124

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

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

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


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

207
#ifndef NO_EMBEDDED_ACCESS_CHECKS
208 209
static HASH hash_user_connections;

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

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

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

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


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

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

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

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

hf@deer.(none)'s avatar
hf@deer.(none) committed
288 289 290
int check_user(THD *thd, enum enum_server_command command, 
	       const char *passwd, uint passwd_len, const char *db,
	       bool check_count)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
291
{
292
  DBUG_ENTER("check_user");
293 294
  LEX_STRING db_str= { (char *) db, db ? strlen(db) : 0 };

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

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

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

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

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

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

420
      /*
421 422 423
        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.
424
      */
425
      thd->main_security_ctx.db_access=0;
426 427

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

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

480
/*
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
481 482
  Check for maximum allowable user connections, if the mysqld server is
  started with corresponding variable that is greater then 0.
483 484
*/

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

492
extern "C" void free_user(struct user_conn *uc)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
493 494 495 496
{
  my_free((char*) uc,MYF(0));
}

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


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
/*
  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
*/

525 526
#ifndef NO_EMBEDDED_ACCESS_CHECKS

527
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
528
{
529
  int error=0;
530
  DBUG_ENTER("check_for_max_user_connections");
peter@mysql.com's avatar
peter@mysql.com committed
531

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

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

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

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

600 601
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

602

603 604
void free_max_user_conn(void)
{
605
#ifndef NO_EMBEDDED_ACCESS_CHECKS
606
  hash_free(&hash_user_connections);
607
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
608 609
}

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
610

611

612 613 614
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
kent@mysql.com's avatar
kent@mysql.com committed
615 616 617

  sql_command is actually set to SQLCOM_END sometimes
  so we need the +1 to include it in the array.
618 619 620 621 622 623

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

kent@mysql.com's avatar
kent@mysql.com committed
626
char  uc_update_queries[SQLCOM_END+1];
627 628 629

void init_update_queries(void)
{
kent@mysql.com's avatar
kent@mysql.com committed
630 631
  bzero((gptr) &uc_update_queries, sizeof(uc_update_queries));

632 633 634
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
635 636 637 638 639 640
  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;
641 642 643 644 645
  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;
646 647
  uc_update_queries[SQLCOM_REPLACE]=2;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=2;
648 649 650 651
  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;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
652 653
  uc_update_queries[SQLCOM_CREATE_VIEW]=1;
  uc_update_queries[SQLCOM_DROP_VIEW]=1;
654 655
}

656 657
bool is_update_query(enum enum_sql_command command)
{
kent@mysql.com's avatar
kent@mysql.com committed
658
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
659
  return uc_update_queries[command] != 0;
660
}
661

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
662
/*
663 664
  Reset per-hour user resource limits when it has been more than
  an hour since they were last checked
665

666 667 668 669
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
670

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

676 677
#ifndef NO_EMBEDDED_ACCESS_CHECKS

678
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
679
{
680
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
681
  DBUG_ENTER("time_out_user_resource_limits");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
682

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

  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)
{
702
  bool error= 0;
703 704 705 706 707 708 709 710
  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);

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

737 738
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

739

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

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

780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
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;
  }
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
811
/*
812
    Perform handshake, authorize client and update thd ACL variables.
813
  SYNOPSIS
814
    check_connection()
815
    thd  thread handle
816 817

  RETURN
818
     0  success, OK is sent to user, thd is updated.
819 820
    -1  error, which is sent to user
   > 0  error code (not sent to user)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
821 822
*/

hf@deer.(none)'s avatar
hf@deer.(none) committed
823 824
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
825
{
826
  uint connect_errors= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
827
  NET *net= &thd->net;
monty@mysql.com's avatar
monty@mysql.com committed
828 829
  ulong pkt_len= 0;
  char *end;
830

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

837
  if (!thd->main_security_ctx.host)         // If TCP/IP connection
bk@work.mysql.com's avatar
bk@work.mysql.com committed
838
  {
839
    char ip[30];
840

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

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

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

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

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

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

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

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

  /*
1008 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
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
1013 1014 1015
    *passwd++ : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1016 1017
  uint db_len= db ? strlen(db) : 0;

serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1018
  if (passwd + passwd_len + db_len > (char *)net->read_pos + pkt_len)
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1019 1020 1021 1022
  {
    inc_host_errors(&thd->remote.sin_addr);
    return ER_HANDSHAKE_ERROR;
  }
peter@mysql.com's avatar
peter@mysql.com committed
1023

kostja@oak.local's avatar
kostja@oak.local committed
1024 1025
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
peter@mysql.com's avatar
peter@mysql.com committed
1026
  {
1027 1028
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info,
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1029
                             db, db_len,
1030
                             thd->charset(), &dummy_errors)]= 0;
1031
    db= db_buff;
kostja@oak.local's avatar
kostja@oak.local committed
1032
  }
peter@mysql.com's avatar
peter@mysql.com committed
1033

1034 1035 1036
  user_buff[user_len= copy_and_convert(user_buff, sizeof(user_buff)-1,
                                       system_charset_info, user, user_len,
                                       thd->charset(), &dummy_errors)]= '\0';
1037
  user= user_buff;
1038

1039 1040 1041 1042 1043 1044 1045 1046
  /* 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;
  }

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

1054

1055 1056
void execute_init_command(THD *thd, sys_var_str *init_command_var,
			  rw_lock_t *var_mutex)
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1057 1058 1059 1060
{
  Vio* save_vio;
  ulong save_client_capabilities;

1061 1062 1063 1064 1065 1066 1067 1068 1069
  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;
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1070 1071
  save_client_capabilities= thd->client_capabilities;
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
1072 1073 1074 1075
  /*
    We don't need return result of execution to client side.
    To forbid this we should set thd->net.vio to 0.
  */
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1076 1077
  save_vio= thd->net.vio;
  thd->net.vio= 0;
1078
  thd->net.no_send_error= 0;
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1079
  dispatch_command(COM_QUERY, thd, thd->query, thd->query_length+1);
1080
  rw_unlock(var_mutex);
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1081 1082 1083 1084 1085
  thd->client_capabilities= save_client_capabilities;
  thd->net.vio= save_vio;
}


1086
pthread_handler_t handle_one_connection(void *arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1087 1088 1089
{
  THD *thd=(THD*) arg;
  uint launch_time  =
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1090
    (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1091 1092 1093 1094 1095
  if (launch_time >= slow_launch_time)
    statistic_increment(slow_launch_threads,&LOCK_status );

  pthread_detach_this_thread();

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

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

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

  do
  {
    int error;
    NET *net= &thd->net;
1138
    Security_context *sctx= thd->security_ctx;
1139
    net->no_send_error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1140

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

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

gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1164
    thd->version= refresh_version;
1165
    thd->proc_info= 0;
1166
    thd->command= COM_SLEEP;
1167
    thd->init_for_queries();
monty@mysql.com's avatar
monty@mysql.com committed
1168

1169
    if (sys_init_connect.value_length && !(sctx->master_access & SUPER_ACL))
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1170
    {
1171 1172
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
1173
      {
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
1174
	thd->killed= THD::KILL_CONNECTION;
1175 1176 1177 1178 1179 1180
        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);
      }
1181 1182
      thd->proc_info=0;
      thd->init_for_queries();
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1183 1184
    }

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

1189 1190
    while (!net->error && net->vio != 0 &&
           !(thd->killed == THD::KILL_CONNECTION))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1191
    {
1192
      net->no_send_error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1193 1194 1195
      if (do_command(thd))
	break;
    }
1196 1197
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1198
    if (net->error && net->vio != 0 && net->report_error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1199
    {
1200
      if (!thd->killed && thd->variables.log_warnings > 1)
monty@mysql.com's avatar
monty@mysql.com committed
1201
	sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
serg@serg.mylan's avatar
serg@serg.mylan committed
1202
                          thd->thread_id,(thd->db ? thd->db : "unconnected"),
1203 1204
                          sctx->user ? sctx->user : "unauthenticated",
                          sctx->host_or_ip,
serg@serg.mylan's avatar
serg@serg.mylan committed
1205 1206
                          (net->last_errno ? ER(net->last_errno) :
                           ER(ER_UNKNOWN_ERROR)));
1207
      net_send_error(thd, net->last_errno, NullS);
1208
      statistic_increment(aborted_threads,&LOCK_status);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1209
    }
1210 1211 1212 1213
    else if (thd->killed)
    {
      statistic_increment(aborted_threads,&LOCK_status);
    }
1214
    
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1215
end_thread:
1216
    close_connection(thd, 0, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1217 1218 1219 1220 1221 1222
    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;
1223
    thd->thread_stack= (char*) &thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1224 1225 1226 1227 1228
  } while (!(test_flags & TEST_NO_THREADS));
  /* The following is only executed if we are not using --one-thread */
  return(0);					/* purecov: deadcode */
}

hf@deer.(none)'s avatar
hf@deer.(none) committed
1229 1230
#endif /* EMBEDDED_LIBRARY */

1231 1232 1233 1234
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1235

1236
pthread_handler_t handle_bootstrap(void *arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1237
{
1238 1239 1240
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1241

1242
  /* The following must be called before DBUG_ENTER */
1243
  thd->thread_stack= (char*) &thd;
1244
  if (my_thread_init() || thd->store_globals())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1245
  {
hf@deer.(none)'s avatar
hf@deer.(none) committed
1246
#ifndef EMBEDDED_LIBRARY
1247
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
hf@deer.(none)'s avatar
hf@deer.(none) committed
1248
#endif
1249
    thd->fatal_error();
1250
    goto end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1251
  }
1252 1253
  DBUG_ENTER("handle_bootstrap");

hf@deer.(none)'s avatar
hf@deer.(none) committed
1254
#ifndef EMBEDDED_LIBRARY
1255 1256
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1257
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1258
  sigset_t set;
1259 1260
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1261
#endif
hf@deer.(none)'s avatar
hf@deer.(none) committed
1262
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1263

1264
  if (thd->variables.max_join_size == HA_POS_ERROR)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1265 1266 1267 1268
    thd->options |= OPTION_BIG_SELECTS;

  thd->proc_info=0;
  thd->version=refresh_version;
1269 1270
  thd->security_ctx->priv_user=
    thd->security_ctx->user= (char*) my_strdup("boot", MYF(MY_WME));
1271 1272 1273 1274 1275 1276
  /*
    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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1277

1278
  buff= (char*) thd->net.buff;
1279
  thd->init_for_queries();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1280 1281
  while (fgets(buff, thd->net.max_packet, file))
  {
monty@mishka.local's avatar
monty@mishka.local committed
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
   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;

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

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

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

1331
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1332
#ifdef USING_TRANSACTIONS
1333
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
1334
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1335
  }
1336 1337

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

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

hf@deer.(none)'s avatar
hf@deer.(none) committed
1345
#ifndef EMBEDDED_LIBRARY
1346 1347 1348
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1349
  (void) pthread_cond_broadcast(&COND_thread_count);
1350 1351
  my_thread_end();
  pthread_exit(0);
hf@deer.(none)'s avatar
hf@deer.(none) committed
1352
#endif
1353
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1354 1355 1356
}


1357 1358 1359 1360
    /* This works because items are allocated with sql_alloc() */

void cleanup_items(Item *item)
{
monty@mysql.com's avatar
monty@mysql.com committed
1361
  DBUG_ENTER("cleanup_items");  
1362 1363
  for (; item ; item=item->next)
    item->cleanup();
monty@mysql.com's avatar
monty@mysql.com committed
1364
  DBUG_VOID_RETURN;
1365 1366
}

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
/*
  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)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1387 1388 1389 1390 1391 1392
{
  TABLE* table;
  TABLE_LIST* table_list;
  int error = 0;
  DBUG_ENTER("mysql_table_dump");
  db = (db && db[0]) ? db : thd->db;
1393
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
1394
    DBUG_RETURN(1); // out of memory
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1395
  table_list->db= db;
1396
  table_list->table_name= table_list->alias= tbl_name;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1397 1398
  table_list->lock_type= TL_READ_NO_INSERT;
  table_list->prev_global= &table_list;	// can be removed after merge with 4.1
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1399

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

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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1412
  if (check_one_table_access(thd, SELECT_ACL, table_list))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1413 1414
    goto err;
  thd->free_list = 0;
1415
  thd->query_length=(uint) strlen(tbl_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1416
  thd->query = tbl_name;
1417
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1418
  {
1419
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1420 1421
    goto err;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1422
  net_flush(&thd->net);
1423
  if ((error= table->file->dump(thd,-1)))
1424
    my_error(ER_GET_ERRNO, MYF(0), error);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1425

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1426
err:
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1427
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1428 1429
}

1430 1431 1432 1433
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1434
    end_trans()
1435 1436 1437 1438 1439 1440 1441
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1442
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
1443 1444 1445
{
  bool do_release= 0;
  int res= 0;
1446
  DBUG_ENTER("end_trans");
1447

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

1498 1499 1500
  if (res < 0)
    my_error(thd->killed_errno(), MYF(0));
  else if ((res == 0) && do_release)
serg@serg.mylan's avatar
serg@serg.mylan committed
1501 1502
    thd->killed= THD::KILL_CONNECTION;

1503 1504
  DBUG_RETURN(res);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1505

1506
#ifndef EMBEDDED_LIBRARY
1507 1508

/*
1509
  Read one command from connection and execute it (query or simple command).
1510 1511 1512 1513 1514 1515 1516 1517
  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)
*/

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1518 1519
bool do_command(THD *thd)
{
1520
  char *packet= 0;
1521
  ulong packet_length;
1522
  NET *net= &thd->net;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1523 1524 1525
  enum enum_server_command command;
  DBUG_ENTER("do_command");

1526 1527 1528 1529
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1530
  thd->lex->current_select= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1531

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

1540
  thd->clear_error();				// Clear error message
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1541 1542 1543 1544

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1545 1546 1547 1548 1549
    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)
1550 1551
    {
      statistic_increment(aborted_threads,&LOCK_status);
1552
      DBUG_RETURN(TRUE);			// We have to close it.
1553
    }
1554
    net_send_error(thd, net->last_errno, NullS);
1555
    net->error= 0;
1556
    DBUG_RETURN(FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1557 1558 1559 1560 1561
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1562 1563
    if (command >= COM_END)
      command= COM_END;				// Wrong command
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1564 1565 1566
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1567
  }
1568 1569 1570 1571

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

1572 1573 1574 1575 1576 1577 1578 1579 1580
  /*
    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.
  */
1581
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1582
}
1583
#endif  /* EMBEDDED_LIBRARY */
1584

1585

1586 1587
/*
   Perform one connection-level (COM_XXXX) command.
1588

1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
  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
*/
1602

1603 1604 1605 1606
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1607
  bool error= 0;
1608 1609
  DBUG_ENTER("dispatch_command");

1610
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
1611
  {
1612
    thd->killed= THD::NOT_KILLED;
1613 1614
    thd->mysys_var->abort= 0;
  }
1615

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

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

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

1691
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1692
    char *user= (char*) packet;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1693
    char *passwd= strend(user)+1;
1694
    /*
1695 1696 1697 1698
      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).
    */
gluh@mysql.com/gluh.(none)'s avatar
gluh@mysql.com/gluh.(none) committed
1699
    char db_buff[NAME_LEN+1];               // buffer to store db in utf8
1700
    char *db= passwd;
1701
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
1702 1703
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1704
#ifndef EMBEDDED_LIBRARY
1705
    /* Small check for incoming packet */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1706
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1707
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1708
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1709 1710
      break;
    }
1711
#endif
1712
    /* Convert database name to utf8 */
1713
    uint dummy_errors;
1714 1715
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1716
                             thd->charset(), &dummy_errors)]= 0;
1717
    db= db_buff;
peter@mysql.com's avatar
peter@mysql.com committed
1718

1719 1720 1721
    /* Save user and privileges */
    uint save_db_length= thd->db_length;
    char *save_db= thd->db;
1722
    Security_context save_security_ctx= *thd->security_ctx;
1723
    USER_CONN *save_user_connect= thd->user_connect;
1724 1725

    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
1726
    {
1727
      thd->security_ctx->user= save_security_ctx.user;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1728
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1729 1730
      break;
    }
peter@mysql.com's avatar
peter@mysql.com committed
1731

1732 1733
    /* Clear variables that are allocated */
    thd->user_connect= 0;
monty@mysql.com's avatar
monty@mysql.com committed
1734
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
peter@mysql.com's avatar
peter@mysql.com committed
1735

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

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

1802
    mysql_parse(thd,thd->query, thd->query_length);
1803

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

1816
      log_slow_statement(thd);
1817

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1834 1835 1836 1837 1838
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1839
  case COM_FIELD_LIST:				// This isn't actually needed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1840
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1841 1842
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1843 1844 1845
    break;
#else
  {
1846
    char *fields, *pend;
1847
    /* Locked closure of all tables */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1848
    TABLE_LIST table_list;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1849
    LEX_STRING conv_name;
1850

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1851 1852
    /* used as fields initializator */
    lex_start(thd, 0, 0);
1853

1854 1855
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1856
    bzero((char*) &table_list,sizeof(table_list));
1857
    if (thd->copy_db_to(&table_list.db, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1858
      break;
1859
    pend= strend(packet);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1860 1861
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1862
    table_list.alias= table_list.table_name= conv_name.str;
1863
    packet= pend+1;
1864 1865

    if (!my_strcasecmp(system_charset_info, table_list.db,
1866
                       INFORMATION_SCHEMA_NAME.str))
1867 1868 1869 1870 1871 1872
    {
      ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, table_list.alias);
      if (schema_table)
        table_list.schema_table= schema_table;
    }

1873
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
1874 1875
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1876
    mysql_log.write(thd,command,"%s %s",table_list.table_name, fields);
1877
    if (lower_case_table_names)
1878 1879
      my_casedn_str(files_charset_info, table_list.table_name);
    remove_escape(table_list.table_name);	// This can't have wildcards
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1880

monty@mysql.com's avatar
monty@mysql.com committed
1881
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
1882
		     0, 0, test(table_list.schema_table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1883
      break;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1884 1885
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1886
      break;
1887 1888 1889 1890 1891 1892
    /* init structures for VIEW processing */
    table_list.select_lex= &(thd->lex->select_lex);
    mysql_init_query(thd, (uchar*)"", 0);
    thd->lex->
      select_lex.table_list.link_in_list((byte*) &table_list,
                                         (byte**) &table_list.next_local);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1893
    thd->lex->add_to_query_tables(&table_list);
1894

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

1910
  case COM_CREATE_DB:				// QQ: To be removed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1911
    {
1912
      char *db=thd->strdup(packet), *alias;
1913
      HA_CREATE_INFO create_info;
1914

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

1961
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1962
      thd->enable_slow_log= opt_log_slow_admin_statements;
1963
      if (check_global_access(thd, REPL_SLAVE_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1964
	break;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1965

1966
      /* TODO: The following has to be changed to an 8 byte integer */
1967 1968
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
1969
      thd->server_id=0; /* avoid suicide */
1970
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
1971
	kill_zombie_dump_threads(slave_server_id);
1972
      thd->server_id = slave_server_id;
monty@mysql.com's avatar
monty@mysql.com committed
1973 1974 1975

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

    STATUS_VAR current_global_status_var;
    calc_sum_of_all_status(&current_global_status_var);

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

    switch (opt_command) {
    case (int) MYSQL_OPTION_MULTI_STATEMENTS_ON:
2100
      thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
2101
      send_eof(thd);
2102
      break;
2103
    case (int) MYSQL_OPTION_MULTI_STATEMENTS_OFF:
2104
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
2105
      send_eof(thd);
2106 2107
      break;
    default:
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2108
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
2109 2110 2111 2112
      break;
    }
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2113
  case COM_DEBUG:
2114
    statistic_increment(thd->status_var.com_other, &LOCK_status);
2115
    if (check_global_access(thd, SUPER_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2116
      break;					/* purecov: inspected */
2117
    mysql_print_status();
2118
    mysql_log.write(thd,command,NullS);
2119
    send_eof(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2120 2121 2122 2123 2124
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
2125
  case COM_END:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2126
  default:
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2127
    my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2128 2129
    break;
  }
2130 2131
  if (thd->lock || thd->open_tables || thd->derived_tables ||
      thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2132 2133 2134 2135
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }
2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
  /*
    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())
2146
    thd->transaction.xid_state.xid.null();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2147

2148 2149 2150
  /* report error issued during command execution */
  if (thd->killed_errno() && !thd->net.report_error)
    thd->send_kill_message();
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2151
  if (thd->net.report_error)
2152
    net_send_error(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2153

2154
  log_slow_statement(thd);
2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169

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


2170
void log_slow_statement(THD *thd)
2171
{
2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
  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;
2183
  thd->end_time();				// Set start time
2184

2185 2186 2187 2188 2189
  /*
    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)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2190
  {
2191 2192
    thd->proc_info="logging slow query";

2193 2194
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2195
        (thd->server_status &
2196
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2197 2198 2199
        (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES) &&
        /* == SQLCOM_END unless this is a SHOW command */
        thd->lex->orig_sql_command == SQLCOM_END)
2200
    {
2201
      thd->status_var.long_query_count++;
2202 2203
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2204 2205 2206
  }
}

2207

2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
/*
  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.
*/

2236 2237 2238 2239
int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
                         enum enum_schema_tables schema_table_idx)
{
  DBUG_ENTER("prepare_schema_table");
2240 2241
  SELECT_LEX *schema_select_lex= NULL;

2242
  switch (schema_table_idx) {
2243 2244
  case SCH_SCHEMATA:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2245 2246
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0));   /* purecov: inspected */
2247 2248 2249 2250
    DBUG_RETURN(1);
#else
    break;
#endif
2251

2252 2253 2254
  case SCH_TABLE_NAMES:
  case SCH_TABLES:
  case SCH_VIEWS:
2255
  case SCH_TRIGGERS:
2256
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2257 2258
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2259 2260
    DBUG_RETURN(1);
#else
2261 2262
    if (lex->select_lex.db == NULL &&
        thd->copy_db_to(&lex->select_lex.db, NULL))
2263
    {
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275
      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);
2276
    }
2277 2278 2279


    break;
2280 2281 2282 2283
#endif
  case SCH_COLUMNS:
  case SCH_STATISTICS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2284 2285
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2286 2287 2288
    DBUG_RETURN(1);
#else
    {
2289 2290
      DBUG_ASSERT(table_ident);

2291
      TABLE_LIST **query_tables_last= lex->query_tables_last;
2292
      schema_select_lex= new SELECT_LEX();
2293
      /* 'parent_lex' is used in init_query() so it must be before it. */
2294 2295 2296 2297
      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))
2298 2299
        DBUG_RETURN(1);
      lex->query_tables_last= query_tables_last;
2300 2301 2302 2303 2304

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

2305 2306 2307
      break;
    }
#endif
2308 2309 2310
  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330
  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;
2331
  table_list->schema_select_lex= schema_select_lex;
2332
  table_list->schema_table_reformed= 1;
2333 2334
  statistic_increment(thd->status_var.com_stat[lex->orig_sql_command],
                      &LOCK_status);
2335 2336 2337 2338
  DBUG_RETURN(0);
}


2339 2340
/*
  Read query from packet and store in thd->query
2341
  Used in COM_QUERY and COM_STMT_PREPARE
2342 2343 2344 2345 2346 2347 2348

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
2349 2350
    FALSE ok
    TRUE  error;  In this case thd->fatal_error is set
2351 2352
*/

2353
bool alloc_query(THD *thd, const char *packet, uint packet_length)
2354 2355
{
  packet_length--;				// Remove end null
2356
  /* Remove garbage at start and end of query */
2357
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
2358 2359 2360 2361
  {
    packet++;
    packet_length--;
  }
2362
  const char *pos= packet + packet_length;     // Point at end null
peter@mysql.com's avatar
peter@mysql.com committed
2363
  while (packet_length > 0 &&
2364
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
2365 2366 2367 2368 2369
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
monty@mysql.com's avatar
monty@mysql.com committed
2370
  thd->query_length= 0;                        // Extra safety: Avoid races
2371 2372
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
2373 2374
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
2375
    return TRUE;
2376 2377
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
2378 2379 2380 2381

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

2383
  return FALSE;
2384 2385
}

2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398
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;
2399
  thd->variables.lc_time_names= &my_locale_en_US;
2400 2401 2402
  thd->one_shot_set= 0;
}

2403

2404
/*
2405
  Execute command saved in thd and lex->sql_command
2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426

  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
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2427

2428
bool
2429
mysql_execute_command(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2430
{
2431 2432
  bool res= FALSE;
  bool need_start_waiting= FALSE; // have protection against global read lock
2433
  int  up_result= 0;
2434
  LEX  *lex= thd->lex;
monty@mysql.com's avatar
monty@mysql.com committed
2435
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2436
  SELECT_LEX *select_lex= &lex->select_lex;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2437
  /* first table of first SELECT_LEX */
monty@mysql.com's avatar
monty@mysql.com committed
2438
  TABLE_LIST *first_table= (TABLE_LIST*) select_lex->table_list.first;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2439 2440 2441
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
2442
  SELECT_LEX_UNIT *unit= &lex->unit;
2443
  /* Saved variable value */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2444
  DBUG_ENTER("mysql_execute_command");
2445
  thd->net.no_send_error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2446

2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460
  /*
    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;

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476
  /*
    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();
2477
  /* should be assigned after making first tables same */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2478
  all_tables= lex->query_tables;
2479 2480 2481 2482
  /* 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);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2483

2484 2485 2486 2487 2488
  /*
    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.
2489
    Don't reset warnings when executing a stored routine.
2490
  */
2491
  if ((all_tables || &lex->select_lex != lex->all_selects_list ||
2492
       lex->sroutines.records) && !thd->spcont ||
2493
      lex->time_zone_tables_used)
monty@mysql.com's avatar
monty@mysql.com committed
2494
    mysql_reset_errors(thd, 0);
2495

hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
2496
#ifdef HAVE_REPLICATION
2497
  if (unlikely(thd->slave_thread))
2498
  {
2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522
    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;
    }
    
peter@mysql.com's avatar
peter@mysql.com committed
2523
    /*
2524 2525
      Check if statment should be skipped because of slave filtering
      rules
2526 2527

      Exceptions are:
2528 2529
      - UPDATE MULTI: For this statement, we want to check the filtering
        rules later in the code
2530
      - SET: we always execute it (Not that many SET commands exists in
lars@mysql.com's avatar
lars@mysql.com committed
2531 2532
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
2533 2534
      - DROP TEMPORARY TABLE IF EXISTS: we always execute it (otherwise we
        have stale files on slave caused by exclusion of one tmp table).
monty@hundin.mysql.fi's avatar
merge  
monty@hundin.mysql.fi committed
2535
    */
2536 2537
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
	!(lex->sql_command == SQLCOM_SET_OPTION) &&
2538
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2539
          lex->drop_temporary && lex->drop_if_exists) &&
guilhem@mysql.com's avatar
Merge  
guilhem@mysql.com committed
2540
        all_tables_not_ok(thd, all_tables))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2541 2542
    {
      /* we warn the slave SQL thread */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2543
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
      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);
      }
2561
      DBUG_RETURN(0);
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2562
    }
2563
  }
2564
  else
2565
  {
2566
#endif /* HAVE_REPLICATION */
2567 2568 2569 2570 2571
    /*
      When option readonly is set deny operations which change non-temporary
      tables. Except for the replication thread and the 'super' users.
    */
    if (opt_readonly &&
2572 2573 2574 2575 2576 2577 2578
        !(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)))
2579 2580 2581 2582 2583 2584 2585
    {
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
      DBUG_RETURN(-1);
    }
#ifdef HAVE_REPLICATION
  } /* endif unlikely slave */
#endif
2586 2587 2588
  if(lex->orig_sql_command == SQLCOM_END)
    statistic_increment(thd->status_var.com_stat[lex->sql_command],
                        &LOCK_status);
2589

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2590 2591 2592
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2593 2594 2595 2596
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
2597 2598
	param->select_limit=
          new Item_int((ulonglong)thd->variables.select_limit);
2599 2600
    }

2601
    select_result *sel_result=lex->result;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2602
    if (all_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2603
    {
2604 2605 2606 2607 2608 2609
      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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2610 2611
    }
    else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2612 2613
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
2614
			any_db, 0, 0, 0, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2615
    if (res)
2616
      goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2617

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2618
    if (!(res= open_and_lock_tables(thd, all_tables)))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2619
    {
2620
      if (lex->describe)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2621
      {
2622 2623 2624 2625 2626 2627
        /*
          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.
        */
2628
	if (!(sel_result= new select_send()))
2629
	  goto error;
2630
	else
2631 2632
	  thd->send_explain_fields(sel_result);
	res= mysql_explain_union(thd, &thd->lex->unit, sel_result);
2633 2634 2635 2636 2637
	if (lex->describe & DESCRIBE_EXTENDED)
	{
	  char buff[1024];
	  String str(buff,(uint32) sizeof(buff), system_charset_info);
	  str.length(0);
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
2638
	  thd->lex->unit.print(&str);
2639 2640 2641 2642
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2643 2644
	sel_result->send_eof();
        delete sel_result;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2645 2646 2647
      }
      else
      {
2648
	if (!sel_result && !(sel_result= new select_send()))
2649
          goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2650
	query_cache_store_query(thd, all_tables);
2651 2652 2653
	res= handle_select(thd, lex, sel_result, 0);
        if (sel_result != lex->result)
          delete sel_result;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2654
      }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2655
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2656 2657
    break;
  }
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2658
  case SQLCOM_PREPARE:
2659
  {
2660
    mysql_sql_stmt_prepare(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2661 2662 2663 2664
    break;
  }
  case SQLCOM_EXECUTE:
  {
2665
    mysql_sql_stmt_execute(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2666 2667 2668 2669
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2670
    mysql_sql_stmt_close(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2671 2672
    break;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2673
  case SQLCOM_DO:
2674 2675
    if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
        open_and_lock_tables(thd, all_tables))
2676
      goto error;
2677 2678

    res= mysql_do(thd, *lex->insert_list);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2679 2680
    break;

2681
  case SQLCOM_EMPTY_QUERY:
2682
    send_ok(thd);
2683 2684
    break;

2685 2686 2687 2688
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2689
#ifndef EMBEDDED_LIBRARY
2690
  case SQLCOM_PURGE:
2691
  {
2692
    if (check_global_access(thd, SUPER_ACL))
2693
      goto error;
monty@mysql.com's avatar
monty@mysql.com committed
2694
    /* PURGE MASTER LOGS TO 'file' */
2695 2696 2697
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2698 2699
  case SQLCOM_PURGE_BEFORE:
  {
2700 2701
    Item *it;

2702 2703
    if (check_global_access(thd, SUPER_ACL))
      goto error;
monty@mysql.com's avatar
monty@mysql.com committed
2704
    /* PURGE MASTER LOGS BEFORE 'data' */
2705
    it= (Item *)lex->value_list.head();
2706
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
2707
        it->check_cols(1))
2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718
    {
      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());
2719 2720
    break;
  }
2721
#endif
2722 2723
  case SQLCOM_SHOW_WARNS:
  {
2724 2725
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2726 2727 2728
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
2729 2730 2731 2732
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2733 2734
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
2735 2736
    break;
  }
2737 2738
  case SQLCOM_SHOW_NEW_MASTER:
  {
2739
    if (check_global_access(thd, REPL_SLAVE_ACL))
2740
      goto error;
2741
    /* This query don't work now. See comment in repl_failsafe.cc */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2742
#ifndef WORKING_NEW_MASTER
2743 2744
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "SHOW NEW MASTER");
    goto error;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2745
#else
2746 2747
    res = show_new_master(thd);
    break;
2748
#endif
2749
  }
2750

2751
#ifdef HAVE_REPLICATION
2752 2753
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
2754
    if (check_global_access(thd, REPL_SLAVE_ACL))
2755 2756 2757 2758
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
2759 2760
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
2761
    if (check_global_access(thd, REPL_SLAVE_ACL))
2762
      goto error;
2763
    res = mysql_show_binlog_events(thd);
2764 2765
    break;
  }
2766 2767
#endif

2768
  case SQLCOM_BACKUP_TABLE:
2769
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2770 2771 2772
    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) ||
2773
	check_global_access(thd, FILE_ACL))
2774
      goto error; /* purecov: inspected */
2775
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2776
    res = mysql_backup_table(thd, first_table);
2777
    select_lex->table_list.first= (byte*) first_table;
2778
    lex->query_tables=all_tables;
2779 2780
    break;
  }
2781
  case SQLCOM_RESTORE_TABLE:
2782
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2783 2784 2785
    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) ||
2786
	check_global_access(thd, FILE_ACL))
2787
      goto error; /* purecov: inspected */
2788
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2789
    res = mysql_restore_table(thd, first_table);
2790
    select_lex->table_list.first= (byte*) first_table;
2791
    lex->query_tables=all_tables;
2792 2793
    break;
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2794 2795
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2796 2797 2798
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
2799 2800
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2801
      goto error;
2802
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2803 2804
    break;
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2805 2806
  case SQLCOM_PRELOAD_KEYS:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2807 2808 2809
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
2810 2811
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
2812
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2813
    res = mysql_preload_keys(thd, first_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2814 2815
    break;
  }
2816
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2817
  case SQLCOM_CHANGE_MASTER:
2818
  {
2819
    if (check_global_access(thd, SUPER_ACL))
2820
      goto error;
2821
    pthread_mutex_lock(&LOCK_active_mi);
2822
    res = change_master(thd,active_mi);
2823
    pthread_mutex_unlock(&LOCK_active_mi);
2824 2825
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2826
  case SQLCOM_SHOW_SLAVE_STAT:
2827
  {
2828 2829
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2830
      goto error;
2831
    pthread_mutex_lock(&LOCK_active_mi);
2832
    res = show_master_info(thd,active_mi);
2833
    pthread_mutex_unlock(&LOCK_active_mi);
2834 2835
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2836
  case SQLCOM_SHOW_MASTER_STAT:
2837
  {
2838 2839
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2840 2841 2842 2843
      goto error;
    res = show_binlog_info(thd);
    break;
  }
peter@mysql.com's avatar
peter@mysql.com committed
2844

2845
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
2846
    if (check_global_access(thd, SUPER_ACL))
2847
      goto error;
2848
    if (end_active_trans(thd))
2849
      goto error;
2850 2851
    else
      res = load_master_data(thd);
2852
    break;
2853
#endif /* HAVE_REPLICATION */
2854 2855 2856 2857 2858 2859 2860
#ifdef HAVE_NDBCLUSTER_DB
  case SQLCOM_SHOW_NDBCLUSTER_STATUS:
    {
      res = ndbcluster_show_status(thd);
      break;
    }
#endif
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2861 2862 2863
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
2864
      if (check_global_access(thd, SUPER_ACL))
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2865 2866 2867 2868
	goto error;
      res = innodb_show_status(thd);
      break;
    }
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2869 2870 2871
  case SQLCOM_SHOW_MUTEX_STATUS:
    {
      if (check_global_access(thd, SUPER_ACL))
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2872
        goto error;
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2873 2874 2875
      res = innodb_mutex_show_status(thd);
      break;
    }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2876
#endif
2877
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2878
  case SQLCOM_LOAD_MASTER_TABLE:
2879
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2880
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
2881 2882
    DBUG_ASSERT(first_table->db); /* Must be set in the parser */

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2883
    if (check_access(thd, CREATE_ACL, first_table->db,
2884 2885
		     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2886 2887 2888 2889
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2890
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2891
	goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2892
    }
2893
    if (strlen(first_table->table_name) > NAME_LEN)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2894
    {
2895
      my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2896 2897
      break;
    }
2898
    pthread_mutex_lock(&LOCK_active_mi);
2899 2900 2901 2902
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2903
    if (!fetch_master_table(thd, first_table->db, first_table->table_name,
2904
			    active_mi, 0, 0))
2905
    {
2906
      send_ok(thd);
2907
    }
2908
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2909
    break;
2910
  }
2911
#endif /* HAVE_REPLICATION */
2912

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2913
  case SQLCOM_CREATE_TABLE:
2914
  {
2915
    /* If CREATE TABLE of non-temporary table, do implicit commit */
2916 2917 2918 2919 2920 2921 2922 2923 2924 2925
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
    {
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
    else 
    {
2926
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
2927
      thd->no_trans_update.all= TRUE;
2928
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2929 2930 2931 2932 2933
    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;
2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947
    /*
      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;
2948
      goto end_with_restore_list;
2949
    }
monty@mysql.com's avatar
monty@mysql.com committed
2950

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2951
    if ((res= create_table_precheck(thd, select_tables, create_table)))
monty@mysql.com's avatar
monty@mysql.com committed
2952
      goto end_with_restore_list;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2953

2954
    create_info.alias= create_table->alias;
2955

2956
#ifndef HAVE_READLINK
2957
    if (create_info.data_file_name)
2958 2959
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                   "DATA DIRECTORY option ignored");
2960
    if (create_info.index_file_name)
2961 2962
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                   "INDEX DIRECTORY option ignored");
2963
    create_info.data_file_name= create_info.index_file_name= NULL;
2964
#else
2965
    /* Fix names if symlinked tables */
2966
    if (append_file_to_dir(thd, &create_info.data_file_name,
2967
			   create_table->table_name) ||
2968
	append_file_to_dir(thd, &create_info.index_file_name,
2969
			   create_table->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
2970
      goto end_with_restore_list;
2971
#endif
2972
    /*
2973
      If we are using SET CHARSET without DEFAULT, add an implicit
2974 2975
      DEFAULT to not confuse old users. (This may change).
    */
2976
    if ((create_info.used_fields &
2977 2978 2979
	 (HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) ==
	HA_CREATE_USED_CHARSET)
    {
2980 2981 2982 2983
      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;
2984
    }
2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
    /*
      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.
    */
2998 2999
    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
3000
    {
monty@mysql.com's avatar
monty@mysql.com committed
3001 3002
      res= 1;
      goto end_with_restore_list;
3003
    }
3004
    if (select_lex->item_list.elements)		// With select
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3005
    {
3006
      select_result *sel_result;
3007

3008
      select_lex->options|= SELECT_NO_UNLOCK;
3009
      unit->set_limit(select_lex);
3010

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3011
      if (!(res= open_and_lock_tables(thd, select_tables)))
3012
      {
3013 3014 3015 3016
        /*
          Is table which we are changing used somewhere in other parts
          of query
        */
3017
        if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
3018
        {
3019
          TABLE_LIST *duplicate;
3020
          if ((duplicate= unique_table(thd, create_table, select_tables, 0)))
3021 3022 3023
          {
            update_non_unique_table_error(create_table, "CREATE", duplicate);
            res= 1;
3024
            goto end_with_restore_list;
3025
          }
3026
        }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3027
        /* If we create merge table, we have to test tables in merge, too */
3028
        if (create_info.used_fields & HA_CREATE_USED_UNION)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3029 3030
        {
          TABLE_LIST *tab;
3031
          for (tab= (TABLE_LIST*) create_info.merge_list.first;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3032 3033 3034
               tab;
               tab= tab->next_local)
          {
3035
            TABLE_LIST *duplicate;
3036
            if ((duplicate= unique_table(thd, tab, select_tables, 0)))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3037
            {
3038
              update_non_unique_table_error(tab, "CREATE", duplicate);
monty@mysql.com's avatar
monty@mysql.com committed
3039
              res= 1;
3040
              goto end_with_restore_list;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3041 3042 3043
            }
          }
        }
3044 3045 3046 3047
        /*
          select_create is currently not re-execution friendly and
          needs to be created for every execution of a PS/SP.
        */
3048
        if ((sel_result= new select_create(create_table,
3049 3050
                                           &create_info,
                                           &alter_info,
3051 3052 3053
                                           select_lex->item_list,
                                           lex->duplicates,
                                           lex->ignore)))
3054 3055 3056 3057 3058
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
3059 3060
          res= handle_select(thd, lex, sel_result, 0);
          delete sel_result;
3061
        }
3062 3063
      }
    }
monty@mysql.com's avatar
monty@mysql.com committed
3064
    else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3065
    {
monty@mysql.com's avatar
monty@mysql.com committed
3066
      /* regular create */
venu@myvenu.com's avatar
venu@myvenu.com committed
3067
      if (lex->name)
3068
        res= mysql_create_like_table(thd, create_table, &create_info,
3069
                                     (Table_ident *)lex->name);
venu@myvenu.com's avatar
venu@myvenu.com committed
3070
      else
3071
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3072
        res= mysql_create_table(thd, create_table->db,
3073
                                create_table->table_name, &create_info,
3074
                                &alter_info, 0, 0);
3075
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3076
      if (!res)
3077
	send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3078
    }
3079

monty@mysql.com's avatar
monty@mysql.com committed
3080
    /* put tables back for PS rexecuting */
monty@mysql.com's avatar
monty@mysql.com committed
3081
end_with_restore_list:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3082
    lex->link_first_table_back(create_table, link_to_local);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3083
    break;
3084
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3085
  case SQLCOM_CREATE_INDEX:
3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106
    /* 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;

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3107
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3108
    if (check_one_table_access(thd, INDEX_ACL, first_table))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3109
      goto error; /* purecov: inspected */
3110
    if (end_active_trans(thd))
3111
      goto error;
3112 3113 3114 3115 3116 3117
    /*
      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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3118

3119 3120
    bzero((char*) &create_info, sizeof(create_info));
    create_info.db_type= DB_TYPE_DEFAULT;
kostja@bodhi.local's avatar
kostja@bodhi.local committed
3121
    create_info.row_type= ROW_TYPE_NOT_USED;
3122
    create_info.default_table_charset= thd->variables.collation_database;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3123

3124
    res= mysql_alter_table(thd, first_table->db, first_table->table_name,
3125
                           &create_info, first_table, &alter_info,
3126
                           0, (ORDER*) 0, 0);
3127 3128
    break;
  }
3129
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3130
  case SQLCOM_SLAVE_START:
3131
  {
3132
    pthread_mutex_lock(&LOCK_active_mi);
3133
    start_slave(thd,active_mi,1 /* net report*/);
3134
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3135
    break;
3136
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3137
  case SQLCOM_SLAVE_STOP:
3138 3139 3140 3141 3142 3143
  /*
    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,
3144
      so it waits for the client thread because t is locked by it.
3145
    - then the client thread does SLAVE STOP.
3146 3147
      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.
3148 3149 3150
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
3151
  if (thd->locked_tables || thd->active_transaction() || thd->global_read_lock)
3152
  {
3153 3154
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3155
    goto error;
3156
  }
3157
  {
3158
    pthread_mutex_lock(&LOCK_active_mi);
3159
    stop_slave(thd,active_mi,1/* net report*/);
3160
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3161
    break;
3162
  }
3163
#endif /* HAVE_REPLICATION */
3164

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3165
  case SQLCOM_ALTER_TABLE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3166
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3167
    {
3168
      ulong priv=0;
3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179
      /*
        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;
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
3180
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3181
      {
3182
	my_error(ER_WRONG_TABLE_NAME, MYF(0), lex->name);
3183
        goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3184
      }
3185 3186
      /* Must be set in the parser */
      DBUG_ASSERT(select_lex->db);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3187
      if (check_access(thd, ALTER_ACL, first_table->db,
3188 3189 3190 3191
		       &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))||
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3192
	  check_merge_table_access(thd, first_table->db,
3193
				   (TABLE_LIST *)
3194
				   create_info.merge_list.first))
3195
	goto error;				/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3196 3197
      if (grant_option)
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3198
	if (check_grant(thd, ALTER_ACL, all_tables, 0, UINT_MAX, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3199 3200 3201 3202 3203
	  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));
3204
	  tmp_table.table_name=lex->name;
3205
	  tmp_table.db=select_lex->db;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3206
	  tmp_table.grant.privilege=priv;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3207 3208
	  if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0,
			  UINT_MAX, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3209 3210 3211
	    goto error;
	}
      }
3212
      /* Don't yet allow changing of symlinks with ALTER TABLE */
3213
      if (create_info.data_file_name)
3214 3215
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                     "DATA DIRECTORY option ignored");
3216
      if (create_info.index_file_name)
3217 3218
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                     "INDEX DIRECTORY option ignored");
3219
      create_info.data_file_name= create_info.index_file_name= NULL;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3220
      /* ALTER TABLE ends previous transaction */
3221
      if (end_active_trans(thd))
3222
	goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3223
      else
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3224
      {
3225 3226 3227 3228 3229 3230 3231
        if (!thd->locked_tables &&
            !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
        {
          res= 1;
          break;
        }

3232
        thd->enable_slow_log= opt_log_slow_admin_statements;
3233 3234
        res= mysql_alter_table(thd, select_lex->db, lex->name,
                               &create_info,
3235
                               first_table,
3236 3237
                               &alter_info,
                               select_lex->order_list.elements,
3238
                               (ORDER *) select_lex->order_list.first,
3239
                               lex->ignore);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3240
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3241 3242
      break;
    }
3243
  case SQLCOM_RENAME_TABLE:
3244
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3245
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3246
    TABLE_LIST *table;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3247
    if (check_db_used(thd, all_tables))
3248
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3249
    for (table= first_table; table; table= table->next_local->next_local)
3250
    {
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3251
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
3252
		       &table->grant.privilege,0,0, test(table->schema_table)) ||
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3253
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next_local->db,
3254 3255
		       &table->next_local->grant.privilege, 0, 0,
                       test(table->next_local->schema_table)))
3256 3257 3258
	goto error;
      if (grant_option)
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3259
	TABLE_LIST old_list, new_list;
3260 3261 3262 3263
	/*
	  we do not need initialize old_list and new_list because we will
	  come table[0] and table->next[0] there
	*/
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3264 3265
	old_list= table[0];
	new_list= table->next_local[0];
3266
	if (check_grant(thd, ALTER_ACL | DROP_ACL, &old_list, 0, 1, 0) ||
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3267
	    (!test_all_bits(table->next_local->grant.privilege,
3268
			    INSERT_ACL | CREATE_ACL) &&
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3269
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0, 1, 0)))
3270 3271 3272
	  goto error;
      }
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3273
    query_cache_invalidate3(thd, first_table, 0);
3274 3275
    if (end_active_trans(thd) || mysql_rename_tables(thd, first_table))
      goto error;
3276
    break;
3277
  }
3278
#ifndef EMBEDDED_LIBRARY
3279 3280
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3281 3282
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3283
    goto error;
3284 3285
#else
    {
3286
      if (check_global_access(thd, SUPER_ACL))
3287 3288 3289 3290
	goto error;
      res = show_binlogs(thd);
      break;
    }
peter@mysql.com's avatar
peter@mysql.com committed
3291
#endif
3292
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3293
  case SQLCOM_SHOW_CREATE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3294
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3295
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3296 3297
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3298
    goto error;
3299
#else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3300
    {
3301 3302 3303 3304
      /* Ignore temporary tables if this is "SHOW CREATE VIEW" */
      if (lex->only_view)
        first_table->skip_temporary= 1;

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3305 3306
      if (check_db_used(thd, all_tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, first_table->db,
3307 3308
		       &first_table->grant.privilege, 0, 0, 
                       test(first_table->schema_table)))
3309
	goto error;
monty@mishka.local's avatar
monty@mishka.local committed
3310
      if (grant_option && check_grant(thd, SELECT_ACL, all_tables, 2, UINT_MAX, 0))
3311
	goto error;
monty@mishka.local's avatar
monty@mishka.local committed
3312
      res= mysqld_show_create(thd, first_table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3313 3314
      break;
    }
3315
#endif
3316 3317
  case SQLCOM_CHECKSUM:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3318 3319 3320
    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))
3321
      goto error; /* purecov: inspected */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3322
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
3323 3324
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3325
  case SQLCOM_REPAIR:
3326
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3327 3328 3329
    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))
3330
      goto error; /* purecov: inspected */
3331
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3332
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
3333 3334 3335
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3336
      /* Presumably, REPAIR and binlog writing doesn't require synchronization */
3337 3338
      if (mysql_bin_log.is_open())
      {
3339
	thd->clear_error(); // No binlog error generated
3340
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3341 3342 3343
        mysql_bin_log.write(&qinfo);
      }
    }
3344
    select_lex->table_list.first= (byte*) first_table;
3345
    lex->query_tables=all_tables;
3346 3347
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3348
  case SQLCOM_CHECK:
3349
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3350 3351 3352
    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))
3353
      goto error; /* purecov: inspected */
3354
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3355
    res = mysql_check_table(thd, first_table, &lex->check_opt);
3356
    select_lex->table_list.first= (byte*) first_table;
3357
    lex->query_tables=all_tables;
3358 3359
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3360 3361
  case SQLCOM_ANALYZE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3362 3363 3364
    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))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3365
      goto error; /* purecov: inspected */
3366
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3367
    res = mysql_analyze_table(thd, first_table, &lex->check_opt);
3368 3369 3370
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3371
      /* Presumably, ANALYZE and binlog writing doesn't require synchronization */
3372 3373
      if (mysql_bin_log.is_open())
      {
3374
	thd->clear_error(); // No binlog error generated
3375
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3376 3377 3378
        mysql_bin_log.write(&qinfo);
      }
    }
3379
    select_lex->table_list.first= (byte*) first_table;
3380
    lex->query_tables=all_tables;
3381
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3382
  }
3383

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3384 3385
  case SQLCOM_OPTIMIZE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3386 3387 3388
    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))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3389
      goto error; /* purecov: inspected */
3390
    thd->enable_slow_log= opt_log_slow_admin_statements;
3391
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
3392
      mysql_recreate_table(thd, first_table) :
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3393
      mysql_optimize_table(thd, first_table, &lex->check_opt);
3394 3395 3396
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3397
      /* Presumably, OPTIMIZE and binlog writing doesn't require synchronization */
3398 3399
      if (mysql_bin_log.is_open())
      {
3400
	thd->clear_error(); // No binlog error generated
3401
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3402 3403 3404
        mysql_bin_log.write(&qinfo);
      }
    }
3405
    select_lex->table_list.first= (byte*) first_table;
3406
    lex->query_tables=all_tables;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3407 3408 3409
    break;
  }
  case SQLCOM_UPDATE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3410 3411
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (update_precheck(thd, all_tables))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3412
      break;
3413 3414
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
3415 3416 3417 3418 3419 3420 3421 3422
    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));
3423
    /* mysql_update return 2 if we need to switch to multi-update */
3424
    if (up_result != 2)
3425
      break;
3426
    /* Fall through */
3427
  case SQLCOM_UPDATE_MULTI:
3428 3429 3430
  {
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    /* if we switched from normal update, rights are checked */
3431
    if (up_result != 2)
3432
    {
3433 3434 3435 3436 3437
      if ((res= multi_update_precheck(thd, all_tables)))
        break;
    }
    else
      res= 0;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3438

3439
    res= mysql_multi_update_prepare(thd);
3440

3441
#ifdef HAVE_REPLICATION
3442
    /* Check slave filtering rules */
3443
    if (unlikely(thd->slave_thread))
3444
    {
3445 3446
      if (all_tables_not_ok(thd, all_tables))
      {
3447 3448 3449 3450 3451
        if (res!= 0)
        {
          res= 0;             /* don't care of prev failure  */
          thd->clear_error(); /* filters are of highest prior */
        }
3452 3453 3454 3455
        /* we warn the slave SQL thread */
        my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
        break;
      }
3456 3457
      if (res)
        break;
3458
    }
3459 3460
    else
    {
3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473
#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
3474

3475 3476 3477 3478 3479 3480
    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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3481
    break;
monty@mysql.com's avatar
monty@mysql.com committed
3482
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3483
  case SQLCOM_REPLACE:
3484 3485
  case SQLCOM_INSERT:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3486
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
monty@mysql.com's avatar
monty@mysql.com committed
3487
    if ((res= insert_precheck(thd, all_tables)))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3488
      break;
3489 3490 3491 3492 3493 3494 3495 3496

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3497
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
monty@mishka.local's avatar
monty@mishka.local committed
3498
		      lex->update_list, lex->value_list,
3499
                      lex->duplicates, lex->ignore);
3500 3501 3502 3503 3504 3505 3506

    /*
      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.
    */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3507
    if (first_table->view && !first_table->contain_auto_increment)
3508 3509
      thd->last_insert_id= thd->current_insert_id;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3510
    break;
3511
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3512 3513 3514
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
3515
    select_result *sel_result;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3516
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
monty@mishka.local's avatar
monty@mishka.local committed
3517
    if ((res= insert_precheck(thd, all_tables)))
3518
      break;
monty@mysql.com's avatar
monty@mysql.com committed
3519

3520
    /* Fix lock for first table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3521 3522
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
3523

3524 3525
    /* Don't unlock tables until command is written to binary log */
    select_lex->options|= SELECT_NO_UNLOCK;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3526

3527
    unit->set_limit(select_lex);
3528 3529 3530 3531 3532 3533 3534 3535

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3536
    if (!(res= open_and_lock_tables(thd, all_tables)))
3537
    {
3538
      /* Skip first table, which is the table we are inserting in */
3539 3540
      TABLE_LIST *second_table= first_table->next_local;
      select_lex->table_list.first= (byte*) second_table;
3541 3542
      select_lex->context.table_list= 
        select_lex->context.first_name_resolution_table= second_table;
3543
      res= mysql_insert_select_prepare(thd);
3544 3545 3546 3547 3548 3549 3550
      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)))
3551
      {
3552
	res= handle_select(thd, lex, sel_result, OPTION_SETUP_TABLES_DONE);
3553 3554 3555 3556 3557 3558 3559 3560 3561
        /*
          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)
        {
3562 3563 3564
          /* INSERT ... SELECT should invalidate only the very first table */
          TABLE_LIST *save_table= first_table->next_local;
          first_table->next_local= 0;
3565 3566
          mysql_unlock_tables(thd, thd->lock);
          query_cache_invalidate3(thd, first_table, 1);
3567
          first_table->next_local= save_table;
3568 3569
          thd->lock=0;
        }
3570
        delete sel_result;
3571
      }
3572
      /* revert changes for SP */
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
3573
      select_lex->table_list.first= (byte*) first_table;
3574
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3575

3576 3577 3578 3579 3580 3581
    /*
      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.
    */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3582
    if (first_table->view && !first_table->contain_auto_increment)
3583 3584
      thd->last_insert_id= thd->current_insert_id;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3585 3586
    break;
  }
3587
  case SQLCOM_TRUNCATE:
3588 3589 3590 3591 3592
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3593 3594
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
3595
      goto error;
3596 3597 3598 3599
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
3600
    if (thd->locked_tables || thd->active_transaction())
3601
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3602 3603
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3604 3605
      goto error;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3606

monty@mysql.com's avatar
monty@mysql.com committed
3607
    res= mysql_truncate(thd, first_table, 0);
3608
    break;
3609
  case SQLCOM_DELETE:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3610
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3611 3612
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= delete_precheck(thd, all_tables)))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3613
      break;
3614 3615
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
3616 3617 3618 3619 3620 3621 3622 3623

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3624
    res = mysql_delete(thd, all_tables, select_lex->where,
3625
                       &select_lex->order_list,
osku@127.(none)'s avatar
osku@127.(none) committed
3626 3627
                       unit->select_limit_cnt, select_lex->options,
                       FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3628 3629
    break;
  }
3630
  case SQLCOM_DELETE_MULTI:
3631
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3632
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3633
    TABLE_LIST *aux_tables=
3634
      (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
3635
    multi_delete *del_result;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3636

3637 3638 3639 3640 3641 3642 3643
    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
    {
      res= 1;
      break;
    }

3644
    if ((res= multi_delete_precheck(thd, all_tables)))
3645
      break;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3646

3647
    /* condition will be TRUE on SP re-excuting */
3648 3649
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3650
    if (add_item_to_list(thd, new Item_null()))
3651
      goto error;
3652

3653
    thd->proc_info="init";
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3654 3655 3656 3657
    if ((res= open_and_lock_tables(thd, all_tables)))
      break;

    if ((res= mysql_multi_delete_prepare(thd)))
3658
      goto error;
3659

3660 3661
    if (!thd->is_fatal_error &&
        (del_result= new multi_delete(aux_tables, lex->table_count)))
3662
    {
3663 3664 3665
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3666
			select_lex->item_list,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3667
			select_lex->where,
3668
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3669 3670
			(ORDER *)NULL,
			select_lex->options | thd->options |
3671 3672
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                        OPTION_SETUP_TABLES_DONE,
3673 3674
			del_result, unit, select_lex);
      delete del_result;
3675 3676
    }
    else
3677
      res= TRUE;                                // Error
3678 3679
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3680
  case SQLCOM_DROP_TABLE:
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
3681
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3682
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3683 3684
    if (!lex->drop_temporary)
    {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3685
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
3686 3687
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
3688
        goto error;
3689
    }
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
3690
    else
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3691 3692 3693 3694 3695 3696
    {
      /*
	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.
monty@mysql.com's avatar
monty@mysql.com committed
3697 3698
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3699 3700
      */
      if (thd->slave_thread)
3701
        lex->drop_if_exists= 1;
3702

3703
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
3704
      thd->no_trans_update.all= TRUE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3705
    }
3706
    /* DDL and binlog write order protected by LOCK_open */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3707 3708
    res= mysql_rm_table(thd, first_table, lex->drop_if_exists,
			lex->drop_temporary);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
3709 3710
  }
  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3711
  case SQLCOM_SHOW_PROCESSLIST:
3712 3713
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd,PROCESS_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3714
      break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
3715
    mysqld_list_processes(thd,
3716 3717 3718 3719
			  (thd->security_ctx->master_access & PROCESS_ACL ?
                           NullS :
                           thd->security_ctx->priv_user),
                          lex->verbose);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3720
    break;
3721 3722
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
3723 3724 3725 3726 3727 3728 3729
    break;
  case SQLCOM_SHOW_PRIVILEGES:
    res= mysqld_show_privileges(thd);
    break;
  case SQLCOM_SHOW_COLUMN_TYPES:
    res= mysqld_show_column_types(thd);
    break;
tim@cane.mysql.fi's avatar
tim@cane.mysql.fi committed
3730 3731
  case SQLCOM_SHOW_LOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3732 3733
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
3734
    goto error;
tim@cane.mysql.fi's avatar
tim@cane.mysql.fi committed
3735 3736
#else
    {
3737
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0,0))
tim@cane.mysql.fi's avatar
tim@cane.mysql.fi committed
3738 3739 3740 3741
	goto error;
      res= mysqld_show_logs(thd);
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3742 3743
#endif
  case SQLCOM_CHANGE_DB:
3744 3745 3746 3747
  {
    LEX_STRING db_str= { (char *) select_lex->db, strlen(select_lex->db) };

    if (!mysql_change_db(thd, &db_str, FALSE))
3748
      send_ok(thd);
3749

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3750
    break;
3751
  }
3752

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3753 3754
  case SQLCOM_LOAD:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3755
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3756
    uint privilege= (lex->duplicates == DUP_REPLACE ?
3757 3758
		     INSERT_ACL | DELETE_ACL : INSERT_ACL) |
                    (lex->local_file ? 0 : FILE_ACL);
3759

3760
    if (lex->local_file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3761
    {
3762
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
3763
          !opt_local_infile)
3764
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3765
	my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
3766 3767
	goto error;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3768
    }
3769 3770 3771 3772

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

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3773
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
3774
                    lex->update_list, lex->value_list, lex->duplicates,
3775
                    lex->ignore, (bool) lex->local_file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3776 3777
    break;
  }
3778

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3779
  case SQLCOM_SET_OPTION:
3780 3781
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
3782
    if ((check_table_access(thd, SELECT_ACL, all_tables, 0) ||
3783 3784
	 open_and_lock_tables(thd, all_tables)))
      goto error;
3785 3786
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
3787 3788
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
      goto error;
3789 3790 3791 3792 3793 3794 3795 3796
    }
    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;
3797
      send_ok(thd);
3798
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3799
    break;
3800
  }
3801

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3802
  case SQLCOM_UNLOCK_TABLES:
3803 3804 3805 3806 3807 3808
    /*
      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.
    */
3809
    unlock_locked_tables(thd);
3810 3811
    if (thd->options & OPTION_TABLE_LOCK)
    {
3812
      end_active_trans(thd);
3813
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3814 3815
    }
    if (thd->global_read_lock)
3816
      unlock_global_read_lock(thd);
3817
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3818 3819
    break;
  case SQLCOM_LOCK_TABLES:
3820
    unlock_locked_tables(thd);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3821
    if (check_db_used(thd, all_tables) || end_active_trans(thd))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3822
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3823
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3824
      goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3825
    thd->in_lock_tables=1;
3826
    thd->options|= OPTION_TABLE_LOCK;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3827

3828
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3829
    {
3830 3831
#ifdef HAVE_QUERY_CACHE
      if (thd->variables.query_cache_wlock_invalidate)
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3832
	query_cache.invalidate_locked_for_write(first_table);
3833
#endif /*HAVE_QUERY_CACHE*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3834 3835
      thd->locked_tables=thd->lock;
      thd->lock=0;
3836
      send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3837
    }
3838 3839
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3840 3841 3842
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3843
  {
3844 3845 3846 3847 3848 3849
    /*
      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);
3850 3851 3852 3853 3854
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3855
    char *alias;
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
3856
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3857
    {
3858
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3859 3860
      break;
    }
3861 3862 3863
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
3864
      For that reason, db_ok() in sql/slave.cc did not check the
3865 3866 3867
      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.
    */
3868
#ifdef HAVE_REPLICATION
3869
    if (thd->slave_thread &&
3870 3871
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3872
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3873
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3874
      break;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3875
    }
3876
#endif
3877

3878
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3879
      break;
monty@mysql.com's avatar
monty@mysql.com committed
3880
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
3881
			 &create_info, 0);
3882 3883
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3884
  case SQLCOM_DROP_DB:
3885
  {
3886 3887 3888 3889 3890
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3891
    if (check_db_name(lex->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3892
    {
3893
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3894 3895
      break;
    }
3896 3897 3898 3899 3900 3901 3902
    /*
      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.
    */
3903
#ifdef HAVE_REPLICATION
3904 3905 3906
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3907
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3908
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3909
      break;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3910
    }
3911
#endif
3912
    if (check_access(thd,DROP_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3913
      break;
3914 3915
    if (thd->locked_tables || thd->active_transaction())
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3916 3917
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3918 3919
      goto error;
    }
3920
    res= mysql_rm_db(thd, lex->name, lex->drop_if_exists, 0);
3921 3922
    break;
  }
3923 3924
  case SQLCOM_ALTER_DB:
  {
3925 3926
    char *db= lex->name;
    DBUG_ASSERT(db); /* Must be set in the parser */
3927
    if (!strip_sp(db) || check_db_name(db))
3928
    {
3929
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
3930 3931
      break;
    }
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3932 3933 3934
    /*
      If in a slave thread :
      ALTER DATABASE DB may not be preceded by USE DB.
3935
      For that reason, maybe db_ok() in sql/slave.cc did not check the
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3936 3937 3938 3939
      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
3940
    if (thd->slave_thread &&
3941 3942
	(!db_ok(db, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(db)))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3943
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3944
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3945 3946 3947
      break;
    }
#endif
3948
    if (check_access(thd, ALTER_ACL, db, 0, 1, 0, is_schema_db(db)))
3949 3950 3951
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3952 3953
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3954 3955
      goto error;
    }
3956
    res= mysql_alter_db(thd, db, &lex->create_info);
3957 3958
    break;
  }
3959 3960 3961 3962
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3963
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
3964 3965
      break;
    }
3966
    if (check_access(thd,SELECT_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3967
      break;
3968
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
3969 3970
    break;
  }
monty@mysql.com's avatar
monty@mysql.com committed
3971
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
monty@mysql.com's avatar
monty@mysql.com committed
3972
  {
3973
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0))
monty@mysql.com's avatar
monty@mysql.com committed
3974
      break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3975
#ifdef HAVE_DLOPEN
3976 3977
    if (sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                        &thd->sp_func_cache, FALSE))
monty@mysql.com's avatar
monty@mysql.com committed
3978
    {
3979
      my_error(ER_UDF_EXISTS, MYF(0), lex->spname->m_name.str);
monty@mysql.com's avatar
monty@mysql.com committed
3980 3981
      goto error;
    }
3982
    if (!(res = mysql_create_function(thd, &lex->udf)))
monty@mysql.com's avatar
monty@mysql.com committed
3983
      send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3984
#else
hf@deer.(none)'s avatar
hf@deer.(none) committed
3985
    my_error(ER_CANT_OPEN_LIBRARY, MYF(0), lex->udf.dl, 0, "feature disabled");
3986
    res= TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3987 3988
#endif
    break;
monty@mysql.com's avatar
monty@mysql.com committed
3989
  }
hf@deer.(none)'s avatar
hf@deer.(none) committed
3990
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3991 3992
  case SQLCOM_CREATE_USER:
  {
3993
    if (check_access(thd, INSERT_ACL, "mysql", 0, 1, 1, 0) &&
3994
        check_global_access(thd,CREATE_USER_ACL))
3995
      break;
3996 3997
    if (end_active_trans(thd))
      goto error;
3998
    /* Conditionally writes to binlog */
3999 4000 4001 4002
    if (!(res= mysql_create_user(thd, lex->users_list)))
      send_ok(thd);
    break;
  }
4003 4004
  case SQLCOM_DROP_USER:
  {
4005
    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 1, 0) &&
4006
        check_global_access(thd,CREATE_USER_ACL))
4007
      break;
4008 4009
    if (end_active_trans(thd))
      goto error;
4010
    /* Conditionally writes to binlog */
4011
    if (!(res= mysql_drop_user(thd, lex->users_list)))
4012 4013 4014 4015 4016
      send_ok(thd);
    break;
  }
  case SQLCOM_RENAME_USER:
  {
4017
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
4018
        check_global_access(thd,CREATE_USER_ACL))
4019
      break;
4020 4021
    if (end_active_trans(thd))
      goto error;
4022
    /* Conditionally writes to binlog */
4023
    if (!(res= mysql_rename_user(thd, lex->users_list)))
4024 4025 4026 4027 4028
      send_ok(thd);
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
4029
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
4030
        check_global_access(thd,CREATE_USER_ACL))
4031
      break;
4032
    /* Conditionally writes to binlog */
4033 4034 4035 4036
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
      send_ok(thd);
    break;
  }
4037 4038 4039 4040
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
serg@serg.mylan's avatar
serg@serg.mylan committed
4041
		     first_table ?  first_table->db : select_lex->db,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4042
		     first_table ? &first_table->grant.privilege : 0,
4043 4044 4045
		     first_table ? 0 : 1, 0,
                     first_table ? (bool) first_table->schema_table :
                     select_lex->db ? is_schema_db(select_lex->db) : 0))
4046 4047
      goto error;

4048
    if (thd->security_ctx->user)              // If not replication
4049
    {
4050
      LEX_USER *user, *tmp_user;
4051

4052
      List_iterator <LEX_USER> user_list(lex->users_list);
4053
      while ((tmp_user= user_list++))
4054
      {
4055 4056
        if (!(user= get_current_user(thd, tmp_user)))
          goto error;
4057 4058 4059 4060 4061 4062 4063 4064
        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);
4065
        if (strcmp(thd->security_ctx->user, user->user.str) ||
4066
            my_strcasecmp(system_charset_info,
4067
                          user->host.str, thd->security_ctx->host_or_ip))
4068 4069
        {
          // TODO: use check_change_password()
4070 4071
          if (is_acl_user(user->host.str, user->user.str) &&
              user->password.str &&
4072
              check_access(thd, UPDATE_ACL,"mysql",0,1,1,0))
4073 4074 4075 4076 4077 4078
          {
            my_message(ER_PASSWORD_NOT_ALLOWED,
                       ER(ER_PASSWORD_NOT_ALLOWED), MYF(0));
            goto error;
          }
        }
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
4079 4080
      }
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4081
    if (first_table)
4082
    {
4083 4084
      if (lex->type == TYPE_ENUM_PROCEDURE ||
          lex->type == TYPE_ENUM_FUNCTION)
4085 4086 4087 4088 4089
      {
        uint grants= lex->all_privileges 
		   ? (PROC_ACLS & ~GRANT_ACL) | (lex->grant & GRANT_ACL)
		   : lex->grant;
        if (grant_option && 
4090 4091
	    check_grant_routine(thd, grants | GRANT_ACL, all_tables,
                                lex->type == TYPE_ENUM_PROCEDURE, 0))
4092
	  goto error;
4093
        /* Conditionally writes to binlog */
4094 4095 4096 4097
        res= mysql_routine_grant(thd, all_tables,
                                 lex->type == TYPE_ENUM_PROCEDURE, 
                                 lex->users_list, grants,
                                 lex->sql_command == SQLCOM_REVOKE, 0);
4098 4099 4100 4101 4102 4103 4104 4105
      }
      else
      {
	if (grant_option && check_grant(thd,
					(lex->grant | lex->grant_tot_col |
					 GRANT_ACL),
					all_tables, 0, UINT_MAX, 0))
	  goto error;
4106
        /* Conditionally writes to binlog */
4107 4108 4109 4110
        res= mysql_table_grant(thd, all_tables, lex->users_list,
			       lex->columns, lex->grant,
			       lex->sql_command == SQLCOM_REVOKE);
      }
4111 4112 4113
    }
    else
    {
4114
      if (lex->columns.elements || lex->type)
4115
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4116 4117
	my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE),
                   MYF(0));
4118
        goto error;
4119 4120
      }
      else
4121
	/* Conditionally writes to binlog */
4122 4123 4124 4125
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
4126
	if (lex->sql_command == SQLCOM_GRANT)
4127
	{
4128
	  List_iterator <LEX_USER> str_list(lex->users_list);
4129 4130 4131 4132 4133
	  LEX_USER *user, *tmp_user;
	  while ((tmp_user=str_list++))
          {
            if (!(user= get_current_user(thd, tmp_user)))
              goto error;
monty@mysql.com's avatar
monty@mysql.com committed
4134
	    reset_mqh(user);
4135
          }
4136
	}
4137 4138 4139 4140
      }
    }
    break;
  }
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
4141
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4142
  case SQLCOM_RESET:
4143 4144 4145
    /*
      RESET commands are never written to the binary log, so we have to
      initialize this variable because RESET shares the same code as FLUSH
4146 4147 4148 4149
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
4150
    bool write_to_binlog;
4151
    if (check_global_access(thd,RELOAD_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4152
      goto error;
4153

4154 4155 4156 4157
    /*
      reload_acl_and_cache() will tell us if we are allowed to write to the
      binlog or not.
    */
4158
    if (!reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
4159 4160 4161 4162 4163
    {
      /*
        We WANT to write and we CAN write.
        ! we write after unlocking the table.
      */
4164
      /* Presumably, RESET and binlog writing doesn't require synchronization */
4165 4166 4167 4168
      if (!lex->no_write_to_binlog && write_to_binlog)
      {
        if (mysql_bin_log.is_open())
        {
4169
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
4170 4171 4172 4173
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
4174 4175
    } 
    
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4176
    break;
4177
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4178
  case SQLCOM_KILL:
4179 4180 4181
  {
    Item *it= (Item *)lex->value_list.head();

4182
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) || it->check_cols(1))
4183 4184 4185 4186 4187 4188
    {
      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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4189
    break;
4190
  }
hf@deer.(none)'s avatar
hf@deer.(none) committed
4191
#ifndef NO_EMBEDDED_ACCESS_CHECKS
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4192
  case SQLCOM_SHOW_GRANTS:
4193 4194 4195 4196
  {
    LEX_USER *grant_user= get_current_user(thd, lex->grant_user);
    if (!grant_user)
      goto error;
4197
    if ((thd->security_ctx->priv_user &&
4198
	 !strcmp(thd->security_ctx->priv_user, grant_user->user.str)) ||
4199
	!check_access(thd, SELECT_ACL, "mysql",0,1,0,0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4200
    {
4201
      res = mysql_show_grants(thd, grant_user);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4202 4203
    }
    break;
4204
  }
hf@deer.(none)'s avatar
hf@deer.(none) committed
4205
#endif
4206
  case SQLCOM_HA_OPEN:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4207 4208 4209
    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))
4210
      goto error;
monty@mysql.com's avatar
monty@mysql.com committed
4211
    res= mysql_ha_open(thd, first_table, 0);
4212 4213
    break;
  case SQLCOM_HA_CLOSE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4214 4215
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables))
4216
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4217
    res= mysql_ha_close(thd, first_table);
4218 4219
    break;
  case SQLCOM_HA_READ:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4220
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
4221 4222 4223 4224 4225
    /*
      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.
    */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4226
    if (check_db_used(thd, all_tables))
4227
      goto error;
4228
    unit->set_limit(select_lex);
4229
    res= mysql_ha_read(thd, first_table, lex->ha_read_mode, lex->ident.str,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4230
                       lex->insert_list, lex->ha_rkey_mode, select_lex->where,
4231
                       unit->select_limit_cnt, unit->offset_limit_cnt);
4232 4233
    break;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4234
  case SQLCOM_BEGIN:
4235 4236 4237 4238 4239 4240
    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;
    }
4241
    if (begin_trans(thd))
4242
      goto error;
serg@serg.mylan's avatar
serg@serg.mylan committed
4243
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4244 4245
    break;
  case SQLCOM_COMMIT:
4246
    if (end_trans(thd, lex->tx_release ? COMMIT_RELEASE :
serg@serg.mylan's avatar
serg@serg.mylan committed
4247
                              lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
4248
      goto error;
4249
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4250 4251
    break;
  case SQLCOM_ROLLBACK:
4252
    if (end_trans(thd, lex->tx_release ? ROLLBACK_RELEASE :
serg@serg.mylan's avatar
serg@serg.mylan committed
4253
                              lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
4254
      goto error;
4255
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4256
    break;
serg@serg.mylan's avatar
serg@serg.mylan committed
4257
  case SQLCOM_RELEASE_SAVEPOINT:
serg@serg.mylan's avatar
serg@serg.mylan committed
4258
  {
4259 4260
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
serg@serg.mylan's avatar
serg@serg.mylan committed
4261 4262 4263
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4264
                       (uchar *)sv->name, sv->length) == 0)
serg@serg.mylan's avatar
serg@serg.mylan committed
4265 4266
        break;
    }
4267
    if (sv)
serg@serg.mylan's avatar
serg@serg.mylan committed
4268
    {
4269
      if (ha_release_savepoint(thd, sv))
serg@serg.mylan's avatar
serg@serg.mylan committed
4270
        res= TRUE; // cannot happen
serg@serg.mylan's avatar
serg@serg.mylan committed
4271 4272
      else
        send_ok(thd);
4273
      thd->transaction.savepoints=sv->prev;
serg@serg.mylan's avatar
serg@serg.mylan committed
4274
    }
4275
    else
serg@serg.mylan's avatar
serg@serg.mylan committed
4276
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4277
    break;
serg@serg.mylan's avatar
serg@serg.mylan committed
4278
  }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4279
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
serg@serg.mylan's avatar
serg@serg.mylan committed
4280
  {
4281 4282
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
4283 4284 4285
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4286
                       (uchar *)sv->name, sv->length) == 0)
4287 4288
        break;
    }
4289
    if (sv)
4290
    {
4291
      if (ha_rollback_to_savepoint(thd, sv))
4292 4293
        res= TRUE; // cannot happen
      else
serg@serg.mylan's avatar
serg@serg.mylan committed
4294
      {
4295
        if (thd->no_trans_update.all &&
serg@serg.mylan's avatar
serg@serg.mylan committed
4296 4297 4298 4299 4300 4301
            !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);
      }
4302
      thd->transaction.savepoints=sv;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4303 4304
    }
    else
4305
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4306
    break;
4307
  }
4308
  case SQLCOM_SAVEPOINT:
4309 4310
    if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN) ||
          thd->in_sub_stmt) || !opt_using_transactions)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4311
      send_ok(thd);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4312
    else
4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350
    {
      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);
      }
    }
4351
    break;
4352 4353
  case SQLCOM_CREATE_PROCEDURE:
  case SQLCOM_CREATE_SPFUNCTION:
monty@mysql.com's avatar
monty@mysql.com committed
4354
  {
4355
    uint namelen;
4356
    char *name;
4357
    int sp_result= SP_INTERNAL_ERROR;
4358

4359
    DBUG_ASSERT(lex->sphead != 0);
4360
    DBUG_ASSERT(lex->sphead->m_db.str); /* Must be initialized in the parser */
4361 4362 4363 4364 4365 4366 4367
    /*
      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);
4368
      goto create_sp_error;
4369 4370 4371
    }

    /*
4372 4373 4374
      Check that a database directory with this name
      exists. Design note: This won't work on virtual databases
      like information_schema.
4375 4376 4377 4378
    */
    if (check_db_dir_existence(lex->sphead->m_db.str))
    {
      my_error(ER_BAD_DB_ERROR, MYF(0), lex->sphead->m_db.str);
4379
      goto create_sp_error;
4380 4381
    }

4382 4383
    if (check_access(thd, CREATE_PROC_ACL, lex->sphead->m_db.str, 0, 0, 0,
                     is_schema_db(lex->sphead->m_db.str)))
4384
      goto create_sp_error;
4385

4386 4387
    if (end_active_trans(thd))
      goto create_sp_error;
4388 4389

    name= lex->sphead->name(&namelen);
4390
#ifdef HAVE_DLOPEN
monty@mysql.com's avatar
monty@mysql.com committed
4391 4392 4393
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
4394

monty@mysql.com's avatar
monty@mysql.com committed
4395
      if (udf)
4396
      {
4397 4398
        my_error(ER_UDF_EXISTS, MYF(0), name);
        goto create_sp_error;
4399
      }
monty@mysql.com's avatar
monty@mysql.com committed
4400 4401 4402
    }
#endif

4403 4404 4405
    /*
      If the definer is not specified, this means that CREATE-statement missed
      DEFINER-clause. DEFINER-clause can be missed in two cases:
4406

4407 4408 4409 4410 4411 4412 4413 4414
        - 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.
4415

4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429
          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)
    {
4430
      bool local_res= FALSE;
4431 4432 4433 4434
      Query_arena original_arena;
      Query_arena *ps_arena = thd->activate_stmt_arena_if_needed(&original_arena);

      if (!(lex->definer= create_default_definer(thd)))
4435
        local_res= TRUE;
4436 4437 4438 4439

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

4440
      /* Error has been already reported. */
4441
      if (local_res)
4442
        goto create_sp_error;
4443 4444 4445 4446 4447 4448 4449 4450 4451 4452

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

4454 4455 4456 4457 4458 4459 4460 4461
    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");
4462
        goto create_sp_error;
4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480
      }
    }

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

4481
    res= (sp_result= lex->sphead->create(thd));
4482
    switch (sp_result) {
4483
    case SP_OK:
4484
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4485
      /* only add privileges if really neccessary */
4486
      if (sp_automatic_privileges && !opt_noacl &&
4487
          check_routine_access(thd, DEFAULT_CREATE_PROC_ACLS,
4488
                               lex->sphead->m_db.str, name,
4489
                               lex->sql_command == SQLCOM_CREATE_PROCEDURE, 1))
4490
      {
4491
        if (sp_grant_privileges(thd, lex->sphead->m_db.str, name,
4492
                                lex->sql_command == SQLCOM_CREATE_PROCEDURE))
4493 4494 4495 4496
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                       ER_PROC_AUTO_GRANT_FAIL,
                       ER(ER_PROC_AUTO_GRANT_FAIL));
        close_thread_tables(thd);
4497
      }
4498
#endif
monty@mysql.com's avatar
monty@mysql.com committed
4499
    break;
4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518
    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:
4519
    if (sp_result != SP_OK )
4520 4521 4522 4523
      goto error;
    send_ok(thd);
    break; /* break super switch */
  } /* end case group bracket */
4524 4525 4526 4527
  case SQLCOM_CALL:
    {
      sp_head *sp;

4528 4529 4530 4531 4532 4533 4534 4535 4536
      /*
        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;

      /*
4537 4538
        By this moment all needed SPs should be in cache so no need to look 
        into DB. 
4539
      */
4540 4541
      if (!(sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                                &thd->sp_proc_cache, TRUE)))
4542
      {
4543
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PROCEDURE",
4544
                 lex->spname->m_qname.str);
4545
	goto error;
4546 4547 4548
      }
      else
      {
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4549
	ha_rows select_limit;
monty@mysql.com's avatar
monty@mysql.com committed
4550 4551
        /* bits that should be cleared in thd->server_status */
	uint bits_to_be_cleared= 0;
4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563
        /*
          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;
        }
4564

4565
	my_bool save_no_send_ok= thd->net.no_send_ok;
4566
	thd->net.no_send_ok= TRUE;
4567
	if (sp->m_flags & sp_head::MULTI_RESULTS)
4568
	{
4569
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
4570
	  {
4571 4572 4573 4574
            /*
              The client does not support multiple result sets being sent
              back
            */
4575
	    my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str);
4576
	    thd->net.no_send_ok= save_no_send_ok;
4577 4578
	    goto error;
	  }
monty@mysql.com's avatar
monty@mysql.com committed
4579 4580 4581 4582 4583 4584 4585
          /*
            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;
4586 4587
	}

4588
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4589
	if (check_routine_access(thd, EXECUTE_ACL,
4590
				 sp->m_db.str, sp->m_name.str, TRUE, FALSE))
4591
	{
4592
	  thd->net.no_send_ok= save_no_send_ok;
4593 4594
	  goto error;
	}
4595
#endif
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4596 4597
	select_limit= thd->variables.select_limit;
	thd->variables.select_limit= HA_POS_ERROR;
4598

4599
        /* 
4600
          We never write CALL statements into binlog:
4601 4602 4603 4604 4605
           - 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.
4606
        */
4607
	res= sp->execute_procedure(thd, &lex->value_list);
4608 4609 4610
	/*
          If warnings have been cleared, we have to clear total_warn_count
          too, otherwise the clients get confused.
4611 4612 4613 4614
	 */
	if (thd->warn_list.is_empty())
	  thd->total_warn_count= 0;

pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4615
	thd->variables.select_limit= select_limit;
4616

4617
	thd->net.no_send_ok= save_no_send_ok;
monty@mysql.com's avatar
monty@mysql.com committed
4618
        thd->server_status&= ~bits_to_be_cleared;
4619

4620
	if (!res)
monty@mysql.com's avatar
monty@mysql.com committed
4621 4622
	  send_ok(thd, (ulong) (thd->row_count_func < 0 ? 0 :
                                thd->row_count_func));
4623 4624
	else
	  goto error;		// Substatement should already have sent error
4625
      }
4626
      break;
4627 4628
    }
  case SQLCOM_ALTER_PROCEDURE:
4629
  case SQLCOM_ALTER_FUNCTION:
4630
    {
4631
      int sp_result;
4632 4633 4634 4635
      sp_head *sp;
      st_sp_chistics chistics;

      memcpy(&chistics, &lex->sp_chistics, sizeof(chistics));
4636
      if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4637 4638
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
4639
      else
4640 4641
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
monty@mysql.com's avatar
monty@mysql.com committed
4642
      mysql_reset_errors(thd, 0);
4643
      if (! sp)
4644 4645
      {
	if (lex->spname->m_db.str)
4646
	  sp_result= SP_KEY_NOT_FOUND;
4647 4648 4649 4650 4651 4652
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
      }
4653 4654
      else
      {
4655 4656 4657
        if (check_routine_access(thd, ALTER_PROC_ACL, sp->m_db.str, 
				 sp->m_name.str,
                                 lex->sql_command == SQLCOM_ALTER_PROCEDURE, 0))
4658
	  goto error;
4659 4660 4661

        if (end_active_trans(thd)) 
          goto error;
4662
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
4663 4664
        if ((sp->m_type == TYPE_ENUM_FUNCTION) &&
            !trust_function_creators &&  mysql_bin_log.is_open() &&
4665 4666 4667 4668 4669 4670
            !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));
4671
          sp_result= SP_INTERNAL_ERROR;
4672 4673 4674
        }
        else
        {
4675 4676 4677 4678 4679 4680
          /*
            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.
          */
4681
          /* Conditionally writes to binlog */
4682
          if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4683 4684
            sp_result= sp_update_procedure(thd, lex->spname,
                                           &lex->sp_chistics);
4685
          else
4686
            sp_result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
4687
        }
4688
      }
4689
      switch (sp_result)
4690
      {
4691
      case SP_OK:
4692
	send_ok(thd);
4693 4694
	break;
      case SP_KEY_NOT_FOUND:
4695 4696
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4697 4698
	goto error;
      default:
4699 4700
	my_error(ER_SP_CANT_ALTER, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4701
	goto error;
4702
      }
4703
      break;
4704 4705
    }
  case SQLCOM_DROP_PROCEDURE:
4706
  case SQLCOM_DROP_FUNCTION:
4707
    {
4708
      int sp_result;
4709 4710
      int type= (lex->sql_command == SQLCOM_DROP_PROCEDURE ?
                 TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION);
4711

4712
      sp_result= sp_routine_exists_in_table(thd, type, lex->spname);
monty@mysql.com's avatar
monty@mysql.com committed
4713
      mysql_reset_errors(thd, 0);
4714
      if (sp_result == SP_OK)
4715
      {
4716 4717 4718
        char *db= lex->spname->m_db.str;
	char *name= lex->spname->m_name.str;

4719 4720
	if (check_routine_access(thd, ALTER_PROC_ACL, db, name,
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE, 0))
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
4721
          goto error;
4722 4723 4724

        if (end_active_trans(thd)) 
          goto error;
4725
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4726
	if (sp_automatic_privileges && !opt_noacl &&
4727 4728
	    sp_revoke_privileges(thd, db, name, 
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE))
4729 4730 4731 4732 4733
	{
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
		       ER_PROC_AUTO_REVOKE_FAIL,
		       ER(ER_PROC_AUTO_REVOKE_FAIL));
	}
4734
#endif
4735
          /* Conditionally writes to binlog */
4736 4737
	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
	  sp_result= sp_drop_procedure(thd, lex->spname);
4738
	else
4739
	  sp_result= sp_drop_function(thd, lex->spname);
4740 4741 4742
      }
      else
      {
4743
#ifdef HAVE_DLOPEN
4744 4745 4746 4747 4748 4749
	if (lex->sql_command == SQLCOM_DROP_FUNCTION)
	{
          udf_func *udf = find_udf(lex->spname->m_name.str,
                                   lex->spname->m_name.length);
          if (udf)
          {
4750
	    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 0, 0))
4751
	      goto error;
4752 4753

	    /* Does NOT write to binlog */
4754
	    if (!(res = mysql_drop_function(thd, &lex->spname->m_name)))
4755
	    {
4756 4757
	      send_ok(thd);
	      break;
4758 4759
	    }
	  }
4760
	}
4761
#endif
4762
	if (lex->spname->m_db.str)
4763
	  sp_result= SP_KEY_NOT_FOUND;
4764 4765 4766 4767 4768
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
4769
      }
4770 4771
      res= sp_result;
      switch (sp_result) {
4772
      case SP_OK:
4773
	send_ok(thd);
4774 4775
	break;
      case SP_KEY_NOT_FOUND:
4776 4777
	if (lex->drop_if_exists)
	{
4778
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
4779
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
4780
			      SP_COM_STRING(lex), lex->spname->m_name.str);
4781
	  res= FALSE;
4782 4783 4784
	  send_ok(thd);
	  break;
	}
4785 4786
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4787 4788
	goto error;
      default:
4789 4790
	my_error(ER_SP_DROP_FAILED, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4791
	goto error;
4792
      }
4793
      break;
4794
    }
4795 4796
  case SQLCOM_SHOW_CREATE_PROC:
    {
4797
      if (lex->spname->m_name.length > NAME_LEN)
4798
      {
4799
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
4800 4801
	goto error;
      }
4802
      if (sp_show_create_procedure(thd, lex->spname) != SP_OK)
4803
      {			/* We don't distinguish between errors for now */
4804 4805
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
4806 4807 4808 4809 4810 4811
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
4812
      if (lex->spname->m_name.length > NAME_LEN)
4813
      {
4814
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
4815 4816
	goto error;
      }
4817
      if (sp_show_create_function(thd, lex->spname) != SP_OK)
4818
      {			/* We don't distinguish between errors for now */
4819 4820
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
4821 4822 4823 4824 4825 4826
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
4827
      res= sp_show_status_procedure(thd, (lex->wild ?
4828 4829 4830 4831 4832
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
4833
      res= sp_show_status_function(thd, (lex->wild ? 
4834 4835 4836
					 lex->wild->ptr() : NullS));
      break;
    }
pem@mysql.com's avatar
pem@mysql.com committed
4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848
#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)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4849 4850
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
pem@mysql.com's avatar
pem@mysql.com committed
4851
      else
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4852 4853
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
4854
      if (!sp || sp->show_routine_code(thd))
4855 4856
      {
        /* We don't distinguish between errors for now */
pem@mysql.com's avatar
pem@mysql.com committed
4857 4858 4859 4860 4861 4862 4863
        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
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4864 4865
  case SQLCOM_CREATE_VIEW:
    {
4866 4867 4868
      if (end_active_trans(thd))
        goto error;

4869
      res= mysql_create_view(thd, first_table, thd->lex->create_view_mode);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4870 4871 4872 4873
      break;
    }
  case SQLCOM_DROP_VIEW:
    {
4874 4875 4876
      if (check_table_access(thd, DROP_ACL, all_tables, 0) ||
          end_active_trans(thd))
        goto error;
4877 4878
      /* Conditionally writes to binlog. */
      res= mysql_drop_view(thd, first_table, thd->lex->drop_mode);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4879 4880
      break;
    }
4881 4882
  case SQLCOM_CREATE_TRIGGER:
  {
4883 4884 4885
    if (end_active_trans(thd))
      goto error;

4886
    /* Conditionally writes to binlog. */
4887 4888
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

4889 4890 4891 4892
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
4893 4894 4895
    if (end_active_trans(thd))
      goto error;

4896
    /* Conditionally writes to binlog. */
4897 4898 4899
    res= mysql_create_or_drop_trigger(thd, all_tables, 0);
    break;
  }
4900
  case SQLCOM_XA_START:
4901 4902
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
        thd->lex->xa_opt == XA_RESUME)
4903
    {
4904
      if (! thd->transaction.xid_state.xid.eq(thd->lex->xid))
4905 4906 4907 4908
      {
        my_error(ER_XAER_NOTA, MYF(0));
        break;
      }
4909
      thd->transaction.xid_state.xa_state=XA_ACTIVE;
4910 4911 4912
      send_ok(thd);
      break;
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
4913
    if (thd->lex->xa_opt != XA_NONE)
4914 4915 4916 4917
    { // JOIN is not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
4918
    if (thd->transaction.xid_state.xa_state != XA_NOTR)
4919
    {
4920
      my_error(ER_XAER_RMFAIL, MYF(0),
4921
               xa_state_names[thd->transaction.xid_state.xa_state]);
4922 4923 4924 4925 4926 4927 4928
      break;
    }
    if (thd->active_transaction() || thd->locked_tables)
    {
      my_error(ER_XAER_OUTSIDE, MYF(0));
      break;
    }
4929 4930 4931 4932 4933 4934 4935 4936 4937
    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);
4938 4939
    thd->no_trans_update.all= FALSE;
    thd->options|= (ulong) OPTION_BEGIN;
4940 4941 4942 4943 4944 4945 4946 4947 4948 4949
    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;
    }
4950
    if (thd->transaction.xid_state.xa_state != XA_ACTIVE)
4951
    {
4952
      my_error(ER_XAER_RMFAIL, MYF(0),
4953
               xa_state_names[thd->transaction.xid_state.xa_state]);
4954 4955
      break;
    }
4956
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4957 4958 4959 4960
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
4961
    thd->transaction.xid_state.xa_state=XA_IDLE;
4962 4963 4964
    send_ok(thd);
    break;
  case SQLCOM_XA_PREPARE:
4965
    if (thd->transaction.xid_state.xa_state != XA_IDLE)
4966
    {
4967
      my_error(ER_XAER_RMFAIL, MYF(0),
4968
               xa_state_names[thd->transaction.xid_state.xa_state]);
4969 4970
      break;
    }
4971
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4972 4973 4974 4975 4976 4977 4978
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
    if (ha_prepare(thd))
    {
      my_error(ER_XA_RBROLLBACK, MYF(0));
4979 4980
      xid_cache_delete(&thd->transaction.xid_state);
      thd->transaction.xid_state.xa_state=XA_NOTR;
4981 4982
      break;
    }
4983
    thd->transaction.xid_state.xa_state=XA_PREPARED;
4984 4985 4986
    send_ok(thd);
    break;
  case SQLCOM_XA_COMMIT:
4987
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4988
    {
4989 4990
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
4991
        my_error(ER_XAER_NOTA, MYF(0));
serg@serg.mylan's avatar
serg@serg.mylan committed
4992
      else
4993 4994 4995
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 1);
        xid_cache_delete(xs);
serg@serg.mylan's avatar
serg@serg.mylan committed
4996
        send_ok(thd);
4997
      }
4998 4999
      break;
    }
5000
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
monty@mysql.com's avatar
monty@mysql.com committed
5001
        thd->lex->xa_opt == XA_ONE_PHASE)
5002
    {
5003 5004 5005
      int r;
      if ((r= ha_commit(thd)))
        my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0));
5006 5007 5008
      else
        send_ok(thd);
    }
5009
    else if (thd->transaction.xid_state.xa_state == XA_PREPARED &&
monty@mysql.com's avatar
monty@mysql.com committed
5010
             thd->lex->xa_opt == XA_NONE)
5011
    {
5012 5013 5014
      if (wait_if_global_read_lock(thd, 0, 0))
      {
        ha_rollback(thd);
5015
        my_error(ER_XAER_RMERR, MYF(0));
5016
      }
5017
      else
5018 5019 5020 5021 5022 5023 5024
      {
        if (ha_commit_one_phase(thd, 1))
          my_error(ER_XAER_RMERR, MYF(0));
        else
          send_ok(thd);
        start_waiting_global_read_lock(thd);
      }
5025 5026 5027
    }
    else
    {
5028
      my_error(ER_XAER_RMFAIL, MYF(0),
5029
               xa_state_names[thd->transaction.xid_state.xa_state]);
5030 5031
      break;
    }
5032 5033
    thd->options&= ~(ulong) OPTION_BEGIN;
    thd->no_trans_update.all= FALSE;
5034
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
5035 5036
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
5037 5038
    break;
  case SQLCOM_XA_ROLLBACK:
5039
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
5040
    {
5041 5042
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
5043
        my_error(ER_XAER_NOTA, MYF(0));
serg@serg.mylan's avatar
serg@serg.mylan committed
5044
      else
5045 5046 5047
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 0);
        xid_cache_delete(xs);
serg@serg.mylan's avatar
serg@serg.mylan committed
5048
        send_ok(thd);
5049
      }
5050 5051
      break;
    }
5052 5053
    if (thd->transaction.xid_state.xa_state != XA_IDLE &&
        thd->transaction.xid_state.xa_state != XA_PREPARED)
5054
    {
5055
      my_error(ER_XAER_RMFAIL, MYF(0),
5056
               xa_state_names[thd->transaction.xid_state.xa_state]);
5057 5058 5059 5060 5061 5062
      break;
    }
    if (ha_rollback(thd))
      my_error(ER_XAER_RMERR, MYF(0));
    else
      send_ok(thd);
5063 5064
    thd->options&= ~(ulong) OPTION_BEGIN;
    thd->no_trans_update.all= FALSE;
5065
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
5066 5067
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
5068 5069
    break;
  case SQLCOM_XA_RECOVER:
5070
    res= mysql_xa_recover(thd);
5071 5072
    break;
  default:
5073
#ifndef EMBEDDED_LIBRARY
5074
    DBUG_ASSERT(0);                             /* Impossible */
5075
#endif
5076
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5077 5078
    break;
  }
monty@mysql.com's avatar
monty@mysql.com committed
5079
  thd->proc_info="query end";
5080
  /* Two binlog-related cleanups: */
5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093

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

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

  goto end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5107 5108

error:
5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120
  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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5121 5122 5123
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5124
/*
5125
  Check grants for commands which work only with one table.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5126

5127
  SYNOPSIS
5128
    check_single_table_access()
monty@mysql.com's avatar
monty@mysql.com committed
5129
    thd			Thread handler
5130
    privilege		requested privilege
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5131
    all_tables		global table list of query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5132 5133 5134

  RETURN
    0 - OK
monty@mysql.com's avatar
monty@mysql.com committed
5135
    1 - access denied, error is sent to client
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5136 5137
*/

5138 5139
bool check_single_table_access(THD *thd, ulong privilege, 
                               TABLE_LIST *all_tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5140
{
5141 5142 5143 5144 5145 5146
  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;

5147 5148 5149 5150 5151 5152 5153 5154
  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,
5155 5156
		   &all_tables->grant.privilege, 0, 0,
                   test(all_tables->schema_table)))
5157
    goto deny;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5158

5159
  /* Show only 1 table for check_grant */
5160 5161 5162 5163
  if (grant_option &&
      !(all_tables->belong_to_view &&
        (thd->lex->sql_command == SQLCOM_SHOW_FIELDS)) &&
      check_grant(thd, privilege, all_tables, 0, 1, 0))
5164 5165 5166
    goto deny;

  thd->security_ctx= backup_ctx;
5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192
  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;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5193

5194
  /* Check rights on tables of subselects and implictly opened tables */
5195
  TABLE_LIST *subselects_tables, *view= all_tables->view ? all_tables : 0;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5196
  if ((subselects_tables= all_tables->next_global))
monty@mysql.com's avatar
monty@mysql.com committed
5197
  {
5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209
    /*
      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)))
5210
      return 1;
monty@mysql.com's avatar
monty@mysql.com committed
5211 5212
  }
  return 0;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5213 5214 5215
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5216
/****************************************************************************
5217
  Get the user (global) and database privileges for all used tables
5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230

  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
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5231 5232
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5233 5234 5235
****************************************************************************/

bool
5236
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
5237
	     bool dont_check_global_grants, bool no_errors, bool schema_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5238
{
5239
  Security_context *sctx= thd->security_ctx;
5240 5241
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
5242
  bool  db_is_pattern= test(want_access & GRANT_ACL);
5243 5244
#endif
  ulong dummy;
5245 5246
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
5247
                      db ? db : "", want_access, sctx->master_access));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5248 5249 5250 5251 5252
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

5253
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5254
  {
5255
    DBUG_PRINT("error",("No database"));
5256
    if (!no_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5257 5258
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                 MYF(0));                       /* purecov: tested */
5259
    DBUG_RETURN(TRUE);				/* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5260 5261
  }

5262 5263
  if (schema_db)
  {
5264 5265
    if (!(sctx->master_access & FILE_ACL) && (want_access & FILE_ACL) ||
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5266 5267
    {
      if (!no_errors)
5268 5269
      {
        const char *db_name= db ? db : thd->db;
5270
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5271 5272
                 sctx->priv_user, sctx->priv_host, db_name);
      }
5273 5274 5275 5276 5277 5278 5279 5280 5281
      DBUG_RETURN(TRUE);
    }
    else
    {
      *save_priv= SELECT_ACL;
      DBUG_RETURN(FALSE);
    }
  }

monty@mysql.com's avatar
monty@mysql.com committed
5282 5283 5284
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
5285
  if ((sctx->master_access & want_access) == want_access)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5286
  {
5287 5288 5289 5290 5291
    /*
      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
    */
5292 5293
    db_access= sctx->db_access;
    if (!(sctx->master_access & SELECT_ACL) &&
5294
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
5295 5296 5297
      db_access=acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                        db_is_pattern);
    *save_priv=sctx->master_access | db_access;
5298
    DBUG_RETURN(FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5299
  }
5300
  if (((want_access & ~sctx->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
5301
      ! db && dont_check_global_grants)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5302
  {						// We can never grant this
5303
    DBUG_PRINT("error",("No possible access"));
5304
    if (!no_errors)
5305
      my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
5306 5307
               sctx->priv_user,
               sctx->priv_host,
5308 5309 5310
               (thd->password ?
                ER(ER_YES) :
                ER(ER_NO)));                    /* purecov: tested */
5311
    DBUG_RETURN(TRUE);				/* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5312 5313 5314
  }

  if (db == any_db)
5315
    DBUG_RETURN(FALSE);				// Allow select on anything
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5316

5317
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
5318 5319
    db_access= acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                       db_is_pattern);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5320
  else
5321
    db_access= sctx->db_access;
5322
  DBUG_PRINT("info",("db_access: %lu", db_access));
monty@mysql.com's avatar
monty@mysql.com committed
5323
  /* Remove SHOW attribute and access rights we already have */
5324
  want_access &= ~(sctx->master_access | EXTRA_ACL);
5325 5326
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
5327
  db_access= ((*save_priv=(db_access | sctx->master_access)) & want_access);
5328 5329

  /* grant_option is set if there exists a single table or column grant */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5330
  if (db_access == want_access ||
5331
      (grant_option && !dont_check_global_grants &&
5332
       !(want_access & ~(db_access | TABLE_ACLS | PROC_ACLS))))
5333
    DBUG_RETURN(FALSE);				/* Ok */
5334 5335

  DBUG_PRINT("error",("Access denied"));
5336
  if (!no_errors)
5337
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5338
             sctx->priv_user, sctx->priv_host,
5339 5340 5341
             (db ? db : (thd->db ?
                         thd->db :
                         "unknown")));          /* purecov: tested */
5342
  DBUG_RETURN(TRUE);				/* purecov: tested */
monty@mysql.com's avatar
monty@mysql.com committed
5343
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5344 5345 5346
}


5347 5348 5349 5350 5351 5352 5353 5354 5355
/*
  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
5356
    One gets access right if one has ANY of the rights in want_access
5357 5358 5359 5360 5361 5362 5363 5364
    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
*/
5365 5366

bool check_global_access(THD *thd, ulong want_access)
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5367
{
monty@mysql.com's avatar
monty@mysql.com committed
5368 5369 5370
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
5371
  char command[128];
5372
  if ((thd->security_ctx->master_access & want_access))
5373 5374
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
5375
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
5376
  return 1;
monty@mysql.com's avatar
monty@mysql.com committed
5377
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5378 5379 5380
}


5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457
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;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5458
/*
5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478
  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
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5479 5480
*/

5481
bool
5482
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
5483
		   bool no_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5484
{
5485 5486
  uint found=0;
  ulong found_access=0;
5487
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5488
  TABLE_LIST *org_tables= tables;
5489
#endif
5490
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
5491
  Security_context *sctx= thd->security_ctx, *backup_ctx= thd->security_ctx;
5492
  /*
5493 5494 5495
    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.
5496
  */
5497
  for (; tables != first_not_own_table; tables= tables->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5498
  {
5499 5500 5501 5502 5503
    if (tables->security_ctx)
      sctx= tables->security_ctx;
    else
      sctx= backup_ctx;

5504
    if (tables->schema_table && 
5505
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5506 5507 5508
    {
      if (!no_errors)
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5509
                 sctx->priv_user, sctx->priv_host,
5510
                 INFORMATION_SCHEMA_NAME.str);
5511 5512
      return TRUE;
    }
5513 5514 5515 5516 5517
    /*
       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);
5518 5519 5520 5521 5522 5523 5524 5525 5526 5527

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

      continue;
    }

    if (tables->derived ||
5528
        (tables->table && (int)tables->table->s->tmp_table) ||
5529 5530
        my_tz_check_n_skip_implicit_tables(&tables,
                                           thd->lex->time_zone_tables_used))
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
5531
      continue;
5532 5533
    thd->security_ctx= sctx;
    if ((sctx->master_access & want_access) ==
5534
        (want_access & ~EXTRA_ACL) &&
5535
	thd->db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5536
      tables->grant.privilege= want_access;
5537
    else if (tables->db && thd->db && strcmp(tables->db, thd->db) == 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5538 5539 5540 5541 5542
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
5543
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5544
			 0, no_errors, test(tables->schema_table)))
5545
	  goto deny;                            // Access denied
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5546
	found_access=tables->grant.privilege;
5547
	found=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5548 5549
      }
    }
5550
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5551
			  0, no_errors, test(tables->schema_table)))
5552
      goto deny;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5553
  }
5554
  thd->security_ctx= backup_ctx;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5555
  if (grant_option)
5556
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5557
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5558
  return FALSE;
5559 5560 5561
deny:
  thd->security_ctx= backup_ctx;
  return TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5562 5563
}

5564

5565
bool
5566 5567
check_routine_access(THD *thd, ulong want_access,char *db, char *name,
		     bool is_proc, bool no_errors)
5568 5569 5570 5571 5572
{
  TABLE_LIST tables[1];
  
  bzero((char *)tables, sizeof(TABLE_LIST));
  tables->db= db;
5573
  tables->table_name= tables->alias= name;
5574
  
monty@mysql.com's avatar
monty@mysql.com committed
5575 5576 5577 5578 5579 5580 5581
  /*
    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)
5582 5583
    tables->grant.privilege= want_access;
  else if (check_access(thd,want_access,db,&tables->grant.privilege,
monty@mysql.com's avatar
monty@mysql.com committed
5584
			0, no_errors, 0))
5585 5586
    return TRUE;
  
5587
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5588
  if (grant_option)
5589
    return check_grant_routine(thd, want_access, tables, is_proc, no_errors);
5590
#endif
5591 5592 5593 5594

  return FALSE;
}

5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609

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

5610 5611
bool check_some_routine_access(THD *thd, const char *db, const char *name,
                               bool is_proc)
5612 5613
{
  ulong save_priv;
5614
  if (thd->security_ctx->master_access & SHOW_PROC_ACLS)
5615
    return FALSE;
5616 5617 5618 5619 5620
  /*
    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) ||
5621 5622
      (save_priv & SHOW_PROC_ACLS))
    return FALSE;
5623
  return check_routine_level_acl(thd, db, name, is_proc);
5624 5625 5626
}


5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651
/*
  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,
5652 5653
                        &table->grant.privilege, 0, 1,
                        test(table->schema_table)) &&
5654 5655 5656 5657 5658 5659 5660 5661 5662
          !grant_option || !check_grant(thd, access, table, 0, 1, 1))
        DBUG_RETURN(0);
    }
  }
  DBUG_PRINT("exit",("no matching access rights"));
  DBUG_RETURN(1);
}


5663 5664
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
5665 5666 5667 5668
{
  int error=0;
  if (table_list)
  {
5669
    /* Check that all tables use the current database */
5670
    TABLE_LIST *tmp;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5671
    for (tmp= table_list; tmp; tmp= tmp->next_local)
5672 5673 5674 5675
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
5676
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
hf@deer.(none)'s avatar
hf@deer.(none) committed
5677
			     table_list,0);
5678 5679 5680 5681
  }
  return error;
}

hf@deer.(none)'s avatar
hf@deer.(none) committed
5682 5683 5684

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
5685
  char *current_db= NULL;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5686
  for (; tables; tables= tables->next_global)
hf@deer.(none)'s avatar
hf@deer.(none) committed
5687
  {
5688
    if (tables->db == NULL)
hf@deer.(none)'s avatar
hf@deer.(none) committed
5689
    {
5690 5691 5692 5693 5694 5695 5696 5697 5698
      /*
        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;
hf@deer.(none)'s avatar
hf@deer.(none) committed
5699 5700 5701 5702
    }
  }
  return FALSE;
}
5703

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5704 5705 5706 5707 5708 5709 5710 5711 5712 5713
/****************************************************************************
	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

monty@mysql.com's avatar
monty@mysql.com committed
5714 5715 5716 5717
#ifndef DBUG_OFF
long max_stack_used;
#endif

5718
#ifndef EMBEDDED_LIBRARY
5719 5720 5721 5722 5723 5724 5725 5726
/*
  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)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5727 5728
{
  long stack_used;
5729
  DBUG_ASSERT(thd == current_thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5730
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
monty@mysql.com's avatar
monty@mysql.com committed
5731
      (long) (thread_stack - margin))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5732
  {
5733 5734 5735
    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));
5736
    thd->fatal_error();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5737 5738
    return 1;
  }
monty@mysql.com's avatar
monty@mysql.com committed
5739 5740 5741
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5742 5743
  return 0;
}
5744
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5745 5746 5747 5748

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

5749
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5750
{
5751
  LEX	*lex= current_thd->lex;
5752
  ulong old_info=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778
  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;
}


/****************************************************************************
5779
  Initialize global thd variables needed for query
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5780 5781
****************************************************************************/

5782
void
5783
mysql_init_query(THD *thd, uchar *buf, uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5784 5785
{
  DBUG_ENTER("mysql_init_query");
5786
  lex_start(thd, buf, length);
5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807
  mysql_reset_thd_for_next_command(thd);
  DBUG_VOID_RETURN;
}


/*
 Reset THD part responsible for command processing state.

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

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

void mysql_reset_thd_for_next_command(THD *thd)
{
  DBUG_ENTER("mysql_reset_thd_for_next_command");
5808
  thd->free_list= 0;
5809
  thd->select_number= 1;
5810
  thd->query_start_used= thd->insert_id_used=0;
5811
  thd->last_insert_id_used_bin_log= FALSE;
5812
  thd->is_fatal_error= thd->time_zone_used= 0;
monty@mysql.com's avatar
monty@mysql.com committed
5813
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
monty@mysql.com's avatar
monty@mysql.com committed
5814 5815
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
5816
  DBUG_ASSERT(thd->security_ctx== &thd->main_security_ctx);
5817
  thd->tmp_table_used= 0;
5818 5819
  if (!thd->in_sub_stmt)
  {
5820
    if (opt_bin_log)
5821
    {
5822
      reset_dynamic(&thd->user_var_events);
5823 5824
      thd->user_var_events_alloc= thd->mem_root;
    }
5825
    thd->clear_error();
5826 5827 5828 5829
    thd->total_warn_count=0;			// Warnings for this query
    thd->rand_used= 0;
    thd->sent_row_count= thd->examined_row_count= 0;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5830 5831 5832
  DBUG_VOID_RETURN;
}

5833

5834 5835 5836
void
mysql_init_select(LEX *lex)
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5837
  SELECT_LEX *select_lex= lex->current_select;
5838
  select_lex->init_select();
5839
  lex->wild= 0;
5840 5841
  if (select_lex == &lex->select_lex)
  {
5842
    DBUG_ASSERT(lex->result == 0);
5843 5844
    lex->exchange= 0;
  }
5845 5846
}

5847

5848
bool
5849
mysql_new_select(LEX *lex, bool move_down)
5850
{
5851
  SELECT_LEX *select_lex;
5852
  THD *thd= lex->thd;
5853 5854
  DBUG_ENTER("mysql_new_select");

5855
  if (!(select_lex= new (thd->mem_root) SELECT_LEX()))
5856
    DBUG_RETURN(1);
5857
  select_lex->select_number= ++thd->select_number;
5858
  select_lex->parent_lex= lex; /* Used in init_query. */
5859 5860
  select_lex->init_query();
  select_lex->init_select();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5861 5862
  lex->nest_level++;
  select_lex->nest_level= lex->nest_level;
5863 5864 5865 5866 5867
  /*
    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.
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
5868
  if (thd->stmt_arena->is_stmt_prepare())
5869
    select_lex->uncacheable|= UNCACHEABLE_PREPARE;
5870 5871
  if (move_down)
  {
5872
    SELECT_LEX_UNIT *unit;
5873
    lex->subqueries= TRUE;
5874
    /* first select_lex of subselect or derived table */
5875
    if (!(unit= new (thd->mem_root) SELECT_LEX_UNIT()))
5876
      DBUG_RETURN(1);
5877

5878 5879
    unit->init_query();
    unit->init_select();
5880
    unit->thd= thd;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5881
    unit->include_down(lex->current_select);
5882 5883
    unit->link_next= 0;
    unit->link_prev= 0;
5884
    unit->return_to= lex->current_select;
5885
    select_lex->include_down(unit);
5886 5887 5888 5889 5890
    /*
      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;
5891 5892
  }
  else
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5893
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5894 5895
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
5896
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
5897
      DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5898
    }
5899
    select_lex->include_neighbour(lex->current_select);
5900 5901 5902 5903 5904
    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;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5905
  }
peter@mysql.com's avatar
peter@mysql.com committed
5906

5907
  select_lex->master_unit()->global_parameters= select_lex;
5908
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
5909
  lex->current_select= select_lex;
5910 5911 5912 5913 5914
  /*
    in subquery is SELECT query and we allow resolution of names in SELECT
    list
  */
  select_lex->context.resolve_in_select_list= TRUE;
5915
  DBUG_RETURN(0);
5916
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5917

5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932
/*
  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)
{
5933
  THD *thd;
5934
  LEX *lex;
5935
  LEX_STRING tmp, null_lex_string;
5936 5937
  Item *var;
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
5938
  DBUG_ENTER("create_select_for_variable");
5939 5940

  thd= current_thd;
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
5941
  lex= thd->lex;
5942 5943 5944 5945
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
5946
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
5947 5948 5949 5950
  /*
    We set the name of Item to @@session.var_name because that then is used
    as the column name in the output.
  */
monty@mysql.com's avatar
monty@mysql.com committed
5951 5952 5953 5954 5955 5956
  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);
  }
5957 5958 5959
  DBUG_VOID_RETURN;
}

5960

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5961 5962
void mysql_init_multi_delete(LEX *lex)
{
5963
  lex->sql_command=  SQLCOM_DELETE_MULTI;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5964
  mysql_init_select(lex);
5965 5966
  lex->select_lex.select_limit= 0;
  lex->unit.select_limit_cnt= HA_POS_ERROR;
5967
  lex->select_lex.table_list.save_and_clear(&lex->auxiliary_table_list);
5968
  lex->lock_option= using_update_log ? TL_READ_NO_INSERT : TL_READ;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5969 5970
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5971
}
5972

5973 5974 5975 5976
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
5977

5978
void mysql_parse(THD *thd, char *inBuf, uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5979 5980
{
  DBUG_ENTER("mysql_parse");
5981 5982 5983

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

5984
  mysql_init_query(thd, (uchar*) inBuf, length);
5985
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5986
  {
5987
    LEX *lex= thd->lex;
5988
    
5989 5990
    sp_cache_flush_obsolete(&thd->sp_proc_cache);
    sp_cache_flush_obsolete(&thd->sp_func_cache);
5991
    
5992
    if (!MYSQLparse((void *)thd) && ! thd->is_fatal_error)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5993
    {
hf@deer.(none)'s avatar
hf@deer.(none) committed
5994
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5995
      if (mqh_used && thd->user_connect &&
5996
	  check_mqh(thd, lex->sql_command))
5997 5998 5999 6000
      {
	thd->net.error = 0;
      }
      else
hf@deer.(none)'s avatar
hf@deer.(none) committed
6001
#endif
6002
      {
6003
	if (! thd->net.report_error)
6004
	{
6005 6006 6007 6008 6009 6010 6011 6012 6013 6014
          /*
            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.
          */
serg@serg.mylan's avatar
serg@serg.mylan committed
6015 6016
          if (lex->found_semicolon &&
              (thd->query_length= (ulong)(lex->found_semicolon - thd->query)))
6017 6018
            thd->query_length--;
          /* Actually execute the query */
6019
	  mysql_execute_command(thd);
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
6020
	  query_cache_end_of_result(thd);
6021
	}
6022
      }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6023 6024
    }
    else
6025
    {
6026
      DBUG_ASSERT(thd->net.report_error);
6027
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
6028
			 thd->is_fatal_error));
6029 6030

      query_cache_abort(&thd->net);
6031
    }
6032 6033 6034 6035 6036 6037
    if (thd->lex->sphead)
    {
      delete thd->lex->sphead;
      thd->lex->sphead= 0;
    }
    lex->unit.cleanup();
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6038
    thd->proc_info="freeing items";
6039
    thd->end_statement();
6040
    thd->cleanup_after_query();
6041
    DBUG_ASSERT(thd->change_list.is_empty());
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6042
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6043 6044 6045 6046
  DBUG_VOID_RETURN;
}


monty@mysql.com's avatar
monty@mysql.com committed
6047
#ifdef HAVE_REPLICATION
6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058
/*
  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)
{
6059
  LEX *lex= thd->lex;
6060
  bool error= 0;
monty@mysql.com's avatar
monty@mysql.com committed
6061
  DBUG_ENTER("mysql_test_parse_for_slave");
6062

6063
  mysql_init_query(thd, (uchar*) inBuf, length);
6064
  if (!MYSQLparse((void*) thd) && ! thd->is_fatal_error &&
6065
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
monty@mysql.com's avatar
monty@mysql.com committed
6066
    error= 1;                  /* Ignore question */
6067
  thd->end_statement();
6068
  thd->cleanup_after_query();
monty@mysql.com's avatar
monty@mysql.com committed
6069
  DBUG_RETURN(error);
6070
}
monty@mysql.com's avatar
monty@mysql.com committed
6071
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6072

6073

monty@mysql.com's avatar
monty@mysql.com committed
6074

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6075 6076 6077 6078 6079
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6080
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6081
		       char *length, char *decimals,
6082
		       uint type_modifier,
6083 6084
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
6085 6086
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
6087
		       uint uint_geom_type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6088 6089
{
  register create_field *new_field;
6090
  LEX  *lex= thd->lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6091 6092 6093 6094
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
6095
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6096 6097 6098 6099 6100
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
6101 6102 6103
    lex->alter_info.key_list.push_back(new Key(Key::PRIMARY, NullS,
                                               HA_KEY_ALG_UNDEF, 0,
                                               lex->col_list));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6104 6105 6106 6107 6108
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
6109 6110 6111
    lex->alter_info.key_list.push_back(new Key(Key::UNIQUE, NullS,
                                               HA_KEY_ALG_UNDEF, 0,
                                               lex->col_list));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6112 6113 6114
    lex->col_list.empty();
  }

6115
  if (default_value)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6116
  {
6117
    /* 
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6118 6119
      Default value should be literal => basic constants =>
      no need fix_fields()
6120 6121 6122
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
6123
    */
6124 6125 6126
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
6127
    {
6128
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
6129 6130 6131
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6132
    {
6133
      default_value= 0;
6134 6135 6136
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
6137
	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
6138 6139 6140 6141 6142
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
6143
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6144 6145 6146
      DBUG_RETURN(1);
    }
  }
6147 6148 6149

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
6150
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
6151 6152
    DBUG_RETURN(1);
  }
6153

6154 6155 6156 6157 6158 6159
  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.
    */
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
6160
    char buf[32];
6161
    my_snprintf(buf, sizeof(buf), "TIMESTAMP(%s)", length);
6162 6163 6164
    push_warning_printf(thd,MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_WARN_DEPRECATED_SYNTAX,
                        ER(ER_WARN_DEPRECATED_SYNTAX),
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
6165
                        buf, "TIMESTAMP");
6166 6167
  }

6168 6169 6170 6171
  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))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6172
    DBUG_RETURN(1);
6173

6174
  lex->alter_info.create_list.push_back(new_field);
6175 6176 6177 6178
  lex->last_field=new_field;
  DBUG_RETURN(0);
}

6179

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6180 6181 6182 6183
/* Store position for column in ALTER TABLE .. ADD column */

void store_position_for_column(const char *name)
{
6184
  current_thd->lex->last_field->after=my_const_cast(char*) (name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6185 6186 6187
}

bool
6188
add_proc_to_list(THD* thd, Item *item)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6189 6190 6191 6192
{
  ORDER *order;
  Item	**item_ptr;

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6193
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6194 6195 6196 6197 6198
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
6199
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6200 6201 6202 6203 6204 6205 6206 6207
  return 0;
}


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

static void remove_escape(char *name)
{
6208 6209
  if (!*name)					// For empty DB names
    return;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6210 6211
  char *to;
#ifdef USE_MB
6212
  char *strend=name+(uint) strlen(name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6213 6214 6215 6216 6217
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
6218 6219
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6220 6221 6222 6223 6224 6225 6226 6227
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6228
      name++;					// Skip '\\'
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6229 6230 6231 6232 6233 6234 6235 6236 6237 6238
    *to++= *name;
  }
  *to=0;
}

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


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6239
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6240 6241 6242
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
6243
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6244
    DBUG_RETURN(1);
6245 6246
  order->item_ptr= item;
  order->item= &order->item_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6247 6248 6249
  order->asc = asc;
  order->free_me=0;
  order->used=0;
6250
  order->counter_used= 0;
6251
  list.link_in_list((byte*) order,(byte**) &order->next);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6252 6253 6254 6255
  DBUG_RETURN(0);
}


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6256 6257 6258 6259 6260 6261 6262 6263 6264 6265
/*
  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
6266
			TL_OPTION_ALIAS	        an alias in multi table DELETE
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6267 6268 6269 6270 6271 6272 6273 6274 6275
    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
*/

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6276 6277
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
6278
					     LEX_STRING *alias,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6279 6280
					     ulong table_options,
					     thr_lock_type lock_type,
6281 6282
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6283
                                             LEX_STRING *option)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6284 6285
{
  register TABLE_LIST *ptr;
6286
  TABLE_LIST *previous_table_ref; /* The table preceding the current one. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6287
  char *alias_str;
6288
  LEX *lex= thd->lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6289
  DBUG_ENTER("add_table_to_list");
6290
  LINT_INIT(previous_table_ref);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6291 6292 6293 6294

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
6295 6296
  if (!test(table_options & TL_OPTION_ALIAS) && 
      check_table_name(table->table.str, table->table.length))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6297
  {
6298
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6299 6300 6301 6302
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
6303 6304 6305
  {
    if (table->sel)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6306 6307
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
6308 6309
      DBUG_RETURN(0);
    }
6310
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6311
      DBUG_RETURN(0);
6312
  }
6313
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6314
    DBUG_RETURN(0);				/* purecov: inspected */
peter@mysql.com's avatar
peter@mysql.com committed
6315
  if (table->db.str)
6316
  {
6317 6318 6319 6320 6321
    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);
    }
6322 6323 6324
    ptr->db= table->db.str;
    ptr->db_length= table->db.length;
  }
6325 6326
  else if (thd->copy_db_to(&ptr->db, &ptr->db_length))
    DBUG_RETURN(0);
peter@mysql.com's avatar
peter@mysql.com committed
6327

6328
  ptr->alias= alias_str;
6329
  if (lower_case_table_names && table->table.length)
6330
    table->table.length= my_casedn_str(files_charset_info, table->table.str);
6331 6332
  ptr->table_name=table->table.str;
  ptr->table_name_length=table->table.length;
6333
  ptr->lock_type=   lock_type;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6334 6335
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6336
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
6337
  ptr->derived=	    table->sel;
6338
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
6339
                                      INFORMATION_SCHEMA_NAME.str))
6340
  {
6341
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
6342 6343 6344
    if (!schema_table ||
        (schema_table->hidden && 
         lex->orig_sql_command == SQLCOM_END))  // not a 'show' command
6345
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6346
      my_error(ER_UNKNOWN_TABLE, MYF(0),
6347
               ptr->table_name, INFORMATION_SCHEMA_NAME.str);
6348 6349
      DBUG_RETURN(0);
    }
6350
    ptr->schema_table_name= ptr->table_name;
6351 6352
    ptr->schema_table= schema_table;
  }
6353
  ptr->select_lex=  lex->current_select;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6354
  ptr->cacheable_table= 1;
6355 6356 6357 6358 6359 6360
  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));
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6361
  ptr->option= option ? option->str : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6362
  /* check that used name is unique */
6363
  if (lock_type != TL_IGNORE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6364
  {
timour@mysql.com's avatar
timour@mysql.com committed
6365 6366 6367 6368
    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 ;
6369
	 tables ;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6370
	 tables=tables->next_local)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6371
    {
6372 6373
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
6374
      {
6375
	my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
6376 6377
	DBUG_RETURN(0);				/* purecov: tested */
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6378 6379
    }
  }
6380 6381 6382
  /* Store the table reference preceding the current one. */
  if (table_list.elements > 0)
  {
6383 6384 6385
    /*
      table_list.next points to the last inserted TABLE_LIST->next_local'
      element
6386
      We don't use the offsetof() macro here to avoid warnings from gcc
6387
    */
6388 6389 6390
    previous_table_ref= (TABLE_LIST*) ((char*) table_list.next -
                                       ((char*) &(ptr->next_local) -
                                        (char*) ptr));
6391 6392 6393 6394 6395 6396 6397 6398
    /*
      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;
6399
  }
6400

6401 6402 6403 6404 6405 6406
  /*
    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'.
  */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6407
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
6408
  ptr->next_name_resolution_table= NULL;
6409
  /* Link table in global list (all used tables) */
6410
  lex->add_to_query_tables(ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6411 6412 6413
  DBUG_RETURN(ptr);
}

monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
6414

6415 6416 6417 6418
/*
  Initialize a new table list for a nested join

  SYNOPSIS
6419
    init_nested_join()
6420
    thd         current thread
6421

6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440
  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");
6441

6442 6443
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6444
    DBUG_RETURN(1);
6445 6446 6447
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467
  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
6468
    moves it one level up, eliminating the nest.
6469 6470 6471 6472 6473 6474 6475 6476 6477

  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;
6478
  NESTED_JOIN *nested_join;
6479
  DBUG_ENTER("end_nested_join");
6480

6481
  DBUG_ASSERT(embedding);
6482 6483 6484
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
6485
  nested_join= ptr->nested_join;
6486 6487 6488 6489 6490 6491 6492 6493 6494
  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;
  }
6495
  else if (nested_join->join_list.elements == 0)
6496 6497
  {
    join_list->pop();
6498
    ptr= 0;                                     // return value
6499
  }
6500 6501 6502 6503 6504 6505 6506 6507
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
6508
    nest_last_join()
6509 6510 6511 6512 6513 6514
    thd         current thread

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

  RETURN VALUE
6515 6516 6517
    0  Error
    #  Pointer to TABLE_LIST element created for the new nested join

6518 6519 6520 6521 6522 6523
*/

TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
6524
  List<TABLE_LIST> *embedded_list;
6525
  DBUG_ENTER("nest_last_join");
6526

6527 6528
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6529
    DBUG_RETURN(0);
6530 6531 6532
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6533 6534
  ptr->embedding= embedding;
  ptr->join_list= join_list;
6535
  embedded_list= &nested_join->join_list;
6536
  embedded_list->empty();
6537 6538

  for (uint i=0; i < 2; i++)
6539 6540 6541 6542 6543
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
6544 6545 6546 6547 6548 6549 6550
    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.
      */
6551 6552
      if (prev_join_using)
        ptr->join_using_fields= prev_join_using;
6553
    }
6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593
  }
  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
6594 6595 6596

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619
    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
*/

6620
TABLE_LIST *st_select_lex::convert_right_join()
6621 6622
{
  TABLE_LIST *tab2= join_list->pop();
6623
  TABLE_LIST *tab1= join_list->pop();
6624 6625 6626 6627 6628 6629 6630 6631 6632
  DBUG_ENTER("convert_right_join");

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

  DBUG_RETURN(tab1);
}

6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645
/*
  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
*/

6646
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
6647 6648 6649 6650 6651 6652
{
  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));

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6653 6654 6655
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
6656 6657 6658 6659 6660 6661 6662
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
6663

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687
/*
  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
*/

6688
bool st_select_lex_unit::add_fake_select_lex(THD *thd_arg)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6689 6690 6691 6692
{
  SELECT_LEX *first_sl= first_select();
  DBUG_ENTER("add_fake_select_lex");
  DBUG_ASSERT(!fake_select_lex);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6693

6694
  if (!(fake_select_lex= new (thd_arg->mem_root) SELECT_LEX()))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6695 6696 6697 6698
      DBUG_RETURN(1);
  fake_select_lex->include_standalone(this, 
                                      (SELECT_LEX_NODE**)&fake_select_lex);
  fake_select_lex->select_number= INT_MAX;
6699
  fake_select_lex->parent_lex= thd_arg->lex; /* Used in init_query. */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6700 6701
  fake_select_lex->make_empty_select();
  fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
6702 6703
  fake_select_lex->select_limit= 0;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6704
  fake_select_lex->context.outer_context=first_sl->context.outer_context;
6705 6706 6707
  /* 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;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718

  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;
6719
    thd_arg->lex->current_select= fake_select_lex;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6720
  }
6721
  thd_arg->lex->pop_context();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6722 6723 6724
  DBUG_RETURN(0);
}

6725

6726
/*
6727 6728
  Push a new name resolution context for a JOIN ... ON clause to the
  context stack of a query block.
6729 6730

  SYNOPSIS
6731
    push_new_name_resolution_context()
6732
    thd       pointer to current thread
timour@mysql.com's avatar
timour@mysql.com committed
6733
    left_op   left  operand of the JOIN
6734 6735 6736 6737
    right_op  rigth operand of the JOIN

  DESCRIPTION
    Create a new name resolution context for a JOIN ... ON clause,
6738 6739 6740
    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.
6741 6742

  RETURN
6743 6744
    FALSE  if all is OK
    TRUE   if a memory allocation error occured
6745 6746
*/

6747 6748 6749
bool
push_new_name_resolution_context(THD *thd,
                                 TABLE_LIST *left_op, TABLE_LIST *right_op)
6750 6751
{
  Name_resolution_context *on_context;
6752
  if (!(on_context= new (thd->mem_root) Name_resolution_context))
6753
    return TRUE;
6754 6755 6756 6757 6758
  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();
6759
  return thd->lex->push_context(on_context);
6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779
}


/*
  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)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6780
{
6781
  if (expr)
6782
  {
6783
    if (!b->on_expr)
6784
      b->on_expr= expr;
6785 6786
    else
    {
6787 6788 6789 6790 6791 6792
      /*
        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);
6793 6794
    }
    b->on_expr->top_level_item();
6795
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6796 6797 6798
}


6799
/*
6800 6801
  Mark that there is a NATURAL JOIN or JOIN ... USING between two
  tables.
6802 6803 6804

  SYNOPSIS
    add_join_natural()
6805 6806 6807
    a			Left join argument
    b			Right join argument
    using_fields        Field names from USING clause
6808
    lex                 The current st_select_lex
6809
  
6810
  IMPLEMENTATION
6811 6812 6813 6814 6815 6816 6817 6818 6819 6820
    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
6821 6822 6823
    SELECT * FROM t1 NATURAL LEFT JOIN t2
     <=>
    SELECT * FROM t1 LEFT JOIN t2 ON (t1.i=t2.i and t1.j=t2.j ... )
6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834

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

6837 6838
void add_join_natural(TABLE_LIST *a, TABLE_LIST *b, List<String> *using_fields,
                      SELECT_LEX *lex)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6839
{
6840
  b->natural_join= a;
6841
  lex->prev_join_using= using_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6842 6843
}

6844

6845
/*
6846 6847 6848 6849
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
6850
    thd			Thread handler (can be NULL!)
6851 6852 6853 6854 6855
    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
6856 6857 6858
                        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.
6859 6860 6861

  RETURN
    0	 ok
6862
    !=0  error.  thd->killed or thd->net.report_error is set
6863 6864
*/

6865 6866
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6867 6868 6869
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
6870
  bool tmp_write_to_binlog= 1;
6871

6872
  DBUG_ASSERT(!thd || !thd->in_sub_stmt);
6873

hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
6874
#ifndef NO_EMBEDDED_ACCESS_CHECKS
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6875 6876
  if (options & REFRESH_GRANT)
  {
6877 6878 6879 6880 6881 6882
    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)))
6883 6884
    {
      thd->thread_stack= (char*) &tmp_thd;
6885
      thd->store_globals();
6886
    }
6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898
    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;
    }
6899
    reset_mqh((LEX_USER *)NULL, TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6900
  }
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
6901
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6902 6903
  if (options & REFRESH_LOG)
  {
6904
    /*
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6905 6906
      Flush the normal query log, the update log, the binary log,
      the slow query log, and the relay log (if it exists).
6907
    */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6908

6909
    /*
monty@mysql.com's avatar
monty@mysql.com committed
6910 6911 6912 6913
      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)
6914 6915
    */
    tmp_write_to_binlog= 0;
6916 6917
    mysql_log.new_file(1);
    mysql_slow_log.new_file(1);
6918 6919 6920 6921
    if( mysql_bin_log.is_open() )
    {
      mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
    }
6922
#ifdef HAVE_REPLICATION
6923
    pthread_mutex_lock(&LOCK_active_mi);
6924
    rotate_relay_log(active_mi);
6925
    pthread_mutex_unlock(&LOCK_active_mi);
6926
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6927 6928
    if (ha_flush_logs())
      result=1;
6929 6930
    if (flush_error_log())
      result=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6931
  }
6932
#ifdef HAVE_QUERY_CACHE
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6933 6934
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
6935
    query_cache.pack();				// FLUSH QUERY CACHE
6936
    options &= ~REFRESH_QUERY_CACHE;    // Don't flush cache, just free memory
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6937 6938 6939
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
6940
    query_cache.flush();			// RESET QUERY CACHE
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6941
  }
6942
#endif /*HAVE_QUERY_CACHE*/
6943 6944 6945 6946 6947
  /*
    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)) 
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6948
  {
6949
    if ((options & REFRESH_READ_LOCK) && thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6950
    {
6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961
      /*
        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++)
monty@mysql.com's avatar
monty@mysql.com committed
6962
        {
6963 6964 6965 6966 6967
          if ((*lock_p)->type == TL_WRITE)
          {
            my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
            return 1;
          }
monty@mysql.com's avatar
monty@mysql.com committed
6968
        }
6969
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
6970 6971 6972 6973
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
6974
      tmp_write_to_binlog= 0;
6975
      if (lock_global_read_lock(thd))
6976
	return 1;                               // Killed
6977 6978
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
6979
      if (make_global_read_lock_block_commit(thd)) // Killed
6980 6981 6982 6983 6984
      {
        /* Don't leave things in a half-locked state */
        unlock_global_read_lock(thd);
        return 1;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6985
    }
6986 6987
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
6988
    my_dbopt_cleanup();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6989 6990 6991
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
monty@mysql.com's avatar
monty@mysql.com committed
6992
  if (thd && (options & REFRESH_STATUS))
6993
    refresh_status(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6994 6995
  if (options & REFRESH_THREADS)
    flush_thread_cache();
6996
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6997
  if (options & REFRESH_MASTER)
6998
  {
6999
    DBUG_ASSERT(thd);
7000
    tmp_write_to_binlog= 0;
7001
    if (reset_master(thd))
7002
    {
7003
      result=1;
7004 7005
      thd->fatal_error();                       // Ensure client get error
    }
7006
  }
7007
#endif
7008
#ifdef OPENSSL
7009 7010 7011 7012 7013 7014
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
7015
#ifdef HAVE_REPLICATION
7016 7017
 if (options & REFRESH_SLAVE)
 {
7018
   tmp_write_to_binlog= 0;
7019
   pthread_mutex_lock(&LOCK_active_mi);
7020
   if (reset_slave(thd, active_mi))
7021
     result=1;
7022
   pthread_mutex_unlock(&LOCK_active_mi);
7023
 }
7024
#endif
7025
 if (options & REFRESH_USER_RESOURCES)
monty@mysql.com's avatar
monty@mysql.com committed
7026
   reset_mqh((LEX_USER *) NULL);
7027
 *write_to_binlog= tmp_write_to_binlog;
7028
 return result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7029 7030
}

7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042
/*
  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
*/

hf@genie.(none)'s avatar
SCRUM  
hf@genie.(none) committed
7043
void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7044 7045 7046
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
7047 7048
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7049 7050 7051 7052
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
7053 7054
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7055 7056 7057
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
7058 7059
  if (tmp)
  {
7060 7061
    if ((thd->security_ctx->master_access & SUPER_ACL) ||
	!strcmp(thd->security_ctx->user, tmp->security_ctx->user))
7062
    {
hf@genie.(none)'s avatar
SCRUM  
hf@genie.(none) committed
7063
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
7064 7065 7066 7067 7068 7069 7070
      error=0;
    }
    else
      error=ER_KILL_DENIED_ERROR;
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7071
  if (!error)
7072
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7073
  else
7074
    my_error(error, MYF(0), id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7075 7076
}

timour@mysql.com's avatar
timour@mysql.com committed
7077

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

7080 7081
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name)
7082
{
7083
  char buff[FN_REFLEN],*ptr, *end;
7084 7085 7086 7087 7088 7089 7090
  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))
  {
7091
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
7092 7093 7094 7095
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
7096
  end=convert_dirname(buff, *filename_ptr, NullS);
7097
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
7098 7099
    return 1;					// End of memory
  *filename_ptr=ptr;
7100
  strxmov(ptr,buff,table_name,NullS);
7101 7102
  return 0;
}
7103

7104

7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118
/*
  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;
7119 7120
  LEX *lex= thd->lex;
  if (lex->current_select != &lex->select_lex)
7121 7122
  {
    char command[80];
7123 7124
    strmake(command, lex->yylval->symbol.str,
	    min(lex->yylval->symbol.length, sizeof(command)-1));
7125
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
7126 7127 7128 7129
    return 1;
  }
  return 0;
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7130

7131

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7132
Comp_creator *comp_eq_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7133
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7134
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7135 7136
}

7137

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7138
Comp_creator *comp_ge_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7139
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7140
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7141 7142
}

7143

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7144
Comp_creator *comp_gt_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7145
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7146
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7147 7148
}

7149

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7150
Comp_creator *comp_le_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7151
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7152
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7153 7154
}

7155

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7156
Comp_creator *comp_lt_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7157
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7158
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7159 7160
}

7161

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7162
Comp_creator *comp_ne_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7163
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7164
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7165
}
7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185


/*
  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)
{
serg@serg.mylan's avatar
serg@serg.mylan committed
7186
  if ((cmp == &comp_eq_creator) && !all)       //  = ANY <=> IN
7187
    return new Item_in_subselect(left_expr, select_lex);
serg@serg.mylan's avatar
serg@serg.mylan committed
7188 7189

  if ((cmp == &comp_ne_creator) && all)        // <> ALL <=> NOT IN
7190 7191 7192
    return new Item_func_not(new Item_in_subselect(left_expr, select_lex));

  Item_allany_subselect *it=
7193
    new Item_allany_subselect(left_expr, cmp, select_lex, all);
7194
  if (all)
7195
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
7196

7197
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
7198
}
7199 7200 7201 7202 7203 7204 7205


/*
  Multi update query pre-check

  SYNOPSIS
    multi_update_precheck()
7206
    thd		Thread handler
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7207
    tables	Global/local table list (have to be the same)
7208

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7209
  RETURN VALUE
7210 7211
    FALSE OK
    TRUE  Error
7212
*/
7213

7214
bool multi_update_precheck(THD *thd, TABLE_LIST *tables)
7215 7216 7217 7218 7219
{
  const char *msg= 0;
  TABLE_LIST *table;
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7220
  DBUG_ENTER("multi_update_precheck");
7221 7222 7223

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
7224
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
7225
    DBUG_RETURN(TRUE);
7226 7227 7228 7229 7230
  }
  /*
    Ensure that we have UPDATE or SELECT privilege for each table
    The exact privilege is checked in mysql_multi_update()
  */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7231
  for (table= tables; table; table= table->next_local)
7232
  {
7233 7234 7235
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
7236 7237
                           &table->grant.privilege, 0, 1,
                           test(table->schema_table)) ||
7238 7239
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
monty@mysql.com's avatar
monty@mysql.com committed
7240
             (check_access(thd, SELECT_ACL, table->db,
7241 7242
                           &table->grant.privilege, 0, 0,
                           test(table->schema_table)) ||
monty@mysql.com's avatar
monty@mysql.com committed
7243
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
7244
      DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7245

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7246
    table->table_in_first_from_clause= 1;
7247
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7248 7249 7250
  /*
    Is there tables of subqueries?
  */
7251
  if (&lex->select_lex != lex->all_selects_list || lex->time_zone_tables_used)
7252
  {
7253
    DBUG_PRINT("info",("Checking sub query list"));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7254
    for (table= tables; table; table= table->next_global)
7255
    {
monty@mysql.com's avatar
monty@mysql.com committed
7256 7257 7258
      if (!my_tz_check_n_skip_implicit_tables(&table,
                                              lex->time_zone_tables_used) &&
          !table->table_in_first_from_clause)
7259 7260
      {
	if (check_access(thd, SELECT_ACL, table->db,
7261 7262
			 &table->grant.privilege, 0, 0,
                         test(table->schema_table)) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7263
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
7264
	  DBUG_RETURN(TRUE);
7265 7266 7267 7268 7269 7270
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
7271
  else if (select_lex->select_limit)
7272 7273 7274 7275
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
7276
    DBUG_RETURN(TRUE);
7277
  }
7278
  DBUG_RETURN(FALSE);
7279 7280 7281 7282 7283 7284 7285
}

/*
  Multi delete query pre-check

  SYNOPSIS
    multi_delete_precheck()
7286
    thd			Thread handler
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7287
    tables		Global/local table list
7288

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7289
  RETURN VALUE
7290 7291
    FALSE OK
    TRUE  error
7292
*/
7293

7294
bool multi_delete_precheck(THD *thd, TABLE_LIST *tables)
7295 7296 7297
{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  TABLE_LIST *aux_tables=
7298
    (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
7299
  TABLE_LIST **save_query_tables_own_last= thd->lex->query_tables_own_last;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7300
  DBUG_ENTER("multi_delete_precheck");
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7301

7302 7303 7304
  /* 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) ||
7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316
      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;
7317
    DBUG_RETURN(TRUE);
7318 7319 7320
  }
  thd->lex->query_tables_own_last= save_query_tables_own_last;

7321 7322
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7323 7324
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
7325
    DBUG_RETURN(TRUE);
7326
  }
7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351
  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;

7352
  for (target_tbl= (TABLE_LIST *)lex->auxiliary_table_list.first;
7353
       target_tbl; target_tbl= target_tbl->next_local)
7354
  {
7355
    lex->table_count++;
7356 7357
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7358
    for (walk= tables; walk; walk= walk->next_local)
7359
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7360 7361 7362
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
7363 7364 7365 7366
	break;
    }
    if (!walk)
    {
7367
      my_error(ER_UNKNOWN_TABLE, MYF(0),
7368
               target_tbl->table_name, "MULTI DELETE");
7369
      DBUG_RETURN(TRUE);
7370
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
7371 7372 7373 7374 7375
    if (!walk->derived)
    {
      target_tbl->table_name= walk->table_name;
      target_tbl->table_name_length= walk->table_name_length;
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
7376
    walk->updating= target_tbl->updating;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7377
    walk->lock_type= target_tbl->lock_type;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7378
    target_tbl->correspondent_table= walk;	// Remember corresponding table
7379
  }
7380
  DBUG_RETURN(FALSE);
7381 7382 7383
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7384 7385 7386 7387 7388
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
7389 7390
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7391 7392

  RETURN VALUE
7393 7394
    FALSE OK
    TRUE  Error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7395
*/
7396

7397
bool update_precheck(THD *thd, TABLE_LIST *tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7398 7399 7400 7401
{
  DBUG_ENTER("update_precheck");
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7402
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
7403
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7404
  }
7405 7406
  DBUG_RETURN(check_db_used(thd, tables) ||
	       check_one_table_access(thd, UPDATE_ACL, tables));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7407 7408 7409 7410 7411 7412 7413 7414
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
7415 7416
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7417 7418

  RETURN VALUE
7419 7420
    FALSE  OK
    TRUE   error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7421
*/
7422

7423
bool delete_precheck(THD *thd, TABLE_LIST *tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7424 7425 7426
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
7427
    DBUG_RETURN(TRUE);
7428
  /* Set privilege for the WHERE clause */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7429
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
7430
  DBUG_RETURN(FALSE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7431 7432 7433 7434 7435 7436 7437 7438
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
7439 7440
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7441 7442

  RETURN VALUE
7443 7444
    FALSE  OK
    TRUE   error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7445
*/
7446

bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7447
bool insert_precheck(THD *thd, TABLE_LIST *tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7448 7449 7450 7451
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

7452 7453 7454 7455
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
monty@mysql.com's avatar
monty@mysql.com committed
7456 7457 7458
  ulong privilege= (INSERT_ACL |
                    (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                    (lex->value_list.elements ? UPDATE_ACL : 0));
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7459 7460

  if (check_one_table_access(thd, privilege, tables))
7461
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7462

7463
  if (lex->update_list.elements != lex->value_list.elements)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7464
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7465
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
7466
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7467
  }
7468 7469
  if (check_db_used(thd, tables))
    DBUG_RETURN(TRUE);
7470
  DBUG_RETURN(FALSE);
7471
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7472 7473 7474 7475 7476 7477 7478


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
7479 7480 7481
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7482 7483

  RETURN VALUE
7484 7485
    FALSE   OK
    TRUE   Error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7486
*/
7487

7488 7489
bool create_table_precheck(THD *thd, TABLE_LIST *tables,
                           TABLE_LIST *create_table)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7490 7491
{
  LEX *lex= thd->lex;
7492 7493
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7494
  bool error= TRUE;                                 // Error message is given
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7495
  DBUG_ENTER("create_table_precheck");
7496 7497 7498

  want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
              CREATE_TMP_ACL : CREATE_ACL);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7499
  if (check_access(thd, want_priv, create_table->db,
7500 7501
		   &create_table->grant.privilege, 0, 0,
                   test(create_table->schema_table)) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7502 7503 7504
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
7505 7506
    goto err;
  if (grant_option && want_priv != CREATE_TMP_ACL &&
7507
      check_grant(thd, want_priv, create_table, 0, 1, 0))
7508 7509 7510 7511 7512 7513
    goto err;

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

7514 7515
#ifdef NOT_NECESSARY_TO_CHECK_CREATE_TABLE_EXIST_WHEN_PREPARING_STATEMENT
    /* This code throws an ill error for CREATE TABLE t1 SELECT * FROM t1 */
7516
    /*
monty@mysql.com's avatar
monty@mysql.com committed
7517 7518 7519
      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).
7520
    */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7521
    if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
7522
    {
monty@mysql.com's avatar
monty@mysql.com committed
7523 7524 7525 7526
      /*
        For temporary tables we don't have to check if the created table exists
      */
      if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
monty@mysql.com's avatar
monty@mysql.com committed
7527
          find_table_in_global_list(tables, create_table->db,
7528
                                    create_table->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
7529
      {
7530
	error= FALSE;
monty@mysql.com's avatar
monty@mysql.com committed
7531 7532 7533
        goto err;
      }
    }
7534
#endif
7535 7536 7537
    if (tables && check_table_access(thd, SELECT_ACL, tables,0))
      goto err;
  }
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7538
  error= FALSE;
7539 7540 7541

err:
  DBUG_RETURN(error);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7542
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7543 7544 7545 7546 7547 7548 7549


/*
  negate given expression

  SYNOPSIS
    negate_expression()
7550
    thd  thread handler
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578
    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);
}
7579

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

7601

7602
/*
7603
  Create default definer for the specified THD.
7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621

  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;

7622
  get_default_definer(thd, definer);
7623 7624 7625 7626 7627

  return definer;
}


7628
/*
7629
  Create definer with the given user and host names.
7630 7631

  SYNOPSIS
7632 7633 7634 7635
    create_definer()
    thd         [in] thread handler
    user_name   [in] user name
    host_name   [in] host name
7636 7637

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

7643
LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name)
7644
{
7645 7646 7647 7648
  LEX_USER *definer;

  /* Create and initialize. */

7649
  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
7650 7651 7652 7653 7654 7655
    return 0;

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

  return definer;
7656
}
7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675


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

7678 7679
  return user;
}
7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695


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

7696 7697
bool check_string_length(LEX_STRING *str, const char *err_msg,
                         uint max_length)
7698
{
7699 7700
  if (str->length <= max_length)
    return FALSE;
7701 7702

  my_error(ER_WRONG_STRING_LENGTH, MYF(0), str->str, err_msg, max_length);
7703

7704 7705
  return TRUE;
}