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

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

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

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

17
#define MYSQL_LEX 1
bk@work.mysql.com's avatar
bk@work.mysql.com committed
18
#include "mysql_priv.h"
19
#include "sql_repl.h"
20
#include "repl_failsafe.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
21 22 23 24
#include <m_ctype.h>
#include <myisam.h>
#include <my_dir.h>

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
25
#ifdef HAVE_INNOBASE_DB
26
#include "ha_innodb.h"
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
27 28
#endif

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

33
#include "sp_head.h"
34
#include "sp.h"
35
#include "sp_cache.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
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
70
#ifndef NO_EMBEDDED_ACCESS_CHECKS
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);
75
static bool check_multi_update_lock(THD *thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
76
static void remove_escape(char *name);
77 78
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
79

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

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

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

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

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

125

126
static bool end_active_trans(THD *thd)
127
{
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
128
  int error=0;
129
  DBUG_ENTER("end_active_trans");
130
  if (unlikely(thd->in_sub_stmt))
131 132 133 134
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
135 136 137 138 139 140
  if (thd->transaction.xid_state.xa_state != XA_NOTR)
  {
    my_error(ER_XAER_RMFAIL, MYF(0),
             xa_state_names[thd->transaction.xid_state.xa_state]);
    DBUG_RETURN(1);
  }
141
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
142
		      OPTION_TABLE_LOCK))
143
  {
144 145 146 147
    DBUG_PRINT("info",("options: 0x%lx", (ulong) thd->options));
    /* Safety if one did "drop table" on locked tables */
    if (!thd->locked_tables)
      thd->options&= ~OPTION_TABLE_LOCK;
148
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
149
    if (ha_commit(thd))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
150
      error=1;
151
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
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 177 178
    thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
		   OPTION_BEGIN);
    thd->server_status|= SERVER_STATUS_IN_TRANS;
    if (lex->start_transaction_opt & MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT)
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");
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
293
  
monty@mysql.com's avatar
monty@mysql.com committed
294
#ifdef NO_EMBEDDED_ACCESS_CHECKS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
295
  thd->main_security_ctx.master_access= GLOBAL_ACLS;       // Full rights
296
  /* Change database if necessary */
297 298
  if (db && db[0])
  {
299 300 301 302
    /*
      thd->db is saved in caller and needs to be freed by caller if this
      function returns 0
    */
303
    thd->reset_db(NULL, 0);
304
    if (mysql_change_db(thd, db, FALSE))
305
    {
306 307
      /* Send the error to the client */
      net_send_error(thd);
308
      DBUG_RETURN(-1);
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
309
    }
310
  }
311
  send_ok(thd);
312
  DBUG_RETURN(0);
monty@mysql.com's avatar
monty@mysql.com committed
313 314
#else

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

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

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

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

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

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

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

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

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

484 485
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
486 487 488 489 490
{
  *length=buff->len;
  return (byte*) buff->user;
}

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

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


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

524 525
#ifndef NO_EMBEDDED_ACCESS_CHECKS

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

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

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

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

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

599 600
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

601

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

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

610

611 612 613
/*
  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
614 615 616

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

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

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

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

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

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

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

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

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

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

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

  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)
{
700 701
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  bool error= 0;
702 703 704 705 706 707 708 709
  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);

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

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 970
    if (sslaccept(ssl_acceptor_fd, net->vio, thd->variables.net_wait_timeout))
    {
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;
998
  net->read_timeout=(uint) thd->variables.net_read_timeout;
peter@mysql.com's avatar
peter@mysql.com committed
999

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

  /*
1009 1010 1011 1012
    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'.
  */
1013
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
1014 1015 1016
    *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
1017 1018
  uint db_len= db ? strlen(db) : 0;

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

kostja@oak.local's avatar
kostja@oak.local committed
1025 1026
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
peter@mysql.com's avatar
peter@mysql.com committed
1027
  {
1028 1029
    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
1030
                             db, db_len,
1031
                             thd->charset(), &dummy_errors)]= 0;
1032
    db= db_buff;
kostja@oak.local's avatar
kostja@oak.local committed
1033
  }
peter@mysql.com's avatar
peter@mysql.com committed
1034

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

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

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

1055

1056 1057
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
1058 1059 1060 1061
{
  Vio* save_vio;
  ulong save_client_capabilities;

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


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

  pthread_detach_this_thread();

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

1108 1109 1110 1111 1112 1113 1114
  /*
    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.
  */
1115
  DBUG_PRINT("info", ("handle_one_connection called by thread %lu\n",
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1116
		      thd->thread_id));
monty@mysql.com's avatar
monty@mysql.com committed
1117
  /* 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
1118

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

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

1142
    if ((error=check_connection(thd)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1143 1144
    {						// Wrong permissions
      if (error > 0)
1145
	net_printf_error(thd, error, sctx->host_or_ip);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1146 1147
#ifdef __NT__
      if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
1148
	my_sleep(1000);				/* must wait after eof() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1149
#endif
1150
      statistic_increment(aborted_connects,&LOCK_status);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1151 1152
      goto end_thread;
    }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1153
#ifdef __NETWARE__
1154
    netware_reg_user(sctx->ip, sctx->user, "MySQL");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1155
#endif
1156
    if (thd->variables.max_join_size == HA_POS_ERROR)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1157 1158 1159 1160
      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
1161
    thd->version= refresh_version;
1162
    thd->proc_info= 0;
1163
    thd->command= COM_SLEEP;
1164 1165
    thd->set_time();
    thd->init_for_queries();
monty@mysql.com's avatar
monty@mysql.com committed
1166

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

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

1226 1227 1228 1229
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1230

1231
pthread_handler_t handle_bootstrap(void *arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1232
{
1233 1234 1235
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1236

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

hf@deer.(none)'s avatar
hf@deer.(none) committed
1249
#ifndef EMBEDDED_LIBRARY
1250 1251
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1252
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1253
  sigset_t set;
1254 1255
  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
1256
#endif
hf@deer.(none)'s avatar
hf@deer.(none) committed
1257
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1258

1259
  if (thd->variables.max_join_size == HA_POS_ERROR)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1260 1261 1262 1263
    thd->options |= OPTION_BIG_SELECTS;

  thd->proc_info=0;
  thd->version=refresh_version;
1264 1265
  thd->security_ctx->priv_user=
    thd->security_ctx->user= (char*) my_strdup("boot", MYF(MY_WME));
1266 1267 1268 1269 1270 1271
  /*
    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
1272

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

1297
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1298
           buff[length-1] == ';'))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1299 1300
      length--;
    buff[length]=0;
1301
    thd->query_length=length;
1302 1303
    thd->query= thd->memdup_w_gap(buff, length+1, 
				  thd->db_length+1+QUERY_CACHE_FLAGS_SIZE);
1304
    thd->query[length] = '\0';
1305 1306 1307 1308
    /*
      We don't need to obtain LOCK_thread_count here because in bootstrap
      mode we have only one thread.
    */
1309
    thd->query_id=next_query_id();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1310 1311
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
1312
    if (thd->is_fatal_error)
1313
      break;
1314
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1315
#ifdef USING_TRANSACTIONS
1316
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
1317
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1318
  }
1319 1320 1321

  /* thd->fatal_error should be set in case something went wrong */
end:
1322 1323 1324 1325 1326 1327
  bootstrap_error= thd->is_fatal_error;

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

hf@deer.(none)'s avatar
hf@deer.(none) committed
1328
#ifndef EMBEDDED_LIBRARY
1329 1330 1331
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1332
  (void) pthread_cond_broadcast(&COND_thread_count);
1333 1334
  my_thread_end();
  pthread_exit(0);
hf@deer.(none)'s avatar
hf@deer.(none) committed
1335
#endif
1336
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1337 1338 1339
}


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

void cleanup_items(Item *item)
{
monty@mysql.com's avatar
monty@mysql.com committed
1344
  DBUG_ENTER("cleanup_items");  
1345 1346
  for (; item ; item=item->next)
    item->cleanup();
monty@mysql.com's avatar
monty@mysql.com committed
1347
  DBUG_VOID_RETURN;
1348 1349
}

1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
/*
  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
1370 1371 1372 1373 1374 1375
{
  TABLE* table;
  TABLE_LIST* table_list;
  int error = 0;
  DBUG_ENTER("mysql_table_dump");
  db = (db && db[0]) ? db : thd->db;
1376
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
1377
    DBUG_RETURN(1); // out of memory
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1378
  table_list->db= db;
1379
  table_list->table_name= table_list->alias= tbl_name;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1380 1381
  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
1382

1383 1384
  if (!db || check_db_name(db))
  {
1385
    my_error(ER_WRONG_DB_NAME ,MYF(0), db ? db : "NULL");
1386 1387
    goto err;
  }
1388
  if (lower_case_table_names)
1389
    my_casedn_str(files_charset_info, tbl_name);
1390
  remove_escape(table_list->table_name);
1391 1392 1393 1394

  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
1395
  if (check_one_table_access(thd, SELECT_ACL, table_list))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1396 1397
    goto err;
  thd->free_list = 0;
1398
  thd->query_length=(uint) strlen(tbl_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1399
  thd->query = tbl_name;
1400
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1401
  {
1402
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1403 1404
    goto err;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1405
  net_flush(&thd->net);
1406
  if ((error= table->file->dump(thd,-1)))
1407
    my_error(ER_GET_ERRNO, MYF(0), error);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1408

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1409
err:
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1410
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1411 1412
}

1413 1414 1415 1416
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1417
    end_trans()
1418 1419 1420 1421 1422 1423 1424
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1425
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
1426 1427 1428
{
  bool do_release= 0;
  int res= 0;
1429
  DBUG_ENTER("end_trans");
1430

1431
  if (unlikely(thd->in_sub_stmt))
1432 1433 1434 1435
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
1436 1437 1438 1439 1440 1441
  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);
  }
1442 1443 1444 1445 1446 1447 1448 1449
  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;
1450
    res= ha_commit(thd);
1451
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
1452 1453
    break;
  case COMMIT_RELEASE:
serg@serg.mylan's avatar
serg@serg.mylan committed
1454
    do_release= 1; /* fall through */
1455 1456 1457 1458 1459 1460
  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
1461
    do_release= 1; /* fall through */
1462 1463 1464 1465
  case ROLLBACK:
  case ROLLBACK_AND_CHAIN:
  {
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
serg@serg.mylan's avatar
serg@serg.mylan committed
1466
    if (ha_rollback(thd))
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
      res= -1;
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    if (!res && (completion == ROLLBACK_AND_CHAIN))
      res= begin_trans(thd);
    break;
  }
  default:
    res= -1;
    my_error(ER_UNKNOWN_COM_ERROR, MYF(0));
    DBUG_RETURN(-1);
  }
serg@serg.mylan's avatar
serg@serg.mylan committed
1478

1479 1480 1481
  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
1482 1483
    thd->killed= THD::KILL_CONNECTION;

1484 1485
  DBUG_RETURN(res);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1486

1487
#ifndef EMBEDDED_LIBRARY
1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498

/*
  Read one command from socket and execute it (query or simple command).
  This function is called in loop from thread function.
  SYNOPSIS
    do_command()
  RETURN VALUE
    0  success
    1  request of thread shutdown (see dispatch_command() description)
*/

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1499 1500 1501
bool do_command(THD *thd)
{
  char *packet;
1502 1503
  uint old_timeout;
  ulong packet_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1504 1505 1506 1507 1508
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
1509 1510 1511 1512
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1513
  thd->lex->current_select= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1514 1515

  packet=0;
1516
  old_timeout=net->read_timeout;
monty@mysql.com's avatar
monty@mysql.com committed
1517
  /* Wait max for 8 hours */
1518
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
1519
  thd->clear_error();				// Clear error message
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1520 1521 1522 1523

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1524 1525 1526 1527 1528
    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)
1529 1530
    {
      statistic_increment(aborted_threads,&LOCK_status);
1531
      DBUG_RETURN(TRUE);			// We have to close it.
1532
    }
1533
    net_send_error(thd, net->last_errno, NullS);
1534
    net->error= 0;
1535
    DBUG_RETURN(FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1536 1537 1538 1539 1540
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1541 1542
    if (command >= COM_END)
      command= COM_END;				// Wrong command
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1543 1544 1545
    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
1546
  }
1547
  net->read_timeout=old_timeout;		// restore it
1548 1549 1550 1551 1552 1553 1554 1555 1556
  /*
    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.
  */
1557
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1558
}
1559
#endif  /* EMBEDDED_LIBRARY */
1560

1561

1562 1563
/*
   Perform one connection-level (COM_XXXX) command.
1564

1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
  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
*/
1578

1579 1580 1581 1582
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1583
  bool error= 0;
1584 1585
  DBUG_ENTER("dispatch_command");

1586 1587 1588
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
    thd->killed= THD::NOT_KILLED;

1589
  thd->command=command;
1590
  /*
1591 1592
    Commands which always take a long time are logged into
    the slow log only if opt_log_slow_admin_statements is set.
1593
  */
1594
  thd->enable_slow_log= TRUE;
1595
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
1596
  thd->set_time();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1597 1598 1599
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
1600
    next_query_id();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1601
  thread_running++;
1602
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1603
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1604

1605 1606
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1607
  switch (command) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1608
  case COM_INIT_DB:
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1609 1610
  {
    LEX_STRING tmp;
1611 1612
    statistic_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB],
			&LOCK_status);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1613 1614
    thd->convert_string(&tmp, system_charset_info,
			packet, strlen(packet), thd->charset());
1615 1616
    if (!mysql_change_db(thd, tmp.str, FALSE))
    {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1617
      mysql_log.write(thd,command,"%s",thd->db);
1618 1619
      send_ok(thd);
    }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1620 1621
    break;
  }
1622
#ifdef HAVE_REPLICATION
1623 1624
  case COM_REGISTER_SLAVE:
  {
1625
    if (!register_slave(thd, (uchar*)packet, packet_length))
1626
      send_ok(thd);
1627 1628
    break;
  }
1629
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1630
  case COM_TABLE_DUMP:
1631 1632 1633
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1634
    if (db_len >= packet_length || db_len > NAME_LEN)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1635
    {
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1636
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1637 1638
      break;
    }
1639
    uint tbl_len= *(uchar*) (packet + db_len + 1);
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1640 1641
    if (db_len+tbl_len+2 > packet_length || tbl_len > NAME_LEN)
    {
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1642
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1643 1644
      break;
    }
1645

1646
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1647
    thd->enable_slow_log= opt_log_slow_admin_statements;
1648
    db= thd->alloc(db_len + tbl_len + 2);
1649 1650 1651 1652 1653
    if (!db)
    {
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
      break;
    }
1654 1655
    tbl_name= strmake(db, packet + 1, db_len)+1;
    strmake(tbl_name, packet + db_len + 2, tbl_len);
1656
    mysql_table_dump(thd, db, tbl_name);
1657 1658
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1659 1660
  case COM_CHANGE_USER:
  {
1661
    thd->change_user();
1662
    thd->clear_error();                         // if errors from rollback
1663

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

1692 1693 1694
    /* Save user and privileges */
    uint save_db_length= thd->db_length;
    char *save_db= thd->db;
1695
    Security_context save_security_ctx= *thd->security_ctx;
1696
    USER_CONN *save_user_connect= thd->user_connect;
1697 1698

    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
1699
    {
1700
      thd->security_ctx->user= save_security_ctx.user;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1701
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1702 1703
      break;
    }
peter@mysql.com's avatar
peter@mysql.com committed
1704

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

1709 1710
    if (res)
    {
1711
      /* authentication failure, we shall restore old user */
1712
      if (res > 0)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1713
        my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1714 1715
      x_free(thd->security_ctx->user);
      *thd->security_ctx= save_security_ctx;
1716
      thd->user_connect= save_user_connect;
1717 1718 1719 1720 1721
      thd->db= save_db;
      thd->db_length= save_db_length;
    }
    else
    {
1722
#ifndef NO_EMBEDDED_ACCESS_CHECKS
1723
      /* we've authenticated new user */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1724 1725
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1726
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
1727
      x_free((gptr) save_db);
1728
      x_free((gptr)  save_security_ctx.user);
1729
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1730 1731
    break;
  }
1732
  case COM_STMT_EXECUTE:
1733
  {
1734
    mysql_stmt_execute(thd, packet, packet_length);
1735 1736
    break;
  }
1737
  case COM_STMT_FETCH:
1738 1739 1740 1741
  {
    mysql_stmt_fetch(thd, packet, packet_length);
    break;
  }
1742
  case COM_STMT_SEND_LONG_DATA:
1743
  {
1744
    mysql_stmt_get_longdata(thd, packet, packet_length);
1745 1746
    break;
  }
1747
  case COM_STMT_PREPARE:
1748
  {
1749
    mysql_stmt_prepare(thd, packet, packet_length);
1750 1751
    break;
  }
1752
  case COM_STMT_CLOSE:
1753
  {
1754
    mysql_stmt_close(thd, packet);
1755 1756
    break;
  }
1757
  case COM_STMT_RESET:
1758 1759 1760 1761
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1762 1763
  case COM_QUERY:
  {
1764 1765
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1766
    char *packet_end= thd->query + thd->query_length;
1767 1768 1769
    /* 'b' stands for 'buffer' parameter', special for 'my_snprintf' */
    const char *format= "%.*b";
    mysql_log.write(thd,command, format, thd->query_length, thd->query);
1770
    DBUG_PRINT("query",("%-.4096s",thd->query));
1771 1772 1773 1774

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

1775
    mysql_parse(thd,thd->query, thd->query_length);
1776

1777
    while (!thd->killed && thd->lex->found_semicolon && !thd->net.report_error)
1778
    {
1779
      char *packet= thd->lex->found_semicolon;
1780
      net->no_send_error= 0;
1781
      /*
1782 1783
        Multiple queries exits, execute them individually
      */
1784 1785
      if (thd->lock || thd->open_tables || thd->derived_tables ||
          thd->prelocked_mode)
1786
        close_thread_tables(thd);
1787
      ulong length= (ulong)(packet_end-packet);
1788

1789
      log_slow_statement(thd);
1790

1791
      /* Remove garbage at start of query */
1792
      while (my_isspace(thd->charset(), *packet) && length > 0)
1793 1794 1795 1796
      {
        packet++;
        length--;
      }
monty@mysql.com's avatar
monty@mysql.com committed
1797
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1798
      thd->query_length= length;
1799
      thd->query= packet;
1800
      thd->query_id= next_query_id();
1801
      thd->set_time(); /* Reset the query start time. */
1802
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1803
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1804 1805 1806
      mysql_parse(thd, packet, length);
    }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1807 1808 1809 1810 1811
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1812
  case COM_FIELD_LIST:				// This isn't actually needed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1813
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1814 1815
    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
1816 1817 1818
    break;
#else
  {
1819
    char *fields, *pend;
1820 1821
    /* Locked closure of all tables */
    TABLE_LIST *locked_tables= NULL;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1822
    TABLE_LIST table_list;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1823
    LEX_STRING conv_name;
1824
    /* Saved variable value */
1825 1826
    my_bool old_innodb_table_locks= 
              IF_INNOBASE_DB(thd->variables.innodb_table_locks, FALSE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1827 1828
    /* used as fields initializator */
    lex_start(thd, 0, 0);
1829

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1830

1831 1832
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1833
    bzero((char*) &table_list,sizeof(table_list));
1834
    if (thd->copy_db_to(&table_list.db, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1835
      break;
1836
    pend= strend(packet);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1837 1838
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1839
    table_list.alias= table_list.table_name= conv_name.str;
1840
    packet= pend+1;
1841 1842 1843 1844 1845 1846 1847 1848 1849

    if (!my_strcasecmp(system_charset_info, table_list.db,
                       information_schema_name.str))
    {
      ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, table_list.alias);
      if (schema_table)
        table_list.schema_table= schema_table;
    }

1850
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
1851 1852
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1853
    mysql_log.write(thd,command,"%s %s",table_list.table_name, fields);
1854
    if (lower_case_table_names)
1855 1856
      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
1857

monty@mysql.com's avatar
monty@mysql.com committed
1858
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
1859
		     0, 0, test(table_list.schema_table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1860
      break;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1861 1862
    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
1863
      break;
1864 1865 1866 1867 1868 1869
    /* 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
1870
    thd->lex->add_to_query_tables(&table_list);
1871

1872 1873
    /* 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
1874
    mysqld_list_fields(thd,&table_list,fields);
1875
    thd->lex->unit.cleanup();
1876
    thd->cleanup_after_query();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1877 1878 1879 1880
    break;
  }
#endif
  case COM_QUIT:
1881
    /* We don't calculate statistics for this command */
1882
    mysql_log.write(thd,command,NullS);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1883 1884 1885 1886
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

1887
  case COM_CREATE_DB:				// QQ: To be removed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1888
    {
1889
      char *db=thd->strdup(packet), *alias;
1890
      HA_CREATE_INFO create_info;
1891

1892 1893
      statistic_increment(thd->status_var.com_stat[SQLCOM_CREATE_DB],
			  &LOCK_status);
1894
      // null test to handle EOM
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
1895
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1896
      {
1897
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1898 1899
	break;
      }
1900
      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
1901
	break;
1902
      mysql_log.write(thd,command,packet);
1903
      bzero(&create_info, sizeof(create_info));
1904 1905
      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
1906 1907
      break;
    }
1908
  case COM_DROP_DB:				// QQ: To be removed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1909
    {
1910 1911
      statistic_increment(thd->status_var.com_stat[SQLCOM_DROP_DB],
			  &LOCK_status);
1912
      char *db=thd->strdup(packet);
monty@mysql.com's avatar
monty@mysql.com committed
1913
      /*  null test to handle EOM */
1914
      if (!db || check_db_name(db))
1915
      {
1916
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1917 1918
	break;
      }
1919
      if (check_access(thd,DROP_ACL,db,0,1,0,is_schema_db(db)))
1920
	break;
1921 1922
      if (thd->locked_tables || thd->active_transaction())
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1923 1924
	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
1925
	break;
1926
      }
1927
      mysql_log.write(thd,command,db);
1928
      mysql_rm_db(thd, db, 0, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1929 1930
      break;
    }
1931
#ifndef EMBEDDED_LIBRARY
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1932 1933
  case COM_BINLOG_DUMP:
    {
monty@mysql.com's avatar
monty@mysql.com committed
1934 1935 1936 1937
      ulong pos;
      ushort flags;
      uint32 slave_server_id;

1938
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1939
      thd->enable_slow_log= opt_log_slow_admin_statements;
1940
      if (check_global_access(thd, REPL_SLAVE_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1941
	break;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1942

1943
      /* TODO: The following has to be changed to an 8 byte integer */
1944 1945
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
1946
      thd->server_id=0; /* avoid suicide */
1947
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
1948
	kill_zombie_dump_threads(slave_server_id);
1949
      thd->server_id = slave_server_id;
monty@mysql.com's avatar
monty@mysql.com committed
1950 1951 1952

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

    STATUS_VAR current_global_status_var;
    calc_sum_of_all_status(&current_global_status_var);

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

2124 2125 2126
  /* 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
2127
  if (thd->net.report_error)
2128
    net_send_error(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2129

2130
  log_slow_statement(thd);
2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145

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


2146
void log_slow_statement(THD *thd)
2147
{
2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158
  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;
2159
  thd->end_time();				// Set start time
2160

2161 2162 2163 2164 2165
  /*
    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
2166
  {
2167 2168
    thd->proc_info="logging slow query";

2169 2170
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2171
        (thd->server_status &
2172
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2173 2174 2175
        (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES) &&
        /* == SQLCOM_END unless this is a SHOW command */
        thd->lex->orig_sql_command == SQLCOM_END)
2176
    {
2177
      thd->status_var.long_query_count++;
2178 2179
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2180 2181 2182
  }
}

2183

2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211
/*
  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.
*/

2212 2213 2214 2215 2216
int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
                         enum enum_schema_tables schema_table_idx)
{
  DBUG_ENTER("prepare_schema_table");
  SELECT_LEX *sel= 0;
2217
  switch (schema_table_idx) {
2218 2219
  case SCH_SCHEMATA:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2220 2221
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0));   /* purecov: inspected */
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
    DBUG_RETURN(1);
#else
    if ((specialflag & SPECIAL_SKIP_SHOW_DB) &&
	check_global_access(thd, SHOW_DB_ACL))
      DBUG_RETURN(1);
    break;
#endif
  case SCH_TABLE_NAMES:
  case SCH_TABLES:
  case SCH_VIEWS:
2232
  case SCH_TRIGGERS:
2233
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2234 2235
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2236 2237 2238
    DBUG_RETURN(1);
#else
    {
2239 2240 2241
      char *db;
      if (lex->select_lex.db == NULL &&
          thd->copy_db_to(&lex->select_lex.db, 0))
2242
      {
2243
        DBUG_RETURN(1);
2244
      }
2245
      db= lex->select_lex.db;
2246 2247 2248
      remove_escape(db);				// Fix escaped '_'
      if (check_db_name(db))
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2249
        my_error(ER_WRONG_DB_NAME, MYF(0), db);
2250 2251
        DBUG_RETURN(1);
      }
2252 2253
      if (check_access(thd, SELECT_ACL, db, &thd->col_access, 0, 0,
                       is_schema_db(db)))
2254 2255 2256
        DBUG_RETURN(1);			        /* purecov: inspected */
      if (!thd->col_access && check_grant_db(thd,db))
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2257
	my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
2258 2259
                 thd->security_ctx->priv_user, thd->security_ctx->priv_host,
                 db);
2260 2261 2262 2263 2264 2265 2266 2267
	DBUG_RETURN(1);
      }
      break;
    }
#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
2268 2269
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2270 2271 2272 2273 2274 2275
    DBUG_RETURN(1);
#else
    if (table_ident)
    {
      TABLE_LIST **query_tables_last= lex->query_tables_last;
      sel= new SELECT_LEX();
2276 2277
      /* 'parent_lex' is used in init_query() so it must be before it. */
      sel->parent_lex= lex;
2278
      sel->init_query();
monty@mishka.local's avatar
monty@mishka.local committed
2279
      if (!sel->add_table_to_list(thd, table_ident, 0, 0, TL_READ, 
2280 2281 2282 2283 2284 2285
                                 (List<String> *) 0, (List<String> *) 0))
        DBUG_RETURN(1);
      lex->query_tables_last= query_tables_last;
      TABLE_LIST *table_list= (TABLE_LIST*) sel->table_list.first;
      char *db= table_list->db;
      remove_escape(db);			// Fix escaped '_'
2286
      remove_escape(table_list->table_name);
2287
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
2288 2289
                       &table_list->grant.privilege, 0, 0,
                       test(table_list->schema_table)))
2290 2291 2292 2293 2294 2295 2296
        DBUG_RETURN(1);				/* purecov: inspected */
      if (grant_option && check_grant(thd, SELECT_ACL, table_list, 2,
                                      UINT_MAX, 0))
        DBUG_RETURN(1);
      break;
    }
#endif
2297 2298 2299
  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320
  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;
  table_list->schema_select_lex= sel;
2321
  table_list->schema_table_reformed= 1;
2322 2323
  statistic_increment(thd->status_var.com_stat[lex->orig_sql_command],
                      &LOCK_status);
2324 2325 2326 2327
  DBUG_RETURN(0);
}


2328 2329
/*
  Read query from packet and store in thd->query
2330
  Used in COM_QUERY and COM_STMT_PREPARE
2331 2332 2333 2334 2335 2336 2337

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
2338 2339
    FALSE ok
    TRUE  error;  In this case thd->fatal_error is set
2340 2341
*/

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

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

2372
  return FALSE;
2373 2374
}

2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
static void reset_one_shot_variables(THD *thd) 
{
  thd->variables.character_set_client=
    global_system_variables.character_set_client;
  thd->variables.collation_connection=
    global_system_variables.collation_connection;
  thd->variables.collation_database=
    global_system_variables.collation_database;
  thd->variables.collation_server=
    global_system_variables.collation_server;
  thd->update_charset();
  thd->variables.time_zone=
    global_system_variables.time_zone;
  thd->one_shot_set= 0;
}

2391

2392
/*
2393
  Execute command saved in thd and lex->sql_command
2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414

  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
2415

2416
bool
2417
mysql_execute_command(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2418
{
2419 2420 2421 2422
  bool res= FALSE;
  bool need_start_waiting= FALSE; // have protection against global read lock
  int  result= 0;
  LEX  *lex= thd->lex;
monty@mysql.com's avatar
monty@mysql.com committed
2423
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2424
  SELECT_LEX *select_lex= &lex->select_lex;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2425
  /* first table of first SELECT_LEX */
monty@mysql.com's avatar
monty@mysql.com committed
2426
  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
2427 2428 2429
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
2430
  SELECT_LEX_UNIT *unit= &lex->unit;
2431
  /* Saved variable value */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2432
  DBUG_ENTER("mysql_execute_command");
2433
  thd->net.no_send_error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2434

2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448
  /*
    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
2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
  /*
    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();
2465
  /* should be assigned after making first tables same */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2466
  all_tables= lex->query_tables;
2467 2468 2469 2470
  /* 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
2471

2472 2473 2474 2475 2476
  /*
    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.
2477
    Don't reset warnings when executing a stored routine.
2478
  */
2479
  if ((all_tables || &lex->select_lex != lex->all_selects_list ||
2480
       lex->sroutines.records) && !thd->spcont ||
2481
      lex->time_zone_tables_used)
monty@mysql.com's avatar
monty@mysql.com committed
2482
    mysql_reset_errors(thd, 0);
2483

hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
2484
#ifdef HAVE_REPLICATION
2485
  if (unlikely(thd->slave_thread))
2486
  {
peter@mysql.com's avatar
peter@mysql.com committed
2487
    /*
2488 2489
      Check if statment should be skipped because of slave filtering
      rules
2490 2491

      Exceptions are:
2492 2493
      - UPDATE MULTI: For this statement, we want to check the filtering
        rules later in the code
2494
      - SET: we always execute it (Not that many SET commands exists in
lars@mysql.com's avatar
lars@mysql.com committed
2495 2496
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
2497 2498
      - 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
2499
    */
2500 2501
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
	!(lex->sql_command == SQLCOM_SET_OPTION) &&
2502
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2503
          lex->drop_temporary && lex->drop_if_exists) &&
guilhem@mysql.com's avatar
Merge  
guilhem@mysql.com committed
2504
        all_tables_not_ok(thd, all_tables))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2505 2506
    {
      /* we warn the slave SQL thread */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2507
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524
      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);
      }
2525
      DBUG_RETURN(0);
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2526
    }
2527
  }
2528
  else
2529
  {
2530
#endif /* HAVE_REPLICATION */
2531 2532 2533 2534 2535
    /*
      When option readonly is set deny operations which change non-temporary
      tables. Except for the replication thread and the 'super' users.
    */
    if (opt_readonly &&
2536 2537 2538 2539 2540 2541 2542
        !(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)))
2543 2544 2545 2546 2547 2548 2549
    {
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
      DBUG_RETURN(-1);
    }
#ifdef HAVE_REPLICATION
  } /* endif unlikely slave */
#endif
2550 2551 2552
  if(lex->orig_sql_command == SQLCOM_END)
    statistic_increment(thd->status_var.com_stat[lex->sql_command],
                        &LOCK_status);
2553

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2554 2555 2556
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2557 2558 2559 2560
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
2561 2562
	param->select_limit=
          new Item_int((ulonglong)thd->variables.select_limit);
2563 2564
    }

2565
    select_result *result=lex->result;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2566
    if (all_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2567
    {
2568 2569 2570 2571 2572 2573
      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
2574 2575
    }
    else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2576 2577
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
2578
			any_db, 0, 0, 0, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2579
    if (res)
2580
      goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2581

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2582
    if (!(res= open_and_lock_tables(thd, all_tables)))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2583
    {
2584
      if (lex->describe)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2585
      {
2586 2587 2588 2589 2590 2591
        /*
          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.
        */
2592
	if (!(result= new select_send()))
2593
	  goto error;
2594 2595
	else
	  thd->send_explain_fields(result);
2596
	res= mysql_explain_union(thd, &thd->lex->unit, result);
2597 2598 2599 2600 2601
	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
2602
	  thd->lex->unit.print(&str);
2603 2604 2605 2606
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2607
	result->send_eof();
2608
        delete result;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2609 2610 2611
      }
      else
      {
2612
	if (!result && !(result= new select_send()))
2613
          goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2614
	query_cache_store_query(thd, all_tables);
2615
	res= handle_select(thd, lex, result, 0);
2616 2617
        if (result != lex->result)
          delete result;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2618
      }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2619
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2620 2621
    break;
  }
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2622
  case SQLCOM_PREPARE:
2623
  {
2624
    mysql_sql_stmt_prepare(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2625 2626 2627 2628
    break;
  }
  case SQLCOM_EXECUTE:
  {
2629
    mysql_sql_stmt_execute(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2630 2631 2632 2633
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2634
    mysql_sql_stmt_close(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2635 2636
    break;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2637
  case SQLCOM_DO:
2638 2639
    if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
        open_and_lock_tables(thd, all_tables))
2640
      goto error;
2641 2642

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

2645
  case SQLCOM_EMPTY_QUERY:
2646
    send_ok(thd);
2647 2648
    break;

2649 2650 2651 2652
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2653
#ifndef EMBEDDED_LIBRARY
2654
  case SQLCOM_PURGE:
2655
  {
2656
    if (check_global_access(thd, SUPER_ACL))
2657
      goto error;
monty@mysql.com's avatar
monty@mysql.com committed
2658
    /* PURGE MASTER LOGS TO 'file' */
2659 2660 2661
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2662 2663
  case SQLCOM_PURGE_BEFORE:
  {
2664 2665
    Item *it;

2666 2667
    if (check_global_access(thd, SUPER_ACL))
      goto error;
monty@mysql.com's avatar
monty@mysql.com committed
2668
    /* PURGE MASTER LOGS BEFORE 'data' */
2669
    it= (Item *)lex->value_list.head();
2670
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
2671
        it->check_cols(1))
2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682
    {
      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());
2683 2684
    break;
  }
2685
#endif
2686 2687
  case SQLCOM_SHOW_WARNS:
  {
2688 2689
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2690 2691 2692
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
2693 2694 2695 2696
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2697 2698
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
2699 2700
    break;
  }
2701 2702
  case SQLCOM_SHOW_NEW_MASTER:
  {
2703
    if (check_global_access(thd, REPL_SLAVE_ACL))
2704
      goto error;
2705
    /* This query don't work now. See comment in repl_failsafe.cc */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2706
#ifndef WORKING_NEW_MASTER
2707 2708
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "SHOW NEW MASTER");
    goto error;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2709
#else
2710 2711
    res = show_new_master(thd);
    break;
2712
#endif
2713
  }
2714

2715
#ifdef HAVE_REPLICATION
2716 2717
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
2718
    if (check_global_access(thd, REPL_SLAVE_ACL))
2719 2720 2721 2722
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
2723 2724
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
2725
    if (check_global_access(thd, REPL_SLAVE_ACL))
2726
      goto error;
2727
    res = mysql_show_binlog_events(thd);
2728 2729
    break;
  }
2730 2731
#endif

2732
  case SQLCOM_BACKUP_TABLE:
2733
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2734 2735 2736
    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) ||
2737
	check_global_access(thd, FILE_ACL))
2738
      goto error; /* purecov: inspected */
2739
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2740
    res = mysql_backup_table(thd, first_table);
2741
    select_lex->table_list.first= (byte*) first_table;
2742
    lex->query_tables=all_tables;
2743 2744
    break;
  }
2745
  case SQLCOM_RESTORE_TABLE:
2746
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2747 2748 2749
    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) ||
2750
	check_global_access(thd, FILE_ACL))
2751
      goto error; /* purecov: inspected */
2752
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2753
    res = mysql_restore_table(thd, first_table);
2754
    select_lex->table_list.first= (byte*) first_table;
2755
    lex->query_tables=all_tables;
2756 2757
    break;
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2758 2759
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2760 2761 2762
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
2763 2764
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2765
      goto error;
2766
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2767 2768
    break;
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2769 2770
  case SQLCOM_PRELOAD_KEYS:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2771 2772 2773
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
2774 2775
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
2776
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2777
    res = mysql_preload_keys(thd, first_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2778 2779
    break;
  }
2780
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2781
  case SQLCOM_CHANGE_MASTER:
2782
  {
2783
    if (check_global_access(thd, SUPER_ACL))
2784
      goto error;
2785
    pthread_mutex_lock(&LOCK_active_mi);
2786
    res = change_master(thd,active_mi);
2787
    pthread_mutex_unlock(&LOCK_active_mi);
2788 2789
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2790
  case SQLCOM_SHOW_SLAVE_STAT:
2791
  {
2792 2793
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2794
      goto error;
2795
    pthread_mutex_lock(&LOCK_active_mi);
2796
    res = show_master_info(thd,active_mi);
2797
    pthread_mutex_unlock(&LOCK_active_mi);
2798 2799
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2800
  case SQLCOM_SHOW_MASTER_STAT:
2801
  {
2802 2803
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2804 2805 2806 2807
      goto error;
    res = show_binlog_info(thd);
    break;
  }
peter@mysql.com's avatar
peter@mysql.com committed
2808

2809
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
2810
    if (check_global_access(thd, SUPER_ACL))
2811
      goto error;
2812
    if (end_active_trans(thd))
2813
      goto error;
2814 2815
    else
      res = load_master_data(thd);
2816
    break;
2817
#endif /* HAVE_REPLICATION */
2818 2819 2820 2821 2822 2823 2824
#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
2825 2826 2827
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
2828
      if (check_global_access(thd, SUPER_ACL))
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2829 2830 2831 2832
	goto error;
      res = innodb_show_status(thd);
      break;
    }
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2833 2834 2835
  case SQLCOM_SHOW_MUTEX_STATUS:
    {
      if (check_global_access(thd, SUPER_ACL))
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2836
        goto error;
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2837 2838 2839
      res = innodb_mutex_show_status(thd);
      break;
    }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2840
#endif
2841
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2842
  case SQLCOM_LOAD_MASTER_TABLE:
2843
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2844
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
2845 2846
    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
2847
    if (check_access(thd, CREATE_ACL, first_table->db,
2848 2849
		     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2850 2851 2852 2853
      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
2854
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2855
	goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2856
    }
2857
    if (strlen(first_table->table_name) > NAME_LEN)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2858
    {
2859
      my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2860 2861
      break;
    }
2862
    pthread_mutex_lock(&LOCK_active_mi);
2863 2864 2865 2866
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2867
    if (!fetch_master_table(thd, first_table->db, first_table->table_name,
2868
			    active_mi, 0, 0))
2869
    {
2870
      send_ok(thd);
2871
    }
2872
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2873
    break;
2874
  }
2875
#endif /* HAVE_REPLICATION */
2876

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2877
  case SQLCOM_CREATE_TABLE:
2878
  {
2879
    /* If CREATE TABLE of non-temporary table, do implicit commit */
2880 2881 2882 2883 2884 2885 2886 2887 2888 2889
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
    {
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
    else 
    {
2890 2891
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
2892
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2893 2894 2895 2896 2897
    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;
monty@mysql.com's avatar
monty@mysql.com committed
2898

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

2902 2903 2904
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
2905
    /* Fix names if symlinked tables */
2906
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
2907
			   create_table->table_name) ||
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2908
	append_file_to_dir(thd, &lex->create_info.index_file_name,
2909
			   create_table->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
2910
      goto end_with_restore_list;
2911
#endif
2912
    /*
2913
      If we are using SET CHARSET without DEFAULT, add an implicit
2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924
      DEFAULT to not confuse old users. (This may change).
    */
    if ((lex->create_info.used_fields & 
	 (HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) ==
	HA_CREATE_USED_CHARSET)
    {
      lex->create_info.used_fields&= ~HA_CREATE_USED_CHARSET;
      lex->create_info.used_fields|= HA_CREATE_USED_DEFAULT_CHARSET;
      lex->create_info.default_table_charset= lex->create_info.table_charset;
      lex->create_info.table_charset= 0;
    }
2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937
    /*
      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.
    */
2938 2939
    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
2940
    {
monty@mysql.com's avatar
monty@mysql.com committed
2941 2942
      res= 1;
      goto end_with_restore_list;
2943
    }
2944
    if (select_lex->item_list.elements)		// With select
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2945 2946
    {
      select_result *result;
2947

2948
      select_lex->options|= SELECT_NO_UNLOCK;
2949
      unit->set_limit(select_lex);
2950

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2951
      if (!(res= open_and_lock_tables(thd, select_tables)))
2952
      {
2953 2954 2955 2956
        /*
          Is table which we are changing used somewhere in other parts
          of query
        */
2957
        if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
2958
        {
2959
          TABLE_LIST *duplicate;
2960
          if ((duplicate= unique_table(thd, create_table, select_tables)))
2961 2962 2963
          {
            update_non_unique_table_error(create_table, "CREATE", duplicate);
            res= 1;
2964
            goto end_with_restore_list;
2965
          }
2966
        }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2967 2968 2969 2970 2971 2972 2973 2974
        /* If we create merge table, we have to test tables in merge, too */
        if (lex->create_info.used_fields & HA_CREATE_USED_UNION)
        {
          TABLE_LIST *tab;
          for (tab= (TABLE_LIST*) lex->create_info.merge_list.first;
               tab;
               tab= tab->next_local)
          {
2975
            TABLE_LIST *duplicate;
2976
            if ((duplicate= unique_table(thd, tab, select_tables)))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2977
            {
2978
              update_non_unique_table_error(tab, "CREATE", duplicate);
monty@mysql.com's avatar
monty@mysql.com committed
2979
              res= 1;
2980
              goto end_with_restore_list;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2981 2982 2983
            }
          }
        }
2984

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2985 2986 2987 2988 2989
        if ((result= new select_create(create_table,
				       &lex->create_info,
				       lex->create_list,
				       lex->key_list,
				       select_lex->item_list,
2990 2991
				       lex->duplicates,
				       lex->ignore)))
2992 2993 2994 2995 2996
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
2997
          res= handle_select(thd, lex, result, 0);
2998
          delete result;
2999
        }
monty@mysql.com's avatar
monty@mysql.com committed
3000
	/* reset for PS */
3001 3002
	lex->create_list.empty();
	lex->key_list.empty();
3003 3004
      }
    }
monty@mysql.com's avatar
monty@mysql.com committed
3005
    else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3006
    {
monty@mysql.com's avatar
monty@mysql.com committed
3007
      /* regular create */
venu@myvenu.com's avatar
venu@myvenu.com committed
3008
      if (lex->name)
monty@mysql.com's avatar
monty@mysql.com committed
3009
        res= mysql_create_like_table(thd, create_table, &lex->create_info, 
venu@myvenu.com's avatar
venu@myvenu.com committed
3010 3011
                                     (Table_ident *)lex->name); 
      else
3012
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3013
        res= mysql_create_table(thd, create_table->db,
3014
				create_table->table_name, &lex->create_info,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3015
				lex->create_list,
monty@mysql.com's avatar
monty@mysql.com committed
3016
				lex->key_list, 0, 0);
3017
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3018
      if (!res)
3019
	send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3020
    }
3021

monty@mysql.com's avatar
monty@mysql.com committed
3022
    /* put tables back for PS rexecuting */
monty@mysql.com's avatar
monty@mysql.com committed
3023
end_with_restore_list:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3024
    lex->link_first_table_back(create_table, link_to_local);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3025
    break;
3026
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3027
  case SQLCOM_CREATE_INDEX:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3028 3029
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3030
      goto error; /* purecov: inspected */
3031
    thd->enable_slow_log= opt_log_slow_admin_statements;
3032
    if (end_active_trans(thd))
3033
      goto error;
3034
    else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3035
      res = mysql_create_index(thd, first_table, lex->key_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3036 3037
    break;

3038
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3039
  case SQLCOM_SLAVE_START:
3040
  {
3041
    pthread_mutex_lock(&LOCK_active_mi);
3042
    start_slave(thd,active_mi,1 /* net report*/);
3043
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3044
    break;
3045
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3046
  case SQLCOM_SLAVE_STOP:
3047 3048 3049 3050 3051 3052
  /*
    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,
3053
      so it waits for the client thread because t is locked by it.
3054
    - then the client thread does SLAVE STOP.
3055 3056
      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.
3057 3058 3059
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
3060
  if (thd->locked_tables || thd->active_transaction() || thd->global_read_lock)
3061
  {
3062 3063
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3064
    goto error;
3065
  }
3066
  {
3067
    pthread_mutex_lock(&LOCK_active_mi);
3068
    stop_slave(thd,active_mi,1/* net report*/);
3069
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3070
    break;
3071
  }
3072
#endif /* HAVE_REPLICATION */
3073

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3074
  case SQLCOM_ALTER_TABLE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3075
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3076
    {
3077
      ulong priv=0;
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
3078
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3079
      {
3080
	my_error(ER_WRONG_TABLE_NAME, MYF(0), lex->name);
3081
        goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3082
      }
3083 3084
      /* 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
3085
      if (check_access(thd, ALTER_ACL, first_table->db,
3086 3087 3088 3089
		       &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
3090
	  check_merge_table_access(thd, first_table->db,
3091 3092 3093
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3094 3095
      if (grant_option)
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3096
	if (check_grant(thd, ALTER_ACL, all_tables, 0, UINT_MAX, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3097 3098 3099 3100 3101
	  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));
3102
	  tmp_table.table_name=lex->name;
3103
	  tmp_table.db=select_lex->db;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3104
	  tmp_table.grant.privilege=priv;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3105 3106
	  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
3107 3108 3109
	    goto error;
	}
      }
3110
      /* Don't yet allow changing of symlinks with ALTER TABLE */
3111 3112 3113 3114 3115 3116
      if (lex->create_info.data_file_name)
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                     "DATA DIRECTORY option ignored");
      if (lex->create_info.index_file_name)
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
                     "INDEX DIRECTORY option ignored");
3117
      lex->create_info.data_file_name=lex->create_info.index_file_name=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3118
      /* ALTER TABLE ends previous transaction */
3119
      if (end_active_trans(thd))
3120
	goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3121
      else
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3122
      {
3123 3124 3125 3126 3127 3128 3129
        if (!thd->locked_tables &&
            !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
        {
          res= 1;
          break;
        }

3130
        thd->enable_slow_log= opt_log_slow_admin_statements;
3131
	res= mysql_alter_table(thd, select_lex->db, lex->name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3132
			       &lex->create_info,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3133
			       first_table, lex->create_list,
3134
			       lex->key_list,
3135
			       select_lex->order_list.elements,
3136
                               (ORDER *) select_lex->order_list.first,
3137
			       lex->ignore, &lex->alter_info, 1);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3138
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3139 3140
      break;
    }
3141
  case SQLCOM_RENAME_TABLE:
3142
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3143
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3144
    TABLE_LIST *table;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3145
    if (check_db_used(thd, all_tables))
3146
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3147
    for (table= first_table; table; table= table->next_local->next_local)
3148
    {
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3149
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
3150
		       &table->grant.privilege,0,0, test(table->schema_table)) ||
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3151
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next_local->db,
3152 3153
		       &table->next_local->grant.privilege, 0, 0,
                       test(table->next_local->schema_table)))
3154 3155 3156
	goto error;
      if (grant_option)
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3157
	TABLE_LIST old_list, new_list;
3158 3159 3160 3161
	/*
	  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
3162 3163 3164 3165
	old_list= table[0];
	new_list= table->next_local[0];
	if (check_grant(thd, ALTER_ACL, &old_list, 0, 1, 0) ||
	    (!test_all_bits(table->next_local->grant.privilege,
3166
			    INSERT_ACL | CREATE_ACL) &&
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3167
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0, 1, 0)))
3168 3169 3170
	  goto error;
      }
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3171
    query_cache_invalidate3(thd, first_table, 0);
3172 3173
    if (end_active_trans(thd) || mysql_rename_tables(thd, first_table))
      goto error;
3174
    break;
3175
  }
3176
#ifndef EMBEDDED_LIBRARY
3177 3178
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3179 3180
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3181
    goto error;
3182 3183
#else
    {
3184
      if (check_global_access(thd, SUPER_ACL))
3185 3186 3187 3188
	goto error;
      res = show_binlogs(thd);
      break;
    }
peter@mysql.com's avatar
peter@mysql.com committed
3189
#endif
3190
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3191
  case SQLCOM_SHOW_CREATE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3192
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3193
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3194 3195
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3196
    goto error;
3197
#else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3198
    {
3199 3200 3201 3202
      /* 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
3203 3204
      if (check_db_used(thd, all_tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, first_table->db,
3205 3206
		       &first_table->grant.privilege, 0, 0, 
                       test(first_table->schema_table)))
3207
	goto error;
monty@mishka.local's avatar
monty@mishka.local committed
3208
      if (grant_option && check_grant(thd, SELECT_ACL, all_tables, 2, UINT_MAX, 0))
3209
	goto error;
monty@mishka.local's avatar
monty@mishka.local committed
3210
      res= mysqld_show_create(thd, first_table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3211 3212
      break;
    }
3213
#endif
3214 3215
  case SQLCOM_CHECKSUM:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3216 3217 3218
    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))
3219
      goto error; /* purecov: inspected */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3220
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
3221 3222
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3223
  case SQLCOM_REPAIR:
3224
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3225 3226 3227
    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))
3228
      goto error; /* purecov: inspected */
3229
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3230
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
3231 3232 3233
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3234
      /* Presumably, REPAIR and binlog writing doesn't require synchronization */
3235 3236
      if (mysql_bin_log.is_open())
      {
3237
	thd->clear_error(); // No binlog error generated
3238
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3239 3240 3241
        mysql_bin_log.write(&qinfo);
      }
    }
3242
    select_lex->table_list.first= (byte*) first_table;
3243
    lex->query_tables=all_tables;
3244 3245
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3246
  case SQLCOM_CHECK:
3247
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3248 3249 3250
    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))
3251
      goto error; /* purecov: inspected */
3252
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3253
    res = mysql_check_table(thd, first_table, &lex->check_opt);
3254
    select_lex->table_list.first= (byte*) first_table;
3255
    lex->query_tables=all_tables;
3256 3257
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3258 3259
  case SQLCOM_ANALYZE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3260 3261 3262
    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
3263
      goto error; /* purecov: inspected */
3264
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3265
    res = mysql_analyze_table(thd, first_table, &lex->check_opt);
3266 3267 3268
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3269
      /* Presumably, ANALYZE and binlog writing doesn't require synchronization */
3270 3271
      if (mysql_bin_log.is_open())
      {
3272
	thd->clear_error(); // No binlog error generated
3273
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3274 3275 3276
        mysql_bin_log.write(&qinfo);
      }
    }
3277
    select_lex->table_list.first= (byte*) first_table;
3278
    lex->query_tables=all_tables;
3279
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3280
  }
3281

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3282 3283
  case SQLCOM_OPTIMIZE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3284 3285 3286
    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
3287
      goto error; /* purecov: inspected */
3288
    thd->enable_slow_log= opt_log_slow_admin_statements;
3289
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3290 3291
      mysql_recreate_table(thd, first_table, 1) :
      mysql_optimize_table(thd, first_table, &lex->check_opt);
3292 3293 3294
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
3295
      /* Presumably, OPTIMIZE and binlog writing doesn't require synchronization */
3296 3297
      if (mysql_bin_log.is_open())
      {
3298
	thd->clear_error(); // No binlog error generated
3299
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3300 3301 3302
        mysql_bin_log.write(&qinfo);
      }
    }
3303
    select_lex->table_list.first= (byte*) first_table;
3304
    lex->query_tables=all_tables;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3305 3306 3307
    break;
  }
  case SQLCOM_UPDATE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3308 3309
    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
3310
      break;
3311 3312
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3313 3314 3315 3316 3317 3318
    res= (result= mysql_update(thd, all_tables,
                               select_lex->item_list,
                               lex->value_list,
                               select_lex->where,
                               select_lex->order_list.elements,
                               (ORDER *) select_lex->order_list.first,
3319
                               unit->select_limit_cnt,
3320
                               lex->duplicates, lex->ignore));
3321
    /* mysql_update return 2 if we need to switch to multi-update */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3322
    if (result != 2)
3323
      break;
3324
  case SQLCOM_UPDATE_MULTI:
3325 3326 3327 3328
  {
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    /* if we switched from normal update, rights are checked */
    if (result != 2)
3329
    {
3330 3331 3332 3333 3334
      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
3335

3336
    res= mysql_multi_update_prepare(thd);
3337

3338
#ifdef HAVE_REPLICATION
3339
    /* Check slave filtering rules */
3340
    if (unlikely(thd->slave_thread))
3341
    {
3342 3343
      if (all_tables_not_ok(thd, all_tables))
      {
3344 3345 3346 3347 3348
        if (res!= 0)
        {
          res= 0;             /* don't care of prev failure  */
          thd->clear_error(); /* filters are of highest prior */
        }
3349 3350 3351 3352
        /* we warn the slave SQL thread */
        my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
        break;
      }
3353 3354
      if (res)
        break;
3355
    }
3356 3357
    else
    {
3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370
#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
3371

3372 3373 3374 3375 3376 3377
    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
3378
    break;
monty@mysql.com's avatar
monty@mysql.com committed
3379
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3380
  case SQLCOM_REPLACE:
3381 3382
  case SQLCOM_INSERT:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3383
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
monty@mysql.com's avatar
monty@mysql.com committed
3384
    if ((res= insert_precheck(thd, all_tables)))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3385
      break;
3386 3387 3388 3389 3390 3391 3392 3393

    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
3394
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
monty@mishka.local's avatar
monty@mishka.local committed
3395
		      lex->update_list, lex->value_list,
3396
                      lex->duplicates, lex->ignore);
3397 3398 3399 3400 3401 3402 3403

    /*
      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
3404
    if (first_table->view && !first_table->contain_auto_increment)
3405 3406
      thd->last_insert_id= thd->current_insert_id;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3407
    break;
3408
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3409 3410 3411
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
monty@mysql.com's avatar
monty@mysql.com committed
3412
    select_result *result;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3413
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
monty@mishka.local's avatar
monty@mishka.local committed
3414
    if ((res= insert_precheck(thd, all_tables)))
3415
      break;
monty@mysql.com's avatar
monty@mysql.com committed
3416

3417
    /* Fix lock for first table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3418 3419
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
3420

3421 3422
    /* 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
3423

3424
    unit->set_limit(select_lex);
3425 3426 3427 3428 3429 3430 3431 3432

    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
3433
    if (!(res= open_and_lock_tables(thd, all_tables)))
3434
    {
3435
      /* Skip first table, which is the table we are inserting in */
3436 3437
      TABLE_LIST *second_table= first_table->next_local;
      select_lex->table_list.first= (byte*) second_table;
3438 3439
      select_lex->context.table_list= 
        select_lex->context.first_name_resolution_table= second_table;
3440 3441 3442
      res= mysql_insert_select_prepare(thd);
      if (!res && (result= new select_insert(first_table, first_table->table,
                                             &lex->field_list,
3443 3444
                                             &lex->update_list,
                                             &lex->value_list,
3445
                                             lex->duplicates, lex->ignore)))
3446
      {
3447
	res= handle_select(thd, lex, result, OPTION_SETUP_TABLES_DONE);
3448 3449 3450 3451 3452 3453 3454 3455 3456
        /*
          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)
        {
3457 3458 3459
          /* INSERT ... SELECT should invalidate only the very first table */
          TABLE_LIST *save_table= first_table->next_local;
          first_table->next_local= 0;
3460 3461
          mysql_unlock_tables(thd, thd->lock);
          query_cache_invalidate3(thd, first_table, 1);
3462
          first_table->next_local= save_table;
3463 3464
          thd->lock=0;
        }
3465 3466
        delete result;
      }
3467
      /* revert changes for SP */
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
3468
      select_lex->table_list.first= (byte*) first_table;
3469
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3470

3471 3472 3473 3474 3475 3476
    /*
      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
3477
    if (first_table->view && !first_table->contain_auto_increment)
3478 3479
      thd->last_insert_id= thd->current_insert_id;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3480 3481
    break;
  }
3482
  case SQLCOM_TRUNCATE:
3483 3484 3485 3486 3487
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3488 3489
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
3490
      goto error;
3491 3492 3493 3494
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
3495
    if (thd->locked_tables || thd->active_transaction())
3496
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3497 3498
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3499 3500
      goto error;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3501

monty@mysql.com's avatar
monty@mysql.com committed
3502
    res= mysql_truncate(thd, first_table, 0);
3503
    break;
3504
  case SQLCOM_DELETE:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3505
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3506 3507
    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
3508
      break;
3509 3510
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
3511 3512 3513 3514 3515 3516 3517 3518

    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
3519
    res = mysql_delete(thd, all_tables, select_lex->where,
3520
                       &select_lex->order_list,
osku@127.(none)'s avatar
osku@127.(none) committed
3521 3522
                       unit->select_limit_cnt, select_lex->options,
                       FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3523 3524
    break;
  }
3525
  case SQLCOM_DELETE_MULTI:
3526
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3527
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3528
    TABLE_LIST *aux_tables=
3529
      (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
3530
    multi_delete *result;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3531

3532 3533 3534 3535 3536 3537 3538
    if (!thd->locked_tables &&
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
    {
      res= 1;
      break;
    }

3539
    if ((res= multi_delete_precheck(thd, all_tables)))
3540
      break;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3541

3542
    /* condition will be TRUE on SP re-excuting */
3543 3544
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3545
    if (add_item_to_list(thd, new Item_null()))
3546
      goto error;
3547

3548
    thd->proc_info="init";
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3549 3550 3551 3552
    if ((res= open_and_lock_tables(thd, all_tables)))
      break;

    if ((res= mysql_multi_delete_prepare(thd)))
3553
      goto error;
3554

3555
    if (!thd->is_fatal_error && (result= new multi_delete(aux_tables,
3556
							  lex->table_count)))
3557
    {
3558 3559 3560
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3561
			select_lex->item_list,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3562
			select_lex->where,
3563
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3564 3565
			(ORDER *)NULL,
			select_lex->options | thd->options |
3566 3567
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                        OPTION_SETUP_TABLES_DONE,
3568
			result, unit, select_lex);
3569
      delete result;
3570 3571
    }
    else
3572
      res= TRUE;                                // Error
3573 3574
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3575
  case SQLCOM_DROP_TABLE:
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
3576
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3577
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3578 3579
    if (!lex->drop_temporary)
    {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3580
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
3581 3582
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
3583
        goto error;
3584
    }
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
3585
    else
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3586 3587 3588 3589 3590 3591
    {
      /*
	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
3592 3593
	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
3594 3595 3596
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
3597

3598 3599
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3600
    }
3601
    /* DDL and binlog write order protected by LOCK_open */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3602 3603
    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
3604 3605
  }
  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3606
  case SQLCOM_DROP_INDEX:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3607 3608
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3609
      goto error;				/* purecov: inspected */
3610
    if (end_active_trans(thd))
3611
      goto error;
3612
    else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3613
      res = mysql_drop_index(thd, first_table, &lex->alter_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3614 3615
    break;
  case SQLCOM_SHOW_PROCESSLIST:
3616 3617
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd,PROCESS_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3618
      break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
3619
    mysqld_list_processes(thd,
3620 3621 3622 3623
			  (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
3624
    break;
3625 3626
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
3627 3628 3629 3630 3631 3632 3633
    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
3634 3635
  case SQLCOM_SHOW_LOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3636 3637
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
3638
    goto error;
tim@cane.mysql.fi's avatar
tim@cane.mysql.fi committed
3639 3640
#else
    {
3641
      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
3642 3643 3644 3645
	goto error;
      res= mysqld_show_logs(thd);
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3646 3647
#endif
  case SQLCOM_CHANGE_DB:
3648 3649
    if (!mysql_change_db(thd,select_lex->db,FALSE))
      send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3650
    break;
3651

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3652 3653
  case SQLCOM_LOAD:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3654
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3655
    uint privilege= (lex->duplicates == DUP_REPLACE ?
3656 3657
		     INSERT_ACL | DELETE_ACL : INSERT_ACL) |
                    (lex->local_file ? 0 : FILE_ACL);
3658

3659
    if (lex->local_file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3660
    {
3661
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
3662
          !opt_local_infile)
3663
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3664
	my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
3665 3666
	goto error;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3667
    }
3668 3669 3670 3671

    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
3672
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
3673
                    lex->update_list, lex->value_list, lex->duplicates,
3674
                    lex->ignore, (bool) lex->local_file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3675 3676
    break;
  }
3677

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3678
  case SQLCOM_SET_OPTION:
3679 3680
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
3681
    if ((check_table_access(thd, SELECT_ACL, all_tables, 0) ||
3682 3683
	 open_and_lock_tables(thd, all_tables)))
      goto error;
3684 3685
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
3686 3687
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
      goto error;
3688 3689 3690 3691 3692 3693 3694 3695
    }
    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;
3696
      send_ok(thd);
3697
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3698
    break;
3699
  }
3700

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3701
  case SQLCOM_UNLOCK_TABLES:
3702 3703 3704 3705 3706 3707
    /*
      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.
    */
3708
    unlock_locked_tables(thd);
3709 3710
    if (thd->options & OPTION_TABLE_LOCK)
    {
3711
      end_active_trans(thd);
3712
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3713 3714
    }
    if (thd->global_read_lock)
3715
      unlock_global_read_lock(thd);
3716
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3717 3718
    break;
  case SQLCOM_LOCK_TABLES:
3719
    unlock_locked_tables(thd);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3720
    if (check_db_used(thd, all_tables) || end_active_trans(thd))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3721
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3722
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3723
      goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3724
    thd->in_lock_tables=1;
3725
    thd->options|= OPTION_TABLE_LOCK;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3726

3727
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3728
    {
3729 3730
#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
3731
	query_cache.invalidate_locked_for_write(first_table);
3732
#endif /*HAVE_QUERY_CACHE*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3733 3734
      thd->locked_tables=thd->lock;
      thd->lock=0;
3735
      send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3736
    }
3737 3738
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3739 3740 3741
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3742
  {
3743 3744 3745 3746 3747
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3748
    char *alias;
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
3749
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3750
    {
3751
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3752 3753
      break;
    }
3754 3755 3756
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
3757
      For that reason, db_ok() in sql/slave.cc did not check the
3758 3759 3760
      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.
    */
3761
#ifdef HAVE_REPLICATION
3762
    if (thd->slave_thread &&
3763 3764
	(!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
3765
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3766
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3767
      break;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3768
    }
3769
#endif
3770
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3771
      break;
monty@mysql.com's avatar
monty@mysql.com committed
3772
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
monty@mysql.com's avatar
monty@mysql.com committed
3773
			 &lex->create_info, 0);
3774 3775
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3776
  case SQLCOM_DROP_DB:
3777
  {
3778 3779 3780 3781 3782
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3783
    if (check_db_name(lex->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3784
    {
3785
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3786 3787
      break;
    }
3788 3789 3790 3791 3792 3793 3794
    /*
      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.
    */
3795
#ifdef HAVE_REPLICATION
3796 3797 3798
    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
3799
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3800
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3801
      break;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3802
    }
3803
#endif
3804
    if (check_access(thd,DROP_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3805
      break;
3806 3807
    if (thd->locked_tables || thd->active_transaction())
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3808 3809
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3810 3811
      goto error;
    }
3812
    res= mysql_rm_db(thd, lex->name, lex->drop_if_exists, 0);
3813 3814
    break;
  }
3815 3816
  case SQLCOM_ALTER_DB:
  {
3817 3818
    char *db= lex->name;
    DBUG_ASSERT(db); /* Must be set in the parser */
3819
    if (!strip_sp(db) || check_db_name(db))
3820
    {
3821
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
3822 3823
      break;
    }
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3824 3825 3826
    /*
      If in a slave thread :
      ALTER DATABASE DB may not be preceded by USE DB.
3827
      For that reason, maybe db_ok() in sql/slave.cc did not check the
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3828 3829 3830 3831
      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
3832
    if (thd->slave_thread &&
3833 3834
	(!db_ok(db, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(db)))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3835
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3836
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3837 3838 3839
      break;
    }
#endif
3840
    if (check_access(thd, ALTER_ACL, db, 0, 1, 0, is_schema_db(db)))
3841 3842 3843
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3844 3845
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3846 3847
      goto error;
    }
3848
    res= mysql_alter_db(thd, db, &lex->create_info);
3849 3850
    break;
  }
3851 3852 3853 3854
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3855
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
3856 3857
      break;
    }
3858
    if (check_access(thd,SELECT_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3859
      break;
3860
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
3861 3862
    break;
  }
monty@mysql.com's avatar
monty@mysql.com committed
3863
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
monty@mysql.com's avatar
monty@mysql.com committed
3864
  {
3865
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0))
monty@mysql.com's avatar
monty@mysql.com committed
3866
      break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3867
#ifdef HAVE_DLOPEN
3868 3869
    if (sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                        &thd->sp_func_cache, FALSE))
monty@mysql.com's avatar
monty@mysql.com committed
3870
    {
3871
      my_error(ER_UDF_EXISTS, MYF(0), lex->spname->m_name.str);
monty@mysql.com's avatar
monty@mysql.com committed
3872 3873
      goto error;
    }
3874
    if (!(res = mysql_create_function(thd, &lex->udf)))
monty@mysql.com's avatar
monty@mysql.com committed
3875
      send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3876
#else
hf@deer.(none)'s avatar
hf@deer.(none) committed
3877
    my_error(ER_CANT_OPEN_LIBRARY, MYF(0), lex->udf.dl, 0, "feature disabled");
3878
    res= TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3879 3880
#endif
    break;
monty@mysql.com's avatar
monty@mysql.com committed
3881
  }
hf@deer.(none)'s avatar
hf@deer.(none) committed
3882
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3883 3884
  case SQLCOM_CREATE_USER:
  {
3885
    if (check_access(thd, INSERT_ACL, "mysql", 0, 1, 1, 0) &&
3886
        check_global_access(thd,CREATE_USER_ACL))
3887
      break;
3888 3889
    if (end_active_trans(thd))
      goto error;
3890
    /* Conditionally writes to binlog */
3891 3892 3893 3894
    if (!(res= mysql_create_user(thd, lex->users_list)))
      send_ok(thd);
    break;
  }
3895 3896
  case SQLCOM_DROP_USER:
  {
3897
    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 1, 0) &&
3898
        check_global_access(thd,CREATE_USER_ACL))
3899
      break;
3900 3901
    if (end_active_trans(thd))
      goto error;
3902
    /* Conditionally writes to binlog */
3903
    if (!(res= mysql_drop_user(thd, lex->users_list)))
3904 3905 3906 3907 3908
      send_ok(thd);
    break;
  }
  case SQLCOM_RENAME_USER:
  {
3909
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
3910
        check_global_access(thd,CREATE_USER_ACL))
3911
      break;
3912 3913
    if (end_active_trans(thd))
      goto error;
3914
    /* Conditionally writes to binlog */
3915
    if (!(res= mysql_rename_user(thd, lex->users_list)))
3916 3917 3918 3919 3920
      send_ok(thd);
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
3921
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
3922
        check_global_access(thd,CREATE_USER_ACL))
3923
      break;
3924
    /* Conditionally writes to binlog */
3925 3926 3927 3928
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
      send_ok(thd);
    break;
  }
3929 3930 3931 3932
  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
3933
		     first_table ?  first_table->db : select_lex->db,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3934
		     first_table ? &first_table->grant.privilege : 0,
3935 3936 3937
		     first_table ? 0 : 1, 0,
                     first_table ? (bool) first_table->schema_table :
                     select_lex->db ? is_schema_db(select_lex->db) : 0))
3938 3939
      goto error;

3940
    if (thd->security_ctx->user)              // If not replication
3941
    {
3942
      LEX_USER *user, *tmp_user;
3943

3944
      List_iterator <LEX_USER> user_list(lex->users_list);
3945
      while ((tmp_user= user_list++))
3946
      {
3947 3948
        if (!(user= get_current_user(thd, tmp_user)))
          goto error;
3949 3950 3951 3952 3953 3954 3955 3956
        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);
3957
        if (strcmp(thd->security_ctx->user, user->user.str) ||
3958
            my_strcasecmp(system_charset_info,
3959
                          user->host.str, thd->security_ctx->host_or_ip))
3960 3961
        {
          // TODO: use check_change_password()
3962 3963
          if (is_acl_user(user->host.str, user->user.str) &&
              user->password.str &&
3964
              check_access(thd, UPDATE_ACL,"mysql",0,1,1,0))
3965 3966 3967 3968 3969 3970
          {
            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
3971 3972
      }
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3973
    if (first_table)
3974
    {
3975 3976
      if (lex->type == TYPE_ENUM_PROCEDURE ||
          lex->type == TYPE_ENUM_FUNCTION)
3977 3978 3979 3980 3981
      {
        uint grants= lex->all_privileges 
		   ? (PROC_ACLS & ~GRANT_ACL) | (lex->grant & GRANT_ACL)
		   : lex->grant;
        if (grant_option && 
3982 3983
	    check_grant_routine(thd, grants | GRANT_ACL, all_tables,
                                lex->type == TYPE_ENUM_PROCEDURE, 0))
3984
	  goto error;
3985
        /* Conditionally writes to binlog */
3986 3987 3988 3989
        res= mysql_routine_grant(thd, all_tables,
                                 lex->type == TYPE_ENUM_PROCEDURE, 
                                 lex->users_list, grants,
                                 lex->sql_command == SQLCOM_REVOKE, 0);
3990 3991 3992 3993 3994 3995 3996 3997
      }
      else
      {
	if (grant_option && check_grant(thd,
					(lex->grant | lex->grant_tot_col |
					 GRANT_ACL),
					all_tables, 0, UINT_MAX, 0))
	  goto error;
3998
        /* Conditionally writes to binlog */
3999 4000 4001 4002
        res= mysql_table_grant(thd, all_tables, lex->users_list,
			       lex->columns, lex->grant,
			       lex->sql_command == SQLCOM_REVOKE);
      }
4003 4004 4005
    }
    else
    {
4006
      if (lex->columns.elements || lex->type)
4007
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4008 4009
	my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE),
                   MYF(0));
4010
        goto error;
4011 4012
      }
      else
4013
	/* Conditionally writes to binlog */
4014 4015 4016 4017
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
4018
	if (lex->sql_command == SQLCOM_GRANT)
4019
	{
4020
	  List_iterator <LEX_USER> str_list(lex->users_list);
4021 4022 4023 4024 4025
	  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
4026
	    reset_mqh(user);
4027
          }
4028
	}
4029 4030 4031 4032
      }
    }
    break;
  }
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
4033
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4034
  case SQLCOM_RESET:
4035 4036 4037
    /*
      RESET commands are never written to the binary log, so we have to
      initialize this variable because RESET shares the same code as FLUSH
4038 4039 4040 4041
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
4042
    bool write_to_binlog;
4043
    if (check_global_access(thd,RELOAD_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4044
      goto error;
4045

4046 4047 4048 4049
    /*
      reload_acl_and_cache() will tell us if we are allowed to write to the
      binlog or not.
    */
4050
    if (!reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
4051 4052 4053 4054 4055
    {
      /*
        We WANT to write and we CAN write.
        ! we write after unlocking the table.
      */
4056
      /* Presumably, RESET and binlog writing doesn't require synchronization */
4057 4058 4059 4060
      if (!lex->no_write_to_binlog && write_to_binlog)
      {
        if (mysql_bin_log.is_open())
        {
4061
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
4062 4063 4064 4065
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
4066 4067
    } 
    
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4068
    break;
4069
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4070
  case SQLCOM_KILL:
4071 4072 4073
  {
    Item *it= (Item *)lex->value_list.head();

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

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

4251
    DBUG_ASSERT(lex->sphead != 0);
4252
    DBUG_ASSERT(lex->sphead->m_db.str); /* Must be initialized in the parser */
4253 4254 4255 4256 4257 4258 4259
    /*
      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);
4260
      goto create_sp_error;
4261 4262 4263
    }

    /*
4264 4265 4266
      Check that a database directory with this name
      exists. Design note: This won't work on virtual databases
      like information_schema.
4267 4268 4269 4270
    */
    if (check_db_dir_existence(lex->sphead->m_db.str))
    {
      my_error(ER_BAD_DB_ERROR, MYF(0), lex->sphead->m_db.str);
4271
      goto create_sp_error;
4272 4273
    }

4274 4275
    if (check_access(thd, CREATE_PROC_ACL, lex->sphead->m_db.str, 0, 0, 0,
                     is_schema_db(lex->sphead->m_db.str)))
4276
      goto create_sp_error;
4277

4278 4279
    if (end_active_trans(thd))
      goto create_sp_error;
4280 4281

    name= lex->sphead->name(&namelen);
4282
#ifdef HAVE_DLOPEN
monty@mysql.com's avatar
monty@mysql.com committed
4283 4284 4285
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
4286

monty@mysql.com's avatar
monty@mysql.com committed
4287
      if (udf)
4288
      {
4289 4290
        my_error(ER_UDF_EXISTS, MYF(0), name);
        goto create_sp_error;
4291
      }
monty@mysql.com's avatar
monty@mysql.com committed
4292 4293 4294
    }
#endif

4295 4296 4297
    /*
      If the definer is not specified, this means that CREATE-statement missed
      DEFINER-clause. DEFINER-clause can be missed in two cases:
4298

4299 4300 4301 4302 4303 4304 4305 4306
        - 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.
4307

4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331
          The problem is the slave thread is running under "special" user (@),
          that actually does not exist. In the older versions we do not fail
          execution of a stored routine if its definer does not exist and
          continue the execution under the authorization of the invoker
          (BUG#13198). And now if we try to switch to slave-current-user (@),
          we will fail.

          Actually, this leads to the inconsistent state of master and
          slave (different definers, different SUID behaviour), but it seems,
          this is the best we can do.
    */

    if (!lex->definer)
    {
      bool res= FALSE;
      Query_arena original_arena;
      Query_arena *ps_arena = thd->activate_stmt_arena_if_needed(&original_arena);

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

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

4332
      /* Error has been already reported. */
4333
      if (res)
4334
        goto create_sp_error;
4335 4336 4337 4338 4339 4340 4341 4342 4343 4344

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

4346 4347 4348 4349 4350 4351 4352 4353
    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");
4354
        goto create_sp_error;
4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372
      }
    }

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

4373
    res= (result= lex->sphead->create(thd));
4374 4375
    switch (result) {
    case SP_OK:
4376
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4377
      /* only add privileges if really neccessary */
4378
      if (sp_automatic_privileges && !opt_noacl &&
4379
          check_routine_access(thd, DEFAULT_CREATE_PROC_ACLS,
4380
                               lex->sphead->m_db.str, name,
4381
                               lex->sql_command == SQLCOM_CREATE_PROCEDURE, 1))
4382
      {
4383
        if (sp_grant_privileges(thd, lex->sphead->m_db.str, name,
4384
                                lex->sql_command == SQLCOM_CREATE_PROCEDURE))
4385 4386 4387 4388
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                       ER_PROC_AUTO_GRANT_FAIL,
                       ER(ER_PROC_AUTO_GRANT_FAIL));
        close_thread_tables(thd);
4389
      }
4390
#endif
monty@mysql.com's avatar
monty@mysql.com committed
4391
    break;
4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418
    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:
    lex->unit.cleanup();
    delete lex->sphead;
    lex->sphead= 0;
    if (result != SP_OK )
      goto error;
    send_ok(thd);
    break; /* break super switch */
  } /* end case group bracket */
4419 4420 4421 4422
  case SQLCOM_CALL:
    {
      sp_head *sp;

4423 4424 4425 4426 4427 4428 4429 4430 4431
      /*
        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;

      /*
4432 4433
        By this moment all needed SPs should be in cache so no need to look 
        into DB. 
4434
      */
4435 4436
      if (!(sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                                &thd->sp_proc_cache, TRUE)))
4437
      {
4438
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PROCEDURE",
4439
                 lex->spname->m_qname.str);
4440
	goto error;
4441 4442 4443
      }
      else
      {
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4444
	ha_rows select_limit;
monty@mysql.com's avatar
monty@mysql.com committed
4445 4446
        /* bits that should be cleared in thd->server_status */
	uint bits_to_be_cleared= 0;
4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458
        /*
          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;
        }
4459

4460 4461
	my_bool nsok= thd->net.no_send_ok;
	thd->net.no_send_ok= TRUE;
4462
	if (sp->m_flags & sp_head::MULTI_RESULTS)
4463
	{
4464
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
4465
	  {
4466 4467 4468 4469
            /*
              The client does not support multiple result sets being sent
              back
            */
4470
	    my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str);
4471 4472 4473
	    thd->net.no_send_ok= nsok;
	    goto error;
	  }
monty@mysql.com's avatar
monty@mysql.com committed
4474 4475 4476 4477 4478 4479 4480
          /*
            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;
4481 4482
	}

4483
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4484
	if (check_routine_access(thd, EXECUTE_ACL,
4485
				 sp->m_db.str, sp->m_name.str, TRUE, FALSE))
4486 4487 4488 4489
	{
	  thd->net.no_send_ok= nsok;
	  goto error;
	}
4490
#endif
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4491 4492
	select_limit= thd->variables.select_limit;
	thd->variables.select_limit= HA_POS_ERROR;
4493

4494
        /* 
4495
          We never write CALL statements into binlog:
4496 4497 4498 4499 4500
           - 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.
4501
        */
4502
	res= sp->execute_procedure(thd, &lex->value_list);
4503 4504 4505
	/*
          If warnings have been cleared, we have to clear total_warn_count
          too, otherwise the clients get confused.
4506 4507 4508 4509
	 */
	if (thd->warn_list.is_empty())
	  thd->total_warn_count= 0;

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

4512
	thd->net.no_send_ok= nsok;
monty@mysql.com's avatar
monty@mysql.com committed
4513
        thd->server_status&= ~bits_to_be_cleared;
4514

4515
	if (!res)
monty@mysql.com's avatar
monty@mysql.com committed
4516 4517
	  send_ok(thd, (ulong) (thd->row_count_func < 0 ? 0 :
                                thd->row_count_func));
4518 4519
	else
	  goto error;		// Substatement should already have sent error
4520
      }
4521
      break;
4522 4523
    }
  case SQLCOM_ALTER_PROCEDURE:
4524
  case SQLCOM_ALTER_FUNCTION:
4525
    {
4526
      int result;
4527 4528 4529 4530
      sp_head *sp;
      st_sp_chistics chistics;

      memcpy(&chistics, &lex->sp_chistics, sizeof(chistics));
4531
      if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4532 4533
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
4534
      else
4535 4536
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
monty@mysql.com's avatar
monty@mysql.com committed
4537
      mysql_reset_errors(thd, 0);
4538
      if (! sp)
4539 4540 4541 4542 4543 4544 4545 4546 4547
      {
	if (lex->spname->m_db.str)
	  result= SP_KEY_NOT_FOUND;
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
      }
4548 4549
      else
      {
4550 4551 4552
        if (check_routine_access(thd, ALTER_PROC_ACL, sp->m_db.str, 
				 sp->m_name.str,
                                 lex->sql_command == SQLCOM_ALTER_PROCEDURE, 0))
4553
	  goto error;
4554 4555 4556

        if (end_active_trans(thd)) 
          goto error;
4557
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
4558 4559
        if ((sp->m_type == TYPE_ENUM_FUNCTION) &&
            !trust_function_creators &&  mysql_bin_log.is_open() &&
4560 4561 4562 4563 4564 4565 4566 4567 4568 4569
            !sp->m_chistics->detistic &&
            (chistics.daccess == SP_CONTAINS_SQL ||
             chistics.daccess == SP_MODIFIES_SQL_DATA))
        {
          my_message(ER_BINLOG_UNSAFE_ROUTINE,
		     ER(ER_BINLOG_UNSAFE_ROUTINE), MYF(0));
          result= SP_INTERNAL_ERROR;
        }
        else
        {
4570 4571 4572 4573 4574 4575
          /*
            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.
          */
4576
          if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4577
            /* Conditionally writes to binlog */
4578 4579
            result= sp_update_procedure(thd, lex->spname, &lex->sp_chistics);
          else
4580
            /* Conditionally writes to binlog */
4581 4582
            result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
        }
4583
      }
4584
      switch (result)
4585
      {
4586
      case SP_OK:
4587
	send_ok(thd);
4588 4589
	break;
      case SP_KEY_NOT_FOUND:
4590 4591
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4592 4593
	goto error;
      default:
4594 4595
	my_error(ER_SP_CANT_ALTER, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4596
	goto error;
4597
      }
4598
      break;
4599 4600
    }
  case SQLCOM_DROP_PROCEDURE:
4601
  case SQLCOM_DROP_FUNCTION:
4602
    {
4603
      int result;
4604 4605
      int type= (lex->sql_command == SQLCOM_DROP_PROCEDURE ?
                 TYPE_ENUM_PROCEDURE : TYPE_ENUM_FUNCTION);
4606

4607
      result= sp_routine_exists_in_table(thd, type, lex->spname);
monty@mysql.com's avatar
monty@mysql.com committed
4608
      mysql_reset_errors(thd, 0);
4609
      if (result == SP_OK)
4610
      {
4611 4612 4613
        char *db= lex->spname->m_db.str;
	char *name= lex->spname->m_name.str;

4614 4615
	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
4616
          goto error;
4617 4618 4619

        if (end_active_trans(thd)) 
          goto error;
4620
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4621
	if (sp_automatic_privileges && !opt_noacl &&
4622 4623
	    sp_revoke_privileges(thd, db, name, 
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE))
4624 4625 4626 4627 4628
	{
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
		       ER_PROC_AUTO_REVOKE_FAIL,
		       ER(ER_PROC_AUTO_REVOKE_FAIL));
	}
4629
#endif
4630
	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
4631 4632
          /* Conditionally writes to binlog */
	  result= sp_drop_procedure(thd, lex->spname); /* Conditionally writes to binlog */
4633
	else
4634 4635
          /* Conditionally writes to binlog */
	  result= sp_drop_function(thd, lex->spname); /* Conditionally writes to binlog */
4636 4637 4638
      }
      else
      {
4639
#ifdef HAVE_DLOPEN
4640 4641 4642 4643 4644 4645
	if (lex->sql_command == SQLCOM_DROP_FUNCTION)
	{
          udf_func *udf = find_udf(lex->spname->m_name.str,
                                   lex->spname->m_name.length);
          if (udf)
          {
4646
	    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 0, 0))
4647
	      goto error;
4648 4649

	    /* Does NOT write to binlog */
4650
	    if (!(res = mysql_drop_function(thd, &lex->spname->m_name)))
4651
	    {
4652 4653
	      send_ok(thd);
	      break;
4654 4655
	    }
	  }
4656
	}
4657
#endif
4658 4659 4660 4661 4662 4663 4664
	if (lex->spname->m_db.str)
	  result= SP_KEY_NOT_FOUND;
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
4665
      }
4666 4667
      res= result;
      switch (result)
4668 4669
      {
      case SP_OK:
4670
	send_ok(thd);
4671 4672
	break;
      case SP_KEY_NOT_FOUND:
4673 4674
	if (lex->drop_if_exists)
	{
4675
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
4676
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
4677
			      SP_COM_STRING(lex), lex->spname->m_name.str);
4678
	  res= FALSE;
4679 4680 4681
	  send_ok(thd);
	  break;
	}
4682 4683
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4684 4685
	goto error;
      default:
4686 4687
	my_error(ER_SP_DROP_FAILED, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4688
	goto error;
4689
      }
4690
      break;
4691
    }
4692 4693
  case SQLCOM_SHOW_CREATE_PROC:
    {
4694
      if (lex->spname->m_name.length > NAME_LEN)
4695
      {
4696
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
4697 4698
	goto error;
      }
4699
      if (sp_show_create_procedure(thd, lex->spname) != SP_OK)
4700
      {			/* We don't distinguish between errors for now */
4701 4702
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
4703 4704 4705 4706 4707 4708
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
4709
      if (lex->spname->m_name.length > NAME_LEN)
4710
      {
4711
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
4712 4713
	goto error;
      }
4714
      if (sp_show_create_function(thd, lex->spname) != SP_OK)
4715
      {			/* We don't distinguish between errors for now */
4716 4717
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
4718 4719 4720 4721 4722 4723
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
4724
      res= sp_show_status_procedure(thd, (lex->wild ?
4725 4726 4727 4728 4729
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
4730
      res= sp_show_status_function(thd, (lex->wild ? 
4731 4732 4733
					 lex->wild->ptr() : NullS));
      break;
    }
pem@mysql.com's avatar
pem@mysql.com committed
4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745
#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
4746 4747
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
pem@mysql.com's avatar
pem@mysql.com committed
4748
      else
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4749 4750
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
4751
      if (!sp || sp->show_routine_code(thd))
4752 4753
      {
        /* We don't distinguish between errors for now */
pem@mysql.com's avatar
pem@mysql.com committed
4754 4755 4756 4757 4758 4759 4760
        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
4761 4762
  case SQLCOM_CREATE_VIEW:
    {
4763 4764 4765
      if (end_active_trans(thd))
        goto error;

4766
      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
4767 4768 4769 4770
      break;
    }
  case SQLCOM_DROP_VIEW:
    {
4771 4772 4773
      if (check_table_access(thd, DROP_ACL, all_tables, 0) ||
          end_active_trans(thd))
        goto error;
4774 4775
      /* 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
4776 4777
      break;
    }
4778 4779
  case SQLCOM_CREATE_TRIGGER:
  {
4780 4781 4782
    if (end_active_trans(thd))
      goto error;

4783
    /* Conditionally writes to binlog. */
4784 4785 4786
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

    /* We don't care about trigger body after this point */
4787 4788 4789 4790 4791 4792
    delete lex->sphead;
    lex->sphead= 0;
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
4793 4794 4795
    if (end_active_trans(thd))
      goto error;

4796
    /* Conditionally writes to binlog. */
4797 4798 4799
    res= mysql_create_or_drop_trigger(thd, all_tables, 0);
    break;
  }
4800
  case SQLCOM_XA_START:
4801 4802
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
        thd->lex->xa_opt == XA_RESUME)
4803
    {
4804
      if (! thd->transaction.xid_state.xid.eq(thd->lex->xid))
4805 4806 4807 4808
      {
        my_error(ER_XAER_NOTA, MYF(0));
        break;
      }
4809
      thd->transaction.xid_state.xa_state=XA_ACTIVE;
4810 4811 4812
      send_ok(thd);
      break;
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
4813
    if (thd->lex->xa_opt != XA_NONE)
4814 4815 4816 4817
    { // JOIN is not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
4818
    if (thd->transaction.xid_state.xa_state != XA_NOTR)
4819
    {
4820
      my_error(ER_XAER_RMFAIL, MYF(0),
4821
               xa_state_names[thd->transaction.xid_state.xa_state]);
4822 4823 4824 4825 4826 4827 4828
      break;
    }
    if (thd->active_transaction() || thd->locked_tables)
    {
      my_error(ER_XAER_OUTSIDE, MYF(0));
      break;
    }
4829 4830 4831 4832 4833 4834 4835 4836 4837
    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);
4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849
    thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
                   OPTION_BEGIN);
    thd->server_status|= SERVER_STATUS_IN_TRANS;
    send_ok(thd);
    break;
  case SQLCOM_XA_END:
    /* fake it */
    if (thd->lex->xa_opt != XA_NONE)
    { // SUSPEND and FOR MIGRATE are not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
4850
    if (thd->transaction.xid_state.xa_state != XA_ACTIVE)
4851
    {
4852
      my_error(ER_XAER_RMFAIL, MYF(0),
4853
               xa_state_names[thd->transaction.xid_state.xa_state]);
4854 4855
      break;
    }
4856
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4857 4858 4859 4860
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
4861
    thd->transaction.xid_state.xa_state=XA_IDLE;
4862 4863 4864
    send_ok(thd);
    break;
  case SQLCOM_XA_PREPARE:
4865
    if (thd->transaction.xid_state.xa_state != XA_IDLE)
4866
    {
4867
      my_error(ER_XAER_RMFAIL, MYF(0),
4868
               xa_state_names[thd->transaction.xid_state.xa_state]);
4869 4870
      break;
    }
4871
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4872 4873 4874 4875 4876 4877 4878
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
    if (ha_prepare(thd))
    {
      my_error(ER_XA_RBROLLBACK, MYF(0));
4879 4880
      xid_cache_delete(&thd->transaction.xid_state);
      thd->transaction.xid_state.xa_state=XA_NOTR;
4881 4882
      break;
    }
4883
    thd->transaction.xid_state.xa_state=XA_PREPARED;
4884 4885 4886
    send_ok(thd);
    break;
  case SQLCOM_XA_COMMIT:
4887
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4888
    {
4889 4890
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
4891
        my_error(ER_XAER_NOTA, MYF(0));
serg@serg.mylan's avatar
serg@serg.mylan committed
4892
      else
4893 4894 4895
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 1);
        xid_cache_delete(xs);
serg@serg.mylan's avatar
serg@serg.mylan committed
4896
        send_ok(thd);
4897
      }
4898 4899
      break;
    }
4900
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
monty@mysql.com's avatar
monty@mysql.com committed
4901
        thd->lex->xa_opt == XA_ONE_PHASE)
4902
    {
4903 4904 4905
      int r;
      if ((r= ha_commit(thd)))
        my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0));
4906 4907 4908
      else
        send_ok(thd);
    }
4909
    else if (thd->transaction.xid_state.xa_state == XA_PREPARED &&
monty@mysql.com's avatar
monty@mysql.com committed
4910
             thd->lex->xa_opt == XA_NONE)
4911
    {
4912 4913 4914
      if (wait_if_global_read_lock(thd, 0, 0))
      {
        ha_rollback(thd);
4915
        my_error(ER_XAER_RMERR, MYF(0));
4916
      }
4917
      else
4918 4919 4920 4921 4922 4923 4924
      {
        if (ha_commit_one_phase(thd, 1))
          my_error(ER_XAER_RMERR, MYF(0));
        else
          send_ok(thd);
        start_waiting_global_read_lock(thd);
      }
4925 4926 4927
    }
    else
    {
4928
      my_error(ER_XAER_RMFAIL, MYF(0),
4929
               xa_state_names[thd->transaction.xid_state.xa_state]);
4930 4931 4932 4933
      break;
    }
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
4934 4935
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
4936 4937
    break;
  case SQLCOM_XA_ROLLBACK:
4938
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4939
    {
4940 4941
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
4942
        my_error(ER_XAER_NOTA, MYF(0));
serg@serg.mylan's avatar
serg@serg.mylan committed
4943
      else
4944 4945 4946
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 0);
        xid_cache_delete(xs);
serg@serg.mylan's avatar
serg@serg.mylan committed
4947
        send_ok(thd);
4948
      }
4949 4950
      break;
    }
4951 4952
    if (thd->transaction.xid_state.xa_state != XA_IDLE &&
        thd->transaction.xid_state.xa_state != XA_PREPARED)
4953
    {
4954
      my_error(ER_XAER_RMFAIL, MYF(0),
4955
               xa_state_names[thd->transaction.xid_state.xa_state]);
4956 4957 4958 4959 4960 4961 4962 4963
      break;
    }
    if (ha_rollback(thd))
      my_error(ER_XAER_RMERR, MYF(0));
    else
      send_ok(thd);
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
4964 4965
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
4966 4967
    break;
  case SQLCOM_XA_RECOVER:
4968
    res= mysql_xa_recover(thd);
4969 4970
    break;
  default:
4971
#ifndef EMBEDDED_LIBRARY
4972
    DBUG_ASSERT(0);                             /* Impossible */
4973
#endif
4974
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4975 4976
    break;
  }
monty@mysql.com's avatar
monty@mysql.com committed
4977
  thd->proc_info="query end";
4978
  /* Two binlog-related cleanups: */
4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991

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

4992
  /*
4993 4994 4995 4996 4997 4998
    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.
4999
   */
5000 5001
  if (lex->sql_command != SQLCOM_CALL && lex->sql_command != SQLCOM_EXECUTE &&
      uc_update_queries[lex->sql_command]<2)
5002
    thd->row_count_func= -1;
5003 5004

  goto end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5005 5006

error:
5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018
  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
5019 5020 5021
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5022
/*
5023
  Check grants for commands which work only with one table.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5024

5025
  SYNOPSIS
5026
    check_single_table_access()
monty@mysql.com's avatar
monty@mysql.com committed
5027
    thd			Thread handler
5028
    privilege		requested privilege
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5029
    all_tables		global table list of query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5030 5031 5032

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

5036 5037
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
5038
{
5039 5040 5041 5042 5043 5044
  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;

5045 5046 5047 5048 5049 5050 5051 5052
  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,
5053 5054
		   &all_tables->grant.privilege, 0, 0,
                   test(all_tables->schema_table)))
5055
    goto deny;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5056

5057
  /* Show only 1 table for check_grant */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5058
  if (grant_option && check_grant(thd, privilege, all_tables, 0, 1, 0))
5059 5060 5061
    goto deny;

  thd->security_ctx= backup_ctx;
5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087
  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
5088

5089
  /* Check rights on tables of subselects and implictly opened tables */
5090
  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
5091
  if ((subselects_tables= all_tables->next_global))
monty@mysql.com's avatar
monty@mysql.com committed
5092
  {
5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104
    /*
      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)))
5105
      return 1;
monty@mysql.com's avatar
monty@mysql.com committed
5106 5107
  }
  return 0;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5108 5109 5110
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5111
/****************************************************************************
5112
  Get the user (global) and database privileges for all used tables
5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125

  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
5126 5127
                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
5128 5129 5130
****************************************************************************/

bool
5131
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
5132
	     bool dont_check_global_grants, bool no_errors, bool schema_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5133
{
5134
  Security_context *sctx= thd->security_ctx;
5135 5136
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
5137
  bool  db_is_pattern= test(want_access & GRANT_ACL);
5138 5139
#endif
  ulong dummy;
5140 5141
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
5142
                      db ? db : "", want_access, sctx->master_access));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5143 5144 5145 5146 5147
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

5148
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5149
  {
5150
    DBUG_PRINT("error",("No database"));
5151
    if (!no_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5152 5153
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                 MYF(0));                       /* purecov: tested */
5154
    DBUG_RETURN(TRUE);				/* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5155 5156
  }

5157 5158 5159 5160 5161
  if (schema_db)
  {
    if (want_access & ~(SELECT_ACL | EXTRA_ACL))
    {
      if (!no_errors)
5162 5163
      {
        const char *db_name= db ? db : thd->db;
5164
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5165 5166
                 sctx->priv_user, sctx->priv_host, db_name);
      }
5167 5168 5169 5170 5171 5172 5173 5174 5175
      DBUG_RETURN(TRUE);
    }
    else
    {
      *save_priv= SELECT_ACL;
      DBUG_RETURN(FALSE);
    }
  }

monty@mysql.com's avatar
monty@mysql.com committed
5176 5177 5178
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
5179
  if ((sctx->master_access & want_access) == want_access)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5180
  {
5181 5182 5183 5184 5185
    /*
      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
    */
5186 5187
    db_access= sctx->db_access;
    if (!(sctx->master_access & SELECT_ACL) &&
5188
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
5189 5190 5191
      db_access=acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                        db_is_pattern);
    *save_priv=sctx->master_access | db_access;
5192
    DBUG_RETURN(FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5193
  }
5194
  if (((want_access & ~sctx->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
5195
      ! db && dont_check_global_grants)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5196
  {						// We can never grant this
5197
    DBUG_PRINT("error",("No possible access"));
5198
    if (!no_errors)
5199
      my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
5200 5201
               sctx->priv_user,
               sctx->priv_host,
5202 5203 5204
               (thd->password ?
                ER(ER_YES) :
                ER(ER_NO)));                    /* purecov: tested */
5205
    DBUG_RETURN(TRUE);				/* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5206 5207 5208
  }

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

5211
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
5212 5213
    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
5214
  else
5215
    db_access= sctx->db_access;
5216
  DBUG_PRINT("info",("db_access: %lu", db_access));
monty@mysql.com's avatar
monty@mysql.com committed
5217
  /* Remove SHOW attribute and access rights we already have */
5218
  want_access &= ~(sctx->master_access | EXTRA_ACL);
5219 5220
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
5221
  db_access= ((*save_priv=(db_access | sctx->master_access)) & want_access);
5222 5223

  /* grant_option is set if there exists a single table or column grant */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5224
  if (db_access == want_access ||
5225
      (grant_option && !dont_check_global_grants &&
5226
       !(want_access & ~(db_access | TABLE_ACLS | PROC_ACLS))))
5227
    DBUG_RETURN(FALSE);				/* Ok */
5228 5229

  DBUG_PRINT("error",("Access denied"));
5230
  if (!no_errors)
5231
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5232
             sctx->priv_user, sctx->priv_host,
5233 5234 5235
             (db ? db : (thd->db ?
                         thd->db :
                         "unknown")));          /* purecov: tested */
5236
  DBUG_RETURN(TRUE);				/* purecov: tested */
monty@mysql.com's avatar
monty@mysql.com committed
5237
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5238 5239 5240
}


5241 5242 5243 5244 5245 5246 5247 5248 5249
/*
  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
5250
    One gets access right if one has ANY of the rights in want_access
5251 5252 5253 5254 5255 5256 5257 5258
    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
*/
5259 5260

bool check_global_access(THD *thd, ulong want_access)
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5261
{
monty@mysql.com's avatar
monty@mysql.com committed
5262 5263 5264
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
5265
  char command[128];
5266
  if ((thd->security_ctx->master_access & want_access))
5267 5268
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
5269
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
5270
  return 1;
monty@mysql.com's avatar
monty@mysql.com committed
5271
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5272 5273 5274
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5275
/*
5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295
  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
5296 5297
*/

5298
bool
5299
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
5300
		   bool no_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5301
{
5302 5303
  uint found=0;
  ulong found_access=0;
5304 5305
  TABLE_LIST *org_tables= tables;
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
5306
  Security_context *sctx= thd->security_ctx, *backup_ctx= thd->security_ctx;
5307
  /*
5308 5309 5310
    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.
5311
  */
5312
  for (; tables != first_not_own_table; tables= tables->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5313
  {
5314 5315 5316 5317 5318
    if (tables->security_ctx)
      sctx= tables->security_ctx;
    else
      sctx= backup_ctx;

5319
    if (tables->schema_table && 
5320
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5321 5322 5323
    {
      if (!no_errors)
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5324
                 sctx->priv_user, sctx->priv_host,
5325 5326 5327
                 information_schema_name.str);
      return TRUE;
    }
5328 5329 5330 5331 5332
    /*
       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);
5333
    if (tables->derived || tables->schema_table ||
5334
        (tables->table && (int)tables->table->s->tmp_table) ||
5335 5336
        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
5337
      continue;
5338 5339
    thd->security_ctx= sctx;
    if ((sctx->master_access & want_access) ==
5340
        (want_access & ~EXTRA_ACL) &&
5341
	thd->db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5342
      tables->grant.privilege= want_access;
5343
    else if (tables->db && thd->db && strcmp(tables->db, thd->db) == 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5344 5345 5346 5347 5348
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
5349
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5350
			 0, no_errors, test(tables->schema_table)))
5351
	  goto deny;                            // Access denied
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5352
	found_access=tables->grant.privilege;
5353
	found=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5354 5355
      }
    }
5356
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5357
			  0, no_errors, test(tables->schema_table)))
5358
      goto deny;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5359
  }
5360
  thd->security_ctx= backup_ctx;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5361
  if (grant_option)
5362
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5363
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5364
  return FALSE;
5365 5366 5367
deny:
  thd->security_ctx= backup_ctx;
  return TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5368 5369
}

5370

5371
bool
5372 5373
check_routine_access(THD *thd, ulong want_access,char *db, char *name,
		     bool is_proc, bool no_errors)
5374 5375 5376 5377 5378
{
  TABLE_LIST tables[1];
  
  bzero((char *)tables, sizeof(TABLE_LIST));
  tables->db= db;
5379
  tables->table_name= tables->alias= name;
5380
  
monty@mysql.com's avatar
monty@mysql.com committed
5381 5382 5383 5384 5385 5386 5387
  /*
    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)
5388 5389
    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
5390
			0, no_errors, 0))
5391 5392
    return TRUE;
  
5393
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5394
  if (grant_option)
5395
    return check_grant_routine(thd, want_access, tables, is_proc, no_errors);
5396
#endif
5397 5398 5399 5400

  return FALSE;
}

5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415

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

5416 5417
bool check_some_routine_access(THD *thd, const char *db, const char *name,
                               bool is_proc)
5418 5419
{
  ulong save_priv;
5420
  if (thd->security_ctx->master_access & SHOW_PROC_ACLS)
5421
    return FALSE;
5422 5423 5424 5425 5426
  /*
    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) ||
5427 5428
      (save_priv & SHOW_PROC_ACLS))
    return FALSE;
5429
  return check_routine_level_acl(thd, db, name, is_proc);
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
/*
  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,
5458 5459
                        &table->grant.privilege, 0, 1,
                        test(table->schema_table)) &&
5460 5461 5462 5463 5464 5465 5466 5467 5468
          !grant_option || !check_grant(thd, access, table, 0, 1, 1))
        DBUG_RETURN(0);
    }
  }
  DBUG_PRINT("exit",("no matching access rights"));
  DBUG_RETURN(1);
}


5469 5470
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
5471 5472 5473 5474
{
  int error=0;
  if (table_list)
  {
5475
    /* Check that all tables use the current database */
5476
    TABLE_LIST *tmp;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5477
    for (tmp= table_list; tmp; tmp= tmp->next_local)
5478 5479 5480 5481
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
5482
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
hf@deer.(none)'s avatar
hf@deer.(none) committed
5483
			     table_list,0);
5484 5485 5486 5487
  }
  return error;
}

hf@deer.(none)'s avatar
hf@deer.(none) committed
5488 5489 5490

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
5491
  char *current_db= NULL;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5492
  for (; tables; tables= tables->next_global)
hf@deer.(none)'s avatar
hf@deer.(none) committed
5493
  {
5494
    if (tables->db == NULL)
hf@deer.(none)'s avatar
hf@deer.(none) committed
5495
    {
5496 5497 5498 5499 5500 5501 5502 5503 5504
      /*
        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
5505 5506 5507 5508
    }
  }
  return FALSE;
}
5509

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5510 5511 5512 5513 5514 5515 5516 5517 5518 5519
/****************************************************************************
	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
5520 5521 5522 5523
#ifndef DBUG_OFF
long max_stack_used;
#endif

5524
#ifndef EMBEDDED_LIBRARY
5525 5526 5527 5528 5529 5530 5531 5532
/*
  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
5533 5534
{
  long stack_used;
5535
  DBUG_ASSERT(thd == current_thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5536
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
monty@mysql.com's avatar
monty@mysql.com committed
5537
      (long) (thread_stack - margin))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5538
  {
5539 5540 5541
    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));
5542
    thd->fatal_error();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5543 5544
    return 1;
  }
monty@mysql.com's avatar
monty@mysql.com committed
5545 5546 5547
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5548 5549
  return 0;
}
5550
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5551 5552 5553 5554

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

5555
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5556
{
5557
  LEX	*lex= current_thd->lex;
5558
  ulong old_info=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584
  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;
}


/****************************************************************************
5585
  Initialize global thd variables needed for query
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5586 5587
****************************************************************************/

5588
void
5589
mysql_init_query(THD *thd, uchar *buf, uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5590 5591
{
  DBUG_ENTER("mysql_init_query");
5592
  lex_start(thd, buf, length);
5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613
  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");
5614
  thd->free_list= 0;
5615
  thd->select_number= 1;
5616
  thd->query_start_used= thd->insert_id_used=0;
5617
  thd->last_insert_id_used_bin_log= FALSE;
5618
  thd->is_fatal_error= thd->time_zone_used= 0;
monty@mysql.com's avatar
monty@mysql.com committed
5619
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
monty@mysql.com's avatar
monty@mysql.com committed
5620 5621
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
5622
  DBUG_ASSERT(thd->security_ctx== &thd->main_security_ctx);
5623
  thd->tmp_table_used= 0;
5624 5625
  if (!thd->in_sub_stmt)
  {
5626
    if (opt_bin_log)
5627
    {
5628
      reset_dynamic(&thd->user_var_events);
5629 5630
      thd->user_var_events_alloc= thd->mem_root;
    }
5631
    thd->clear_error();
5632 5633 5634 5635
    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
5636 5637 5638
  DBUG_VOID_RETURN;
}

5639

5640 5641 5642
void
mysql_init_select(LEX *lex)
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5643
  SELECT_LEX *select_lex= lex->current_select;
5644
  select_lex->init_select();
5645
  lex->wild= 0;
5646 5647
  if (select_lex == &lex->select_lex)
  {
5648
    DBUG_ASSERT(lex->result == 0);
5649 5650
    lex->exchange= 0;
  }
5651 5652
}

5653

5654
bool
5655
mysql_new_select(LEX *lex, bool move_down)
5656
{
5657
  SELECT_LEX *select_lex;
5658
  THD *thd= lex->thd;
5659 5660
  DBUG_ENTER("mysql_new_select");

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

5684 5685
    unit->init_query();
    unit->init_select();
5686
    unit->thd= thd;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5687
    unit->include_down(lex->current_select);
5688 5689
    unit->link_next= 0;
    unit->link_prev= 0;
5690
    unit->return_to= lex->current_select;
5691
    select_lex->include_down(unit);
5692 5693 5694 5695 5696
    /*
      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;
5697 5698
  }
  else
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5699
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5700 5701
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
5702
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
5703
      DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5704
    }
5705
    select_lex->include_neighbour(lex->current_select);
5706 5707 5708 5709 5710
    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
5711
  }
peter@mysql.com's avatar
peter@mysql.com committed
5712

5713
  select_lex->master_unit()->global_parameters= select_lex;
5714
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
5715
  lex->current_select= select_lex;
5716 5717 5718 5719 5720
  /*
    in subquery is SELECT query and we allow resolution of names in SELECT
    list
  */
  select_lex->context.resolve_in_select_list= TRUE;
5721
  DBUG_RETURN(0);
5722
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5723

5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738
/*
  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)
{
5739
  THD *thd;
5740
  LEX *lex;
5741
  LEX_STRING tmp, null_lex_string;
5742 5743
  Item *var;
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
5744
  DBUG_ENTER("create_select_for_variable");
5745 5746

  thd= current_thd;
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
5747
  lex= thd->lex;
5748 5749 5750 5751
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
5752
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
5753 5754 5755 5756
  /*
    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
5757 5758 5759 5760 5761 5762
  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);
  }
5763 5764 5765
  DBUG_VOID_RETURN;
}

5766

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5767 5768
void mysql_init_multi_delete(LEX *lex)
{
5769
  lex->sql_command=  SQLCOM_DELETE_MULTI;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5770
  mysql_init_select(lex);
5771 5772
  lex->select_lex.select_limit= 0;
  lex->unit.select_limit_cnt= HA_POS_ERROR;
5773
  lex->select_lex.table_list.save_and_clear(&lex->auxiliary_table_list);
5774
  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
5775 5776
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5777
}
5778

5779 5780 5781 5782
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
5783

5784
void mysql_parse(THD *thd, char *inBuf, uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5785 5786
{
  DBUG_ENTER("mysql_parse");
5787 5788 5789

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

5790
  mysql_init_query(thd, (uchar*) inBuf, length);
5791
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5792
  {
5793
    LEX *lex= thd->lex;
5794
    
5795 5796
    sp_cache_flush_obsolete(&thd->sp_proc_cache);
    sp_cache_flush_obsolete(&thd->sp_func_cache);
5797
    
5798
    if (!MYSQLparse((void *)thd) && ! thd->is_fatal_error)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5799
    {
hf@deer.(none)'s avatar
hf@deer.(none) committed
5800
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5801
      if (mqh_used && thd->user_connect &&
5802
	  check_mqh(thd, lex->sql_command))
5803 5804 5805 5806
      {
	thd->net.error = 0;
      }
      else
hf@deer.(none)'s avatar
hf@deer.(none) committed
5807
#endif
5808
      {
5809
	if (thd->net.report_error)
5810 5811
	{
	  if (thd->lex->sphead)
5812 5813 5814 5815
	  {
	    delete thd->lex->sphead;
	    thd->lex->sphead= NULL;
	  }
5816
	}
5817 5818
	else
	{
5819 5820 5821 5822 5823 5824 5825 5826 5827 5828
          /*
            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
5829 5830
          if (lex->found_semicolon &&
              (thd->query_length= (ulong)(lex->found_semicolon - thd->query)))
5831 5832
            thd->query_length--;
          /* Actually execute the query */
5833
	  mysql_execute_command(thd);
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
5834
	  query_cache_end_of_result(thd);
5835
	}
5836
      }
5837
      lex->unit.cleanup();
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5838 5839
    }
    else
5840
    {
5841
      DBUG_ASSERT(thd->net.report_error);
5842
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
5843
			 thd->is_fatal_error));
5844 5845 5846 5847 5848

      /*
        The first thing we do after parse error is freeing sp_head to
        ensure that we have restored original memroot.
      */
5849
      if (thd->lex->sphead)
5850
      {
monty@mysql.com's avatar
monty@mysql.com committed
5851
	/* Clean up after failed stored procedure/function */
5852 5853 5854
	delete thd->lex->sphead;
	thd->lex->sphead= NULL;
      }
5855 5856
      query_cache_abort(&thd->net);
      lex->unit.cleanup();
5857
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5858
    thd->proc_info="freeing items";
5859
    thd->end_statement();
5860
    thd->cleanup_after_query();
5861
    DBUG_ASSERT(thd->change_list.is_empty());
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5862
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5863 5864 5865 5866
  DBUG_VOID_RETURN;
}


monty@mysql.com's avatar
monty@mysql.com committed
5867
#ifdef HAVE_REPLICATION
5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878
/*
  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)
{
5879
  LEX *lex= thd->lex;
5880
  bool error= 0;
monty@mysql.com's avatar
monty@mysql.com committed
5881
  DBUG_ENTER("mysql_test_parse_for_slave");
5882

5883
  mysql_init_query(thd, (uchar*) inBuf, length);
5884
  if (!MYSQLparse((void*) thd) && ! thd->is_fatal_error &&
5885
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
monty@mysql.com's avatar
monty@mysql.com committed
5886
    error= 1;                  /* Ignore question */
5887
  thd->end_statement();
5888
  thd->cleanup_after_query();
monty@mysql.com's avatar
monty@mysql.com committed
5889
  DBUG_RETURN(error);
5890
}
monty@mysql.com's avatar
monty@mysql.com committed
5891
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5892

5893

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5895 5896 5897 5898 5899
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5900
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
5901
		       char *length, char *decimals,
5902
		       uint type_modifier,
5903 5904
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
5905 5906
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
5907
		       uint uint_geom_type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5908 5909
{
  register create_field *new_field;
5910
  LEX  *lex= thd->lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5911 5912 5913 5914
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
5915
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5916 5917 5918 5919 5920
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
5921
    lex->key_list.push_back(new Key(Key::PRIMARY, NullS, HA_KEY_ALG_UNDEF,
5922
				    0, lex->col_list));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5923 5924 5925 5926 5927
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
5928
    lex->key_list.push_back(new Key(Key::UNIQUE, NullS, HA_KEY_ALG_UNDEF, 0,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5929 5930 5931 5932
				    lex->col_list));
    lex->col_list.empty();
  }

5933
  if (default_value)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5934
  {
5935
    /* 
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5936 5937
      Default value should be literal => basic constants =>
      no need fix_fields()
5938 5939 5940
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
5941
    */
5942 5943 5944
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
5945
    {
5946
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
5947 5948 5949
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5950
    {
5951
      default_value= 0;
5952 5953 5954
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
5955
	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
5956 5957 5958 5959 5960
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
5961
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5962 5963 5964
      DBUG_RETURN(1);
    }
  }
5965 5966 5967

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
5968
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
5969 5970
    DBUG_RETURN(1);
  }
5971

5972 5973 5974 5975 5976 5977
  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
5978
    char buf[32];
5979
    my_snprintf(buf, sizeof(buf), "TIMESTAMP(%s)", length);
5980 5981 5982
    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
5983
                        buf, "TIMESTAMP");
5984 5985
  }

5986 5987 5988 5989
  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
5990
    DBUG_RETURN(1);
5991 5992 5993 5994 5995 5996

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

5997

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5998 5999 6000 6001
/* Store position for column in ALTER TABLE .. ADD column */

void store_position_for_column(const char *name)
{
6002
  current_thd->lex->last_field->after=my_const_cast(char*) (name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6003 6004 6005
}

bool
6006
add_proc_to_list(THD* thd, Item *item)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6007 6008 6009 6010
{
  ORDER *order;
  Item	**item_ptr;

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6011
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6012 6013 6014 6015 6016
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
6017
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6018 6019 6020 6021 6022 6023 6024 6025
  return 0;
}


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

static void remove_escape(char *name)
{
6026 6027
  if (!*name)					// For empty DB names
    return;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6028 6029
  char *to;
#ifdef USE_MB
6030
  char *strend=name+(uint) strlen(name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6031 6032 6033 6034 6035
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
6036 6037
    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
6038 6039 6040 6041 6042 6043 6044 6045
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6046
      name++;					// Skip '\\'
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6047 6048 6049 6050 6051 6052 6053 6054 6055 6056
    *to++= *name;
  }
  *to=0;
}

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


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6057
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6058 6059 6060
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
6061
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6062
    DBUG_RETURN(1);
6063 6064
  order->item_ptr= item;
  order->item= &order->item_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6065 6066 6067
  order->asc = asc;
  order->free_me=0;
  order->used=0;
6068
  order->counter_used= 0;
6069
  list.link_in_list((byte*) order,(byte**) &order->next);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6070 6071 6072 6073
  DBUG_RETURN(0);
}


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6074 6075 6076 6077 6078 6079 6080 6081 6082 6083
/*
  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
6084
			TL_OPTION_ALIAS	        an alias in multi table DELETE
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6085 6086 6087 6088 6089 6090 6091 6092 6093
    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
6094 6095
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
6096
					     LEX_STRING *alias,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6097 6098
					     ulong table_options,
					     thr_lock_type lock_type,
6099 6100
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6101
                                             LEX_STRING *option)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6102 6103
{
  register TABLE_LIST *ptr;
6104
  TABLE_LIST *previous_table_ref; /* The table preceding the current one. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6105
  char *alias_str;
6106
  LEX *lex= thd->lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6107
  DBUG_ENTER("add_table_to_list");
6108
  LINT_INIT(previous_table_ref);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6109 6110 6111 6112

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
6113 6114
  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
6115
  {
6116
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6117 6118 6119 6120
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
6121 6122 6123
  {
    if (table->sel)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6124 6125
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
6126 6127
      DBUG_RETURN(0);
    }
6128
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6129
      DBUG_RETURN(0);
6130
  }
6131
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6132
    DBUG_RETURN(0);				/* purecov: inspected */
peter@mysql.com's avatar
peter@mysql.com committed
6133
  if (table->db.str)
6134
  {
6135 6136 6137 6138 6139
    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);
    }
6140 6141 6142
    ptr->db= table->db.str;
    ptr->db_length= table->db.length;
  }
6143 6144
  else if (thd->copy_db_to(&ptr->db, &ptr->db_length))
    DBUG_RETURN(0);
peter@mysql.com's avatar
peter@mysql.com committed
6145

6146
  ptr->alias= alias_str;
6147
  if (lower_case_table_names && table->table.length)
6148
    table->table.length= my_casedn_str(files_charset_info, table->table.str);
6149 6150
  ptr->table_name=table->table.str;
  ptr->table_name_length=table->table.length;
6151
  ptr->lock_type=   lock_type;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6152 6153
  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
6154
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
6155
  ptr->derived=	    table->sel;
6156 6157
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
                                      information_schema_name.str))
6158
  {
6159
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
6160 6161 6162
    if (!schema_table ||
        (schema_table->hidden && 
         lex->orig_sql_command == SQLCOM_END))  // not a 'show' command
6163
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6164
      my_error(ER_UNKNOWN_TABLE, MYF(0),
6165
               ptr->table_name, information_schema_name.str);
6166 6167
      DBUG_RETURN(0);
    }
6168
    ptr->schema_table_name= ptr->table_name;
6169 6170
    ptr->schema_table= schema_table;
  }
6171
  ptr->select_lex=  lex->current_select;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6172
  ptr->cacheable_table= 1;
6173 6174 6175 6176 6177 6178
  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
6179
  ptr->option= option ? option->str : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6180
  /* check that used name is unique */
6181
  if (lock_type != TL_IGNORE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6182
  {
timour@mysql.com's avatar
timour@mysql.com committed
6183 6184 6185 6186
    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 ;
6187
	 tables ;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6188
	 tables=tables->next_local)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6189
    {
6190 6191
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
6192
      {
6193
	my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
6194 6195
	DBUG_RETURN(0);				/* purecov: tested */
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6196 6197
    }
  }
6198 6199 6200
  /* Store the table reference preceding the current one. */
  if (table_list.elements > 0)
  {
6201 6202 6203
    /*
      table_list.next points to the last inserted TABLE_LIST->next_local'
      element
6204
      We don't use the offsetof() macro here to avoid warnings from gcc
6205
    */
6206 6207 6208
    previous_table_ref= (TABLE_LIST*) ((char*) table_list.next -
                                       ((char*) &(ptr->next_local) -
                                        (char*) ptr));
6209 6210 6211 6212 6213 6214 6215 6216
    /*
      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;
6217
  }
6218

6219 6220 6221 6222 6223 6224
  /*
    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
6225
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
6226
  ptr->next_name_resolution_table= NULL;
6227
  /* Link table in global list (all used tables) */
6228
  lex->add_to_query_tables(ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6229 6230 6231
  DBUG_RETURN(ptr);
}

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

6233 6234 6235 6236
/*
  Initialize a new table list for a nested join

  SYNOPSIS
6237
    init_nested_join()
6238
    thd         current thread
6239

6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258
  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");
6259

6260 6261
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6262
    DBUG_RETURN(1);
6263 6264 6265
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285
  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
6286
    moves it one level up, eliminating the nest.
6287 6288 6289 6290 6291 6292 6293 6294 6295

  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;
6296
  NESTED_JOIN *nested_join;
6297
  DBUG_ENTER("end_nested_join");
6298

6299
  DBUG_ASSERT(embedding);
6300 6301 6302
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
6303
  nested_join= ptr->nested_join;
6304 6305 6306 6307 6308 6309 6310 6311 6312
  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;
  }
6313
  else if (nested_join->join_list.elements == 0)
6314 6315
  {
    join_list->pop();
6316
    ptr= 0;                                     // return value
6317
  }
6318 6319 6320 6321 6322 6323 6324 6325
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
6326
    nest_last_join()
6327 6328 6329 6330 6331 6332
    thd         current thread

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

  RETURN VALUE
6333 6334 6335
    0  Error
    #  Pointer to TABLE_LIST element created for the new nested join

6336 6337 6338 6339 6340 6341
*/

TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
6342
  List<TABLE_LIST> *embedded_list;
6343
  DBUG_ENTER("nest_last_join");
6344

6345 6346
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6347
    DBUG_RETURN(0);
6348 6349 6350
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6351 6352
  ptr->embedding= embedding;
  ptr->join_list= join_list;
6353
  embedded_list= &nested_join->join_list;
6354
  embedded_list->empty();
6355 6356

  for (uint i=0; i < 2; i++)
6357 6358 6359 6360 6361
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374
    if (table->natural_join)
    {
      ptr->is_natural_join= TRUE;
      /*
        If this is a JOIN ... USING, move the list of joined fields to the
        table reference that describes the join.
      */
      if (table->join_using_fields)
      {
        ptr->join_using_fields= table->join_using_fields;
        table->join_using_fields= NULL;
      }
    }
6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414
  }
  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
6415 6416 6417

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440
    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
*/

6441
TABLE_LIST *st_select_lex::convert_right_join()
6442 6443
{
  TABLE_LIST *tab2= join_list->pop();
6444
  TABLE_LIST *tab1= join_list->pop();
6445 6446 6447 6448 6449 6450 6451 6452 6453
  DBUG_ENTER("convert_right_join");

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

  DBUG_RETURN(tab1);
}

6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466
/*
  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
*/

6467
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
6468 6469 6470 6471 6472 6473
{
  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
6474 6475 6476
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
6477 6478 6479 6480 6481 6482 6483
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

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

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513
/*
  Create a fake SELECT_LEX for a unit

  SYNOPSIS:
    add_fake_select_lex()
    thd			   thread handle

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

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

bool st_select_lex_unit::add_fake_select_lex(THD *thd)
{
  SELECT_LEX *first_sl= first_select();
  DBUG_ENTER("add_fake_select_lex");
  DBUG_ASSERT(!fake_select_lex);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6514

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6515 6516 6517 6518 6519
  if (!(fake_select_lex= new (thd->mem_root) SELECT_LEX()))
      DBUG_RETURN(1);
  fake_select_lex->include_standalone(this, 
                                      (SELECT_LEX_NODE**)&fake_select_lex);
  fake_select_lex->select_number= INT_MAX;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6520
  fake_select_lex->parent_lex= thd->lex; /* Used in init_query. */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6521 6522
  fake_select_lex->make_empty_select();
  fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
6523 6524
  fake_select_lex->select_limit= 0;

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6525
  fake_select_lex->context.outer_context=first_sl->context.outer_context;
6526 6527 6528
  /* 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
6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541

  if (!first_sl->next_select())
  {
    /* 
      This works only for 
      (SELECT ... ORDER BY list [LIMIT n]) ORDER BY order_list [LIMIT m],
      (SELECT ... LIMIT n) ORDER BY order_list [LIMIT m]
      just before the parser starts processing order_list
    */ 
    global_parameters= fake_select_lex;
    fake_select_lex->no_table_names_allowed= 1;
    thd->lex->current_select= fake_select_lex;
  }
6542
  thd->lex->pop_context();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6543 6544 6545
  DBUG_RETURN(0);
}

6546

6547
/*
6548 6549
  Push a new name resolution context for a JOIN ... ON clause to the
  context stack of a query block.
6550 6551

  SYNOPSIS
6552
    push_new_name_resolution_context()
6553
    thd       pointer to current thread
timour@mysql.com's avatar
timour@mysql.com committed
6554
    left_op   left  operand of the JOIN
6555 6556 6557 6558
    right_op  rigth operand of the JOIN

  DESCRIPTION
    Create a new name resolution context for a JOIN ... ON clause,
6559 6560 6561
    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.
6562 6563

  RETURN
6564 6565
    FALSE  if all is OK
    TRUE   if a memory allocation error occured
6566 6567
*/

6568 6569 6570
bool
push_new_name_resolution_context(THD *thd,
                                 TABLE_LIST *left_op, TABLE_LIST *right_op)
6571 6572
{
  Name_resolution_context *on_context;
6573
  if (!(on_context= new (thd->mem_root) Name_resolution_context))
6574
    return TRUE;
6575 6576 6577 6578 6579
  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();
6580
  return thd->lex->push_context(on_context);
6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600
}


/*
  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
6601
{
6602
  if (expr)
6603
  {
6604
    if (!b->on_expr)
6605
      b->on_expr= expr;
6606 6607
    else
    {
6608 6609 6610 6611 6612 6613
      /*
        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);
6614 6615
    }
    b->on_expr->top_level_item();
6616
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6617 6618 6619
}


6620
/*
6621 6622
  Mark that there is a NATURAL JOIN or JOIN ... USING between two
  tables.
6623 6624 6625

  SYNOPSIS
    add_join_natural()
6626 6627 6628 6629
    a			Left join argument
    b			Right join argument
    using_fields        Field names from USING clause
  
6630
  IMPLEMENTATION
6631 6632 6633 6634 6635 6636 6637 6638 6639 6640
    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
6641 6642 6643
    SELECT * FROM t1 NATURAL LEFT JOIN t2
     <=>
    SELECT * FROM t1 LEFT JOIN t2 ON (t1.i=t2.i and t1.j=t2.j ... )
6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654

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

6657
void add_join_natural(TABLE_LIST *a, TABLE_LIST *b, List<String> *using_fields)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6658
{
6659 6660
  b->natural_join= a;
  b->join_using_fields= using_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6661 6662
}

6663

6664
/*
6665 6666 6667 6668
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
6669
    thd			Thread handler (can be NULL!)
6670 6671 6672 6673 6674
    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
6675 6676 6677
                        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.
6678 6679 6680

  RETURN
    0	 ok
6681
    !=0  error.  thd->killed or thd->net.report_error is set
6682 6683
*/

6684 6685
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
6686 6687 6688
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
6689
  bool tmp_write_to_binlog= 1;
6690

6691
  DBUG_ASSERT(!thd || !thd->in_sub_stmt);
6692

hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
6693
#ifndef NO_EMBEDDED_ACCESS_CHECKS
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6694 6695
  if (options & REFRESH_GRANT)
  {
6696 6697 6698 6699 6700 6701
    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)))
6702 6703
    {
      thd->thread_stack= (char*) &tmp_thd;
6704
      thd->store_globals();
6705
    }
6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717
    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;
    }
6718
    reset_mqh((LEX_USER *)NULL, TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6719
  }
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
6720
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6721 6722
  if (options & REFRESH_LOG)
  {
6723
    /*
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6724 6725
      Flush the normal query log, the update log, the binary log,
      the slow query log, and the relay log (if it exists).
6726
    */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6727

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

6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861
/*
  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
6862
void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6863 6864 6865
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
6866 6867
  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
6868 6869 6870 6871
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
6872 6873
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6874 6875 6876
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
6877 6878
  if (tmp)
  {
6879 6880
    if ((thd->security_ctx->master_access & SUPER_ACL) ||
	!strcmp(thd->security_ctx->user, tmp->security_ctx->user))
6881
    {
hf@genie.(none)'s avatar
SCRUM  
hf@genie.(none) committed
6882
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
6883 6884 6885 6886 6887 6888 6889
      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
6890
  if (!error)
6891
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6892
  else
6893
    my_error(error, MYF(0), id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6894 6895
}

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

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

6899 6900
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name)
6901
{
6902
  char buff[FN_REFLEN],*ptr, *end;
6903 6904 6905 6906 6907 6908 6909
  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))
  {
6910
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
6911 6912 6913 6914
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
6915
  end=convert_dirname(buff, *filename_ptr, NullS);
6916
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
6917 6918
    return 1;					// End of memory
  *filename_ptr=ptr;
6919
  strxmov(ptr,buff,table_name,NullS);
6920 6921
  return 0;
}
6922

6923

6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937
/*
  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;
6938 6939
  LEX *lex= thd->lex;
  if (lex->current_select != &lex->select_lex)
6940 6941
  {
    char command[80];
6942 6943
    strmake(command, lex->yylval->symbol.str,
	    min(lex->yylval->symbol.length, sizeof(command)-1));
6944
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
6945 6946 6947 6948
    return 1;
  }
  return 0;
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6949

6950

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6951
Comp_creator *comp_eq_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6952
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6953
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6954 6955
}

6956

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6957
Comp_creator *comp_ge_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6958
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6959
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6960 6961
}

6962

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6963
Comp_creator *comp_gt_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6964
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6965
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6966 6967
}

6968

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6969
Comp_creator *comp_le_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6970
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6971
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6972 6973
}

6974

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6975
Comp_creator *comp_lt_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6976
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6977
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6978 6979
}

6980

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6981
Comp_creator *comp_ne_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6982
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6983
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6984
}
6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004


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

  if ((cmp == &comp_ne_creator) && all)        // <> ALL <=> NOT IN
7009 7010 7011
    return new Item_func_not(new Item_in_subselect(left_expr, select_lex));

  Item_allany_subselect *it=
7012
    new Item_allany_subselect(left_expr, cmp, select_lex, all);
7013
  if (all)
7014
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
7015

7016
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
7017
}
7018 7019


7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031
/*
  CREATE INDEX and DROP INDEX are implemented by calling ALTER TABLE with
  the proper arguments.  This isn't very fast but it should work for most
  cases.

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

  One should normally create all indexes with CREATE TABLE or ALTER TABLE.
*/

7032
bool mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
7033 7034
{
  List<create_field> fields;
7035 7036
  ALTER_INFO alter_info;
  alter_info.flags= ALTER_ADD_INDEX;
7037 7038 7039 7040 7041
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_create_index");
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;
7042
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
7043
				&create_info, table_list,
7044
				fields, keys, 0, (ORDER*)0,
7045
                                0, &alter_info, 1));
7046 7047 7048
}


7049
bool mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
7050 7051 7052 7053 7054 7055 7056 7057
{
  List<create_field> fields;
  List<Key> keys;
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_drop_index");
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;
7058 7059
  alter_info->clear();
  alter_info->flags= ALTER_DROP_INDEX;
7060
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
7061
				&create_info, table_list,
7062
				fields, keys, 0, (ORDER*)0,
7063
                                0, alter_info, 1));
7064
}
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7065 7066


7067 7068 7069 7070 7071
/*
  Multi update query pre-check

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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7075
  RETURN VALUE
7076 7077
    FALSE OK
    TRUE  Error
7078
*/
7079

7080
bool multi_update_precheck(THD *thd, TABLE_LIST *tables)
7081 7082 7083 7084 7085
{
  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
7086
  DBUG_ENTER("multi_update_precheck");
7087 7088 7089

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
7090
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
7091
    DBUG_RETURN(TRUE);
7092 7093 7094 7095 7096
  }
  /*
    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
7097
  for (table= tables; table; table= table->next_local)
7098
  {
7099 7100 7101
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
7102 7103
                           &table->grant.privilege, 0, 1,
                           test(table->schema_table)) ||
7104 7105
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
monty@mysql.com's avatar
monty@mysql.com committed
7106
             (check_access(thd, SELECT_ACL, table->db,
7107 7108
                           &table->grant.privilege, 0, 0,
                           test(table->schema_table)) ||
monty@mysql.com's avatar
monty@mysql.com committed
7109
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
7110
      DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7111

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7112
    table->table_in_first_from_clause= 1;
7113
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7114 7115 7116
  /*
    Is there tables of subqueries?
  */
7117
  if (&lex->select_lex != lex->all_selects_list || lex->time_zone_tables_used)
7118
  {
7119
    DBUG_PRINT("info",("Checking sub query list"));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7120
    for (table= tables; table; table= table->next_global)
7121
    {
monty@mysql.com's avatar
monty@mysql.com committed
7122 7123 7124
      if (!my_tz_check_n_skip_implicit_tables(&table,
                                              lex->time_zone_tables_used) &&
          !table->table_in_first_from_clause)
7125 7126
      {
	if (check_access(thd, SELECT_ACL, table->db,
7127 7128
			 &table->grant.privilege, 0, 0,
                         test(table->schema_table)) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7129
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
7130
	  DBUG_RETURN(TRUE);
7131 7132 7133 7134 7135 7136
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
7137
  else if (select_lex->select_limit)
7138 7139 7140 7141
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
7142
    DBUG_RETURN(TRUE);
7143
  }
7144
  DBUG_RETURN(FALSE);
7145 7146 7147 7148 7149 7150 7151
}

/*
  Multi delete query pre-check

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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7155
  RETURN VALUE
7156 7157
    FALSE OK
    TRUE  error
7158
*/
7159

7160
bool multi_delete_precheck(THD *thd, TABLE_LIST *tables)
7161 7162 7163
{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  TABLE_LIST *aux_tables=
7164
    (TABLE_LIST *)thd->lex->auxiliary_table_list.first;
7165
  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
7166
  DBUG_ENTER("multi_delete_precheck");
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7167

7168 7169 7170
  /* 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) ||
7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182
      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;
7183
    DBUG_RETURN(TRUE);
7184 7185 7186
  }
  thd->lex->query_tables_own_last= save_query_tables_own_last;

7187 7188
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7189 7190
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
7191
    DBUG_RETURN(TRUE);
7192
  }
7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217
  DBUG_RETURN(FALSE);
}


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

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

  RETURN VALUE
    FALSE - success
    TRUE  - error
*/

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

  lex->table_count= 0;

7218
  for (target_tbl= (TABLE_LIST *)lex->auxiliary_table_list.first;
7219
       target_tbl; target_tbl= target_tbl->next_local)
7220
  {
7221
    lex->table_count++;
7222 7223
    /* 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
7224
    for (walk= tables; walk; walk= walk->next_local)
7225
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7226 7227 7228
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
7229 7230 7231 7232
	break;
    }
    if (!walk)
    {
7233
      my_error(ER_UNKNOWN_TABLE, MYF(0),
7234
               target_tbl->table_name, "MULTI DELETE");
7235
      DBUG_RETURN(TRUE);
7236
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
7237 7238 7239 7240 7241
    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
7242
    walk->updating= target_tbl->updating;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7243
    walk->lock_type= target_tbl->lock_type;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7244
    target_tbl->correspondent_table= walk;	// Remember corresponding table
7245
  }
7246
  DBUG_RETURN(FALSE);
7247 7248 7249
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7250 7251 7252 7253 7254
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
7255 7256
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7257 7258

  RETURN VALUE
7259 7260
    FALSE OK
    TRUE  Error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7261
*/
7262

7263
bool update_precheck(THD *thd, TABLE_LIST *tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7264 7265 7266 7267
{
  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
7268
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
7269
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7270
  }
7271 7272
  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
7273 7274 7275 7276 7277 7278 7279 7280
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
7281 7282
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7283 7284

  RETURN VALUE
7285 7286
    FALSE  OK
    TRUE   error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7287
*/
7288

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


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
7305 7306
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7307 7308

  RETURN VALUE
7309 7310
    FALSE  OK
    TRUE   error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7311
*/
7312

bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7313
bool insert_precheck(THD *thd, TABLE_LIST *tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7314 7315 7316 7317
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

7318 7319 7320 7321
  /*
    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
7322 7323 7324
  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
7325 7326

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

7329
  if (lex->update_list.elements != lex->value_list.elements)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7330
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7331
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
7332
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7333
  }
7334 7335
  if (check_db_used(thd, tables))
    DBUG_RETURN(TRUE);
7336
  DBUG_RETURN(FALSE);
7337
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7338 7339 7340 7341 7342 7343 7344


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
7345 7346 7347
    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
7348 7349

  RETURN VALUE
7350 7351
    FALSE   OK
    TRUE   Error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7352
*/
7353

7354 7355
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
7356 7357
{
  LEX *lex= thd->lex;
7358 7359
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7360
  bool error= TRUE;                                 // Error message is given
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7361
  DBUG_ENTER("create_table_precheck");
7362 7363 7364

  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
7365 7366
  lex->create_info.alias= create_table->alias;
  if (check_access(thd, want_priv, create_table->db,
7367 7368
		   &create_table->grant.privilege, 0, 0,
                   test(create_table->schema_table)) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7369 7370 7371
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
7372 7373
    goto err;
  if (grant_option && want_priv != CREATE_TMP_ACL &&
7374
      check_grant(thd, want_priv, create_table, 0, 1, 0))
7375 7376 7377 7378 7379 7380
    goto err;

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

7381 7382
#ifdef NOT_NECESSARY_TO_CHECK_CREATE_TABLE_EXIST_WHEN_PREPARING_STATEMENT
    /* This code throws an ill error for CREATE TABLE t1 SELECT * FROM t1 */
7383
    /*
monty@mysql.com's avatar
monty@mysql.com committed
7384 7385 7386
      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).
7387
    */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7388
    if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
7389
    {
monty@mysql.com's avatar
monty@mysql.com committed
7390 7391 7392 7393
      /*
        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
7394
          find_table_in_global_list(tables, create_table->db,
7395
                                    create_table->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
7396
      {
7397
	error= FALSE;
monty@mysql.com's avatar
monty@mysql.com committed
7398 7399 7400
        goto err;
      }
    }
7401
#endif
7402 7403 7404
    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
7405
  error= FALSE;
7406 7407 7408

err:
  DBUG_RETURN(error);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7409
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7410 7411 7412 7413 7414 7415 7416


/*
  negate given expression

  SYNOPSIS
    negate_expression()
7417
    thd  thread handler
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445
    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);
}
7446

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

7468

7469
/*
7470
  Create default definer for the specified THD.
7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488

  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;

7489
  get_default_definer(thd, definer);
7490 7491 7492 7493 7494

  return definer;
}


7495
/*
7496
  Create definer with the given user and host names.
7497 7498

  SYNOPSIS
7499 7500 7501 7502
    create_definer()
    thd         [in] thread handler
    user_name   [in] user name
    host_name   [in] host name
7503 7504

  RETURN
7505
    On success, return a valid pointer to the created and initialized
7506
    LEX_USER, which contains definer information.
7507
    On error, return 0.
7508 7509
*/

7510
LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name)
7511
{
7512 7513 7514 7515
  LEX_USER *definer;

  /* Create and initialize. */

7516
  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
7517 7518 7519 7520 7521 7522
    return 0;

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

  return definer;
7523
}
7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542


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

7545 7546
  return user;
}
7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562


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

7563 7564
bool check_string_length(LEX_STRING *str, const char *err_msg,
                         uint max_length)
7565
{
7566 7567
  if (str->length <= max_length)
    return FALSE;
7568 7569

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

7571 7572
  return TRUE;
}