sql_parse.cc 216 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 17
   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 */

#include "mysql_priv.h"
18
#include "sql_repl.h"
lars@mysql.com's avatar
lars@mysql.com committed
19
#include "rpl_filter.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>

25
#include "sp_head.h"
26
#include "sp.h"
27
#include "sp_cache.h"
28
#include "event.h"
29

30 31 32 33 34 35 36 37 38 39 40
#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?
*/
41 42 43
#define SSL_HANDSHAKE_SIZE      2
#define NORMAL_HANDSHAKE_SIZE   6
#define MIN_HANDSHAKE_SIZE      2
44
#else
45
#define MIN_HANDSHAKE_SIZE      6
46
#endif /* HAVE_OPENSSL */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
47

48 49 50 51 52 53
/* 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 || \
54
   (LP)->sql_command == SQLCOM_SHOW_CREATE_FUNC || \
55 56 57
   (LP)->sql_command == SQLCOM_DROP_FUNCTION ? \
   "FUNCTION" : "PROCEDURE")

58 59 60
#ifdef SOLARIS
extern "C" int gethostname(char *name, int namelen);
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
61

62
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
63
#ifndef NO_EMBEDDED_ACCESS_CHECKS
64
static int check_for_max_user_connections(THD *thd, USER_CONN *uc);
65
#endif
66
static void decrease_user_connections(USER_CONN *uc);
67
static bool check_db_used(THD *thd,TABLE_LIST *tables);
68
static bool check_multi_update_lock(THD *thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
69
static void remove_escape(char *name);
70
static void refresh_status(THD *thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
71

72
const char *any_db="*any*";	// Special symbol for check_access
bk@work.mysql.com's avatar
bk@work.mysql.com committed
73

74
LEX_STRING command_name[]={
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
  (char *)STRING_WITH_LEN("Sleep"),
  (char *)STRING_WITH_LEN("Quit"),
  (char *)STRING_WITH_LEN("Init DB"),
  (char *)STRING_WITH_LEN("Query"),
  (char *)STRING_WITH_LEN("Field List"),
  (char *)STRING_WITH_LEN("Create DB"),
  (char *)STRING_WITH_LEN("Drop DB"),
  (char *)STRING_WITH_LEN("Refresh"),
  (char *)STRING_WITH_LEN("Shutdown"),
  (char *)STRING_WITH_LEN("Statistics"),
  (char *)STRING_WITH_LEN("Processlist"),
  (char *)STRING_WITH_LEN("Connect"),
  (char *)STRING_WITH_LEN("Kill"),
  (char *)STRING_WITH_LEN("Debug"),
  (char *)STRING_WITH_LEN("Ping"),
  (char *)STRING_WITH_LEN("Time"),
  (char *)STRING_WITH_LEN("Delayed insert"),
  (char *)STRING_WITH_LEN("Change user"),
  (char *)STRING_WITH_LEN("Binlog Dump"),
  (char *)STRING_WITH_LEN("Table Dump"),
  (char *)STRING_WITH_LEN("Connect Out"),
  (char *)STRING_WITH_LEN("Register Slave"),
  (char *)STRING_WITH_LEN("Prepare"),
  (char *)STRING_WITH_LEN("Execute"),
  (char *)STRING_WITH_LEN("Long Data"),
  (char *)STRING_WITH_LEN("Close stmt"),
  (char *)STRING_WITH_LEN("Reset stmt"),
  (char *)STRING_WITH_LEN("Set option"),
  (char *)STRING_WITH_LEN("Fetch"),
  (char *)STRING_WITH_LEN("Daemon"),
  (char *)STRING_WITH_LEN("Error")  // Last command number
bk@work.mysql.com's avatar
bk@work.mysql.com committed
106 107
};

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

112
static char empty_c_string[1]= {0};		// Used for not defined 'db'
bk@work.mysql.com's avatar
bk@work.mysql.com committed
113 114 115 116

#ifdef __WIN__
static void  test_signal(int sig_ptr)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
117
#if !defined( DBUG_OFF)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
118 119
  MessageBox(NULL,"Test signal","DBUG",MB_OK);
#endif
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
120
#if defined(OS2)
121 122
  fprintf(stderr, "Test signal %d\n", sig_ptr);
  fflush(stderr);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
123
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
124 125 126 127
}
static void init_signals(void)
{
  int signals[7] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGBREAK,SIGABRT } ;
128
  for (int i=0 ; i < 7 ; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
129 130 131 132
    signal( signals[i], test_signal) ;
}
#endif

133 134 135 136 137
static void unlock_locked_tables(THD *thd)
{
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
138
    thd->locked_tables=0;			// Will be automatically closed
139 140 141 142
    close_thread_tables(thd);			// Free tables
  }
}

143

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

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
174
bool begin_trans(THD *thd)
175 176
{
  int error=0;
177
  if (unlikely(thd->in_sub_stmt))
178 179 180 181
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    return 1;
  }
182 183 184 185 186 187 188 189 190 191
  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
  {
192
    LEX *lex= thd->lex;
193 194 195 196
    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
197
      error= ha_start_consistent_snapshot(thd);
198 199 200
  }
  return error;
}
201

monty@mysql.com's avatar
monty@mysql.com committed
202
#ifdef HAVE_REPLICATION
203 204 205
/*
  Returns true if all tables should be ignored
*/
206 207
inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables)
{
208
  return rpl_filter->is_on() && tables && !thd->spcont &&
tomas@poseidon.ndb.mysql.com's avatar
Merge  
tomas@poseidon.ndb.mysql.com committed
209
         !rpl_filter->tables_ok(thd->db, tables);
210
}
monty@mysql.com's avatar
monty@mysql.com committed
211
#endif
212 213


214 215 216 217 218 219 220 221 222 223 224 225
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;
}

226 227
static HASH hash_user_connections;

228 229
static int get_or_create_user_conn(THD *thd, const char *user,
				   const char *host,
peter@mysql.com's avatar
peter@mysql.com committed
230
				   USER_RESOURCES *mqh)
231
{
232
  int return_val= 0;
233
  uint temp_len, user_len;
234
  char temp_user[USER_HOST_BUFF_SIZE];
235 236 237 238 239
  struct  user_conn *uc;

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

240
  user_len= strlen(user);
241
  temp_len= (strmov(strmov(temp_user, user)+1, host) - temp_user)+1;
242
  (void) pthread_mutex_lock(&LOCK_user_conn);
243 244
  if (!(uc = (struct  user_conn *) hash_search(&hash_user_connections,
					       (byte*) temp_user, temp_len)))
245
  {
246 247 248
    /* First connection for user; Create a user connection object */
    if (!(uc= ((struct user_conn*)
	       my_malloc(sizeof(struct user_conn) + temp_len+1,
249 250
			 MYF(MY_WME)))))
    {
251
      net_send_error(thd, 0, NullS);		// Out of memory
252
      return_val= 1;
253
      goto end;
254
    }
255 256
    uc->user=(char*) (uc+1);
    memcpy(uc->user,temp_user,temp_len+1);
257
    uc->host= uc->user + user_len +  1;
258
    uc->len= temp_len;
259
    uc->connections= uc->questions= uc->updates= uc->conn_per_hour= 0;
260 261
    uc->user_resources= *mqh;
    uc->intime= thd->thr_create_time;
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
262
    if (my_hash_insert(&hash_user_connections, (byte*) uc))
263 264
    {
      my_free((char*) uc,0);
265
      net_send_error(thd, 0, NullS);		// Out of memory
266
      return_val= 1;
267 268 269 270
      goto end;
    }
  }
  thd->user_connect=uc;
271
  uc->connections++;
272 273 274
end:
  (void) pthread_mutex_unlock(&LOCK_user_conn);
  return return_val;
peter@mysql.com's avatar
peter@mysql.com committed
275

276
}
277 278 279


/*
280 281
  Check if user exist and password supplied is correct. 

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

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

298
  RETURN VALUE
299 300
    0  OK; thd->security_ctx->user/master_access/priv_user/db_access and
       thd->db are updated; OK is sent to client;
301 302
   -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
303 304
*/

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

335 336 337 338 339
  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);
  
340
  /*
341 342
    If the server is running in secure auth mode, short scrambles are 
    forbidden.
343
  */
344
  if (opt_secure_auth_local && passwd_len == SCRAMBLE_LENGTH_323)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
345
  {
346
    net_printf_error(thd, ER_NOT_SUPPORTED_AUTH_MODE);
347
    general_log_print(thd, COM_CONNECT, ER(ER_NOT_SUPPORTED_AUTH_MODE));
348
    DBUG_RETURN(-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
349
  }
350 351 352 353
  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
354

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

      if (check_count)
418
      {
419
        VOID(pthread_mutex_lock(&LOCK_thread_count));
serg@serg.mylan's avatar
serg@serg.mylan committed
420
        bool count_ok= thread_count <= max_connections + delayed_insert_threads
421
                       || (thd->main_security_ctx.master_access & SUPER_ACL);
422 423
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
        if (!count_ok)
serg@serg.mylan's avatar
serg@serg.mylan committed
424
        {                                         // too many connections
425
          net_send_error(thd, ER_CON_COUNT_ERROR);
426 427
          DBUG_RETURN(-1);
        }
428
      }
peter@mysql.com's avatar
peter@mysql.com committed
429

430
      /* Why logging is performed before all checks've passed? */
431 432 433 434 435 436 437 438
      general_log_print(thd, command,
                        (thd->main_security_ctx.priv_user ==
                         thd->main_security_ctx.user ?
                         (char*) "%s@%s on %s" :
                         (char*) "%s@%s as anonymous on %s"),
                        thd->main_security_ctx.user,
                        thd->main_security_ctx.host_or_ip,
                        db ? db : (char*) "");
439

440
      /*
441 442 443
        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.
444
      */
445
      thd->main_security_ctx.db_access=0;
446 447

      /* Don't allow user to connect if he has done too many queries */
448
      if ((ur.questions || ur.updates || ur.conn_per_hour || ur.user_conn ||
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
449
	   max_user_connections) &&
450
	  get_or_create_user_conn(thd,
451 452 453 454
            (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),
455
            &ur))
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
456 457
	DBUG_RETURN(-1);
      if (thd->user_connect &&
458 459
	  (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
460 461 462
	   max_user_connections) &&
	  check_for_max_user_connections(thd, thd->user_connect))
	DBUG_RETURN(-1);
463

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

500
/*
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
501 502
  Check for maximum allowable user connections, if the mysqld server is
  started with corresponding variable that is greater then 0.
503 504
*/

505 506
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
507 508 509 510 511
{
  *length=buff->len;
  return (byte*) buff->user;
}

512
extern "C" void free_user(struct user_conn *uc)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
513 514 515 516
{
  my_free((char*) uc,MYF(0));
}

peter@mysql.com's avatar
peter@mysql.com committed
517
void init_max_user_conn(void)
518
{
519 520
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
521
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
522
		   0);
523 524 525
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
/*
  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
*/

543 544
#ifndef NO_EMBEDDED_ACCESS_CHECKS

545
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
546
{
547
  int error=0;
548
  DBUG_ENTER("check_for_max_user_connections");
peter@mysql.com's avatar
peter@mysql.com committed
549

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

  end:
580 581
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
582
  (void) pthread_mutex_unlock(&LOCK_user_conn);
583
  DBUG_RETURN(error);
584
}
585
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
586

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
/*
  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.
*/

605
static void decrease_user_connections(USER_CONN *uc)
606
{
607
  DBUG_ENTER("decrease_user_connections");
608 609 610
  (void) pthread_mutex_lock(&LOCK_user_conn);
  DBUG_ASSERT(uc->connections);
  if (!--uc->connections && !mqh_used)
611 612
  {
    /* Last connection for user; Delete it */
613
    (void) hash_delete(&hash_user_connections,(byte*) uc);
614
  }
615
  (void) pthread_mutex_unlock(&LOCK_user_conn);
616
  DBUG_VOID_RETURN;
617 618
}

619

620 621 622 623 624
void free_max_user_conn(void)
{
  hash_free(&hash_user_connections);
}

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

626 627 628
/*
  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
629 630 631

  sql_command is actually set to SQLCOM_END sometimes
  so we need the +1 to include it in the array.
632 633 634 635 636 637

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

kent@mysql.com's avatar
kent@mysql.com committed
640
char  uc_update_queries[SQLCOM_END+1];
641 642 643

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

646 647 648
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
649 650 651 652 653 654
  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;
655 656 657 658 659
  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;
660 661
  uc_update_queries[SQLCOM_REPLACE]=2;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=2;
662 663 664 665
  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
666 667
  uc_update_queries[SQLCOM_CREATE_VIEW]=1;
  uc_update_queries[SQLCOM_DROP_VIEW]=1;
668 669 670
  uc_update_queries[SQLCOM_CREATE_EVENT]=1;
  uc_update_queries[SQLCOM_ALTER_EVENT]=1;
  uc_update_queries[SQLCOM_DROP_EVENT]=1;  
671 672
}

673 674
bool is_update_query(enum enum_sql_command command)
{
kent@mysql.com's avatar
kent@mysql.com committed
675
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
676
  return uc_update_queries[command] != 0;
677
}
678

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
679
/*
680 681
  Reset per-hour user resource limits when it has been more than
  an hour since they were last checked
682

683 684 685 686
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
687

688 689 690 691
  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.
*/
692

693
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
694
{
695
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
696
  DBUG_ENTER("time_out_user_resource_limits");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
697

698
  /* If more than a hour since last check, reset resource checking */
699 700 701 702 703 704 705
  if (check_time  - uc->intime >= 3600)
  {
    uc->questions=1;
    uc->updates=0;
    uc->conn_per_hour=0;
    uc->intime=check_time;
  }
706 707 708 709 710 711 712 713 714 715 716 717

  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)
{
718 719
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  bool error= 0;
720 721 722 723 724 725 726 727
  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);

728
  /* Check that we have not done too many questions / hour */
729 730 731
  if (uc->user_resources.questions &&
      uc->questions++ >= uc->user_resources.questions)
  {
732 733
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user, "max_questions",
                     (long) uc->user_resources.questions);
734 735 736
    error=1;
    goto end;
  }
737
  if (check_command < (uint) SQLCOM_END)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
738
  {
739 740 741 742
    /* 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)
    {
743 744
      net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user, "max_updates",
                       (long) uc->user_resources.updates);
745 746 747
      error=1;
      goto end;
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
748 749
  }
end:
750
  (void) pthread_mutex_unlock(&LOCK_user_conn);
751
  DBUG_RETURN(error);
752 753
#else
  return (0);
monty@mysql.com's avatar
monty@mysql.com committed
754
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
755 756
}

757

monty@mysql.com's avatar
monty@mysql.com committed
758
static void reset_mqh(LEX_USER *lu, bool get_them= 0)
759
{
monty@mysql.com's avatar
monty@mysql.com committed
760
#ifndef NO_EMBEDDED_ACCESS_CHECKS
761
  (void) pthread_mutex_lock(&LOCK_user_conn);
peter@mysql.com's avatar
peter@mysql.com committed
762
  if (lu)  // for GRANT
763
  {
764
    USER_CONN *uc;
765
    uint temp_len=lu->user.length+lu->host.length+2;
766
    char temp_user[USER_HOST_BUFF_SIZE];
767

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
798
/*
799
    Perform handshake, authorize client and update thd ACL variables.
800
  SYNOPSIS
801
    check_connection()
802
    thd  thread handle
803 804

  RETURN
805
     0  success, OK is sent to user, thd is updated.
806 807
    -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
808 809
*/

hf@deer.(none)'s avatar
hf@deer.(none) committed
810 811
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
812
{
813
  uint connect_errors= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
814
  NET *net= &thd->net;
monty@mysql.com's avatar
monty@mysql.com committed
815 816
  ulong pkt_len= 0;
  char *end;
817

818 819
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));
820
#ifdef SIGNAL_WITH_VIO_CLOSE
821
  thd->set_active_vio(net->vio);
822
#endif
823

824
  if (!thd->main_security_ctx.host)         // If TCP/IP connection
bk@work.mysql.com's avatar
bk@work.mysql.com committed
825
  {
826
    char ip[30];
827

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

873 874 875 876 877
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
878 879
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
880
      client_flags |= CLIENT_SSL;       /* Wow, SSL is available! */
881
#endif /* HAVE_OPENSSL */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
882

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

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

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

  if (end >= (char*) net->read_pos+ pkt_len +2)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1001
  {
1002 1003
    inc_host_errors(&thd->remote.sin_addr);
    return(ER_HANDSHAKE_ERROR);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1004 1005 1006
  }

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
1007
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
1008
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
1009 1010
      opt_using_transactions)
    net->return_status= &thd->server_status;
1011
  net->read_timeout=(uint) thd->variables.net_read_timeout;
peter@mysql.com's avatar
peter@mysql.com committed
1012

1013 1014
  char *user= end;
  char *passwd= strend(user)+1;
1015
  char *db= passwd;
1016
  char db_buff[NAME_LEN+1];                     // buffer to store db in utf8
1017
  char user_buff[USERNAME_LENGTH+1];		// buffer to store user in utf8
1018 1019 1020
  uint dummy_errors;

  /*
1021 1022 1023 1024
    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'.
  */
1025
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
1026 1027 1028
    *passwd++ : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
peter@mysql.com's avatar
peter@mysql.com committed
1029

kostja@oak.local's avatar
kostja@oak.local committed
1030 1031
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
peter@mysql.com's avatar
peter@mysql.com committed
1032
  {
1033 1034 1035
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info,
                             db, strlen(db),
1036
                             thd->charset(), &dummy_errors)]= 0;
1037
    db= db_buff;
kostja@oak.local's avatar
kostja@oak.local committed
1038
  }
peter@mysql.com's avatar
peter@mysql.com committed
1039

1040 1041 1042 1043
  user_buff[copy_and_convert(user_buff, sizeof(user_buff)-1,
                             system_charset_info, user, strlen(user),
                             thd->charset(), &dummy_errors)]= '\0';
  user= user_buff;
1044

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

1052

1053 1054
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
1055 1056 1057 1058
{
  Vio* save_vio;
  ulong save_client_capabilities;

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


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

  pthread_detach_this_thread();

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

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

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

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

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

1164
    if (sys_init_connect.value_length && !(sctx->master_access & SUPER_ACL))
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1165
    {
1166 1167
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
1168
	thd->killed= THD::KILL_CONNECTION;
1169 1170 1171
      thd->proc_info=0;
      thd->set_time();
      thd->init_for_queries();
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
1172 1173
    }

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

1216 1217 1218 1219
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1220

1221
pthread_handler_t handle_bootstrap(void *arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1222
{
1223 1224 1225
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1226

1227
  /* The following must be called before DBUG_ENTER */
1228
  thd->thread_stack= (char*) &thd;
1229
  if (my_thread_init() || thd->store_globals())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1230
  {
hf@deer.(none)'s avatar
hf@deer.(none) committed
1231
#ifndef EMBEDDED_LIBRARY
1232
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
hf@deer.(none)'s avatar
hf@deer.(none) committed
1233
#endif
1234
    thd->fatal_error();
1235
    goto end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1236
  }
1237 1238
  DBUG_ENTER("handle_bootstrap");

hf@deer.(none)'s avatar
hf@deer.(none) committed
1239
#ifndef EMBEDDED_LIBRARY
1240 1241
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1242
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1243
  sigset_t set;
1244 1245
  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
1246
#endif
hf@deer.(none)'s avatar
hf@deer.(none) committed
1247
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1248

1249
  if (thd->variables.max_join_size == HA_POS_ERROR)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1250 1251 1252 1253
    thd->options |= OPTION_BIG_SELECTS;

  thd->proc_info=0;
  thd->version=refresh_version;
1254 1255
  thd->security_ctx->priv_user=
    thd->security_ctx->user= (char*) my_strdup("boot", MYF(MY_WME));
serg@serg.mylan's avatar
serg@serg.mylan committed
1256
  thd->security_ctx->priv_host[0]=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1257

1258
  buff= (char*) thd->net.buff;
1259
  thd->init_for_queries();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1260 1261
  while (fgets(buff, thd->net.max_packet, file))
  {
monty@mishka.local's avatar
monty@mishka.local committed
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281
   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;

1282
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1283
           buff[length-1] == ';'))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1284 1285
      length--;
    buff[length]=0;
1286
    thd->query_length=length;
1287 1288
    thd->query= thd->memdup_w_gap(buff, length+1, 
				  thd->db_length+1+QUERY_CACHE_FLAGS_SIZE);
1289
    thd->query[length] = '\0';
1290 1291 1292 1293
    /*
      We don't need to obtain LOCK_thread_count here because in bootstrap
      mode we have only one thread.
    */
1294
    thd->query_id=next_query_id();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1295 1296
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
1297
    if (thd->is_fatal_error)
1298
      break;
1299
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1300
#ifdef USING_TRANSACTIONS
1301
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
1302
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1303
  }
1304 1305 1306

  /* thd->fatal_error should be set in case something went wrong */
end:
1307 1308 1309 1310 1311 1312
  bootstrap_error= thd->is_fatal_error;

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

hf@deer.(none)'s avatar
hf@deer.(none) committed
1313
#ifndef EMBEDDED_LIBRARY
1314 1315 1316
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1317
  (void) pthread_cond_broadcast(&COND_thread_count);
1318 1319
  my_thread_end();
  pthread_exit(0);
hf@deer.(none)'s avatar
hf@deer.(none) committed
1320
#endif
1321
  DBUG_RETURN(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1322 1323
}

1324
    /* This works because items are allocated with sql_alloc() */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1325

1326
void free_items(Item *item)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1327
{
1328
  Item *next;
monty@mysql.com's avatar
monty@mysql.com committed
1329
  DBUG_ENTER("free_items");
1330 1331 1332
  for (; item ; item=next)
  {
    next=item->next;
1333
    item->delete_self();
1334
  }
monty@mysql.com's avatar
monty@mysql.com committed
1335
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1336 1337
}

1338 1339 1340 1341
    /* This works because items are allocated with sql_alloc() */

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1348 1349 1350 1351 1352 1353 1354
int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd)
{
  TABLE* table;
  TABLE_LIST* table_list;
  int error = 0;
  DBUG_ENTER("mysql_table_dump");
  db = (db && db[0]) ? db : thd->db;
1355
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
1356
    DBUG_RETURN(1); // out of memory
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1357
  table_list->db= db;
1358
  table_list->table_name= table_list->alias= tbl_name;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1359 1360
  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
1361

1362 1363
  if (!db || check_db_name(db))
  {
1364
    my_error(ER_WRONG_DB_NAME ,MYF(0), db ? db : "NULL");
1365 1366
    goto err;
  }
1367
  if (lower_case_table_names)
1368
    my_casedn_str(files_charset_info, tbl_name);
1369
  remove_escape(table_list->table_name);
1370 1371 1372 1373

  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
1374
  if (check_one_table_access(thd, SELECT_ACL, table_list))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1375 1376
    goto err;
  thd->free_list = 0;
1377
  thd->query_length=(uint) strlen(tbl_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1378
  thd->query = tbl_name;
1379
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1380
  {
1381
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1382 1383
    goto err;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1384
  net_flush(&thd->net);
1385
  if ((error= table->file->dump(thd,fd)))
1386
    my_error(ER_GET_ERRNO, MYF(0), error);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1387

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1388
err:
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1389
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1390 1391
}

1392 1393 1394 1395
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1396
    end_trans()
1397 1398 1399 1400 1401 1402 1403
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1404
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
1405 1406 1407
{
  bool do_release= 0;
  int res= 0;
1408
  DBUG_ENTER("end_trans");
1409

1410
  if (unlikely(thd->in_sub_stmt))
1411 1412 1413 1414
  {
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
1415 1416 1417 1418 1419 1420
  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);
  }
1421 1422 1423 1424 1425 1426 1427 1428
  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;
1429
    res= ha_commit(thd);
1430
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
1431 1432
    break;
  case COMMIT_RELEASE:
serg@serg.mylan's avatar
serg@serg.mylan committed
1433
    do_release= 1; /* fall through */
1434 1435 1436 1437 1438 1439
  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
1440
    do_release= 1; /* fall through */
1441 1442 1443 1444
  case ROLLBACK:
  case ROLLBACK_AND_CHAIN:
  {
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
serg@serg.mylan's avatar
serg@serg.mylan committed
1445
    if (ha_rollback(thd))
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
      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
1457

1458 1459 1460
  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
1461 1462
    thd->killed= THD::KILL_CONNECTION;

1463 1464
  DBUG_RETURN(res);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1465

1466
#ifndef EMBEDDED_LIBRARY
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477

/*
  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
1478 1479 1480
bool do_command(THD *thd)
{
  char *packet;
1481 1482
  uint old_timeout;
  ulong packet_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1483 1484 1485 1486 1487
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
1488 1489 1490 1491
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1492
  thd->lex->current_select= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1493 1494

  packet=0;
1495
  old_timeout=net->read_timeout;
monty@mysql.com's avatar
monty@mysql.com committed
1496
  /* Wait max for 8 hours */
1497
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
1498
  thd->clear_error();				// Clear error message
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1499 1500 1501 1502

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1503 1504 1505 1506 1507
    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)
1508 1509
    {
      statistic_increment(aborted_threads,&LOCK_status);
1510
      DBUG_RETURN(TRUE);			// We have to close it.
1511
    }
1512
    net_send_error(thd, net->last_errno, NullS);
1513
    net->error= 0;
1514
    DBUG_RETURN(FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1515 1516 1517 1518 1519
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1520 1521
    if (command >= COM_END)
      command= COM_END;				// Wrong command
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1522 1523 1524
    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
1525
  }
1526
  net->read_timeout=old_timeout;		// restore it
1527 1528 1529 1530 1531 1532 1533 1534 1535
  /*
    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.
  */
1536
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1537
}
1538
#endif  /* EMBEDDED_LIBRARY */
1539

1540

1541 1542
/*
   Perform one connection-level (COM_XXXX) command.
1543

1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556
  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
*/
1557

1558 1559 1560 1561
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1562
  bool error= 0;
1563 1564
  DBUG_ENTER("dispatch_command");

1565 1566 1567
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
    thd->killed= THD::NOT_KILLED;

1568
  thd->command=command;
1569
  /*
1570 1571
    Commands which always take a long time are logged into
    the slow log only if opt_log_slow_admin_statements is set.
1572
  */
1573
  thd->enable_slow_log= TRUE;
1574
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
1575
  thd->set_time();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1576 1577 1578
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
1579
    next_query_id();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1580
  thread_running++;
1581
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1582
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1583

1584 1585
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1586
  switch (command) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1587
  case COM_INIT_DB:
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1588 1589
  {
    LEX_STRING tmp;
1590 1591
    statistic_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB],
			&LOCK_status);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1592 1593
    thd->convert_string(&tmp, system_charset_info,
			packet, strlen(packet), thd->charset());
1594 1595
    if (!mysql_change_db(thd, tmp.str, FALSE))
    {
1596
      general_log_print(thd, command, "%s",thd->db);
1597 1598
      send_ok(thd);
    }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1599 1600
    break;
  }
1601
#ifdef HAVE_REPLICATION
1602 1603
  case COM_REGISTER_SLAVE:
  {
1604
    if (!register_slave(thd, (uchar*)packet, packet_length))
1605
      send_ok(thd);
1606 1607
    break;
  }
1608
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1609
  case COM_TABLE_DUMP:
1610 1611 1612 1613 1614
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
    uint tbl_len= *(uchar*) (packet + db_len + 1);

1615
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1616
    thd->enable_slow_log= opt_log_slow_admin_statements;
1617 1618 1619
    db= thd->alloc(db_len + tbl_len + 2);
    tbl_name= strmake(db, packet + 1, db_len)+1;
    strmake(tbl_name, packet + db_len + 2, tbl_len);
1620
    mysql_table_dump(thd, db, tbl_name, -1);
1621 1622
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1623 1624
  case COM_CHANGE_USER:
  {
1625
    thd->change_user();
1626
    thd->clear_error();                         // if errors from rollback
1627

1628
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1629
    char *user= (char*) packet;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1630
    char *passwd= strend(user)+1;
1631 1632 1633 1634 1635
    /* 
      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).
    */
1636
    char db_buff[NAME_LEN+1];                 // buffer to store db in utf8 
1637 1638 1639 1640
    char *db= passwd;
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ? 
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1641
#ifndef EMBEDDED_LIBRARY
1642
    /* Small check for incoming packet */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1643
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1644
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1645
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1646 1647
      break;
    }
1648
#endif
1649
    /* Convert database name to utf8 */
1650
    uint dummy_errors;
1651 1652
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1653
                             thd->charset(), &dummy_errors)]= 0;
1654
    db= db_buff;
peter@mysql.com's avatar
peter@mysql.com committed
1655

1656 1657 1658
    /* Save user and privileges */
    uint save_db_length= thd->db_length;
    char *save_db= thd->db;
1659
    Security_context save_security_ctx= *thd->security_ctx;
1660
    USER_CONN *save_user_connect= thd->user_connect;
1661 1662

    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
1663
    {
1664
      thd->security_ctx->user= save_security_ctx.user;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1665
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1666 1667
      break;
    }
peter@mysql.com's avatar
peter@mysql.com committed
1668

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

1673 1674
    if (res)
    {
1675
      /* authentication failure, we shall restore old user */
1676
      if (res > 0)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1677
        my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1678 1679
      x_free(thd->security_ctx->user);
      *thd->security_ctx= save_security_ctx;
1680
      thd->user_connect= save_user_connect;
1681 1682 1683 1684 1685 1686
      thd->db= save_db;
      thd->db_length= save_db_length;
    }
    else
    {
      /* we've authenticated new user */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1687 1688
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1689
      x_free((gptr) save_db);
1690
      x_free((gptr)  save_security_ctx.user);
1691
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1692 1693
    break;
  }
1694
  case COM_STMT_EXECUTE:
1695
  {
1696
    mysql_stmt_execute(thd, packet, packet_length);
1697 1698
    break;
  }
1699
  case COM_STMT_FETCH:
1700 1701 1702 1703
  {
    mysql_stmt_fetch(thd, packet, packet_length);
    break;
  }
1704
  case COM_STMT_SEND_LONG_DATA:
1705
  {
1706
    mysql_stmt_get_longdata(thd, packet, packet_length);
1707 1708
    break;
  }
1709
  case COM_STMT_PREPARE:
1710
  {
1711
    mysql_stmt_prepare(thd, packet, packet_length);
1712 1713
    break;
  }
1714
  case COM_STMT_CLOSE:
1715
  {
1716
    mysql_stmt_close(thd, packet);
1717 1718
    break;
  }
1719
  case COM_STMT_RESET:
1720 1721 1722 1723
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1724 1725
  case COM_QUERY:
  {
1726 1727
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1728
    char *packet_end= thd->query + thd->query_length;
1729
    general_log_print(thd, command, "%s", thd->query);
1730
    DBUG_PRINT("query",("%-.4096s",thd->query));
1731 1732 1733 1734

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

1735
    mysql_parse(thd,thd->query, thd->query_length);
1736

1737
    while (!thd->killed && thd->lex->found_semicolon && !thd->net.report_error)
1738
    {
1739
      char *packet= thd->lex->found_semicolon;
1740
      net->no_send_error= 0;
1741
      /*
1742 1743
        Multiple queries exits, execute them individually
      */
1744 1745
      if (thd->lock || thd->open_tables || thd->derived_tables ||
          thd->prelocked_mode)
1746
        close_thread_tables(thd);
1747
      ulong length= (ulong)(packet_end-packet);
1748

1749
      log_slow_statement(thd);
1750

1751
      /* Remove garbage at start of query */
1752
      while (my_isspace(thd->charset(), *packet) && length > 0)
1753 1754 1755 1756
      {
        packet++;
        length--;
      }
monty@mysql.com's avatar
monty@mysql.com committed
1757
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1758
      thd->query_length= length;
1759
      thd->query= packet;
1760
      thd->query_id= next_query_id();
1761
      thd->set_time(); /* Reset the query start time. */
1762
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1763
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1764 1765 1766
      mysql_parse(thd, packet, length);
    }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1767 1768 1769 1770 1771
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1772
  case COM_FIELD_LIST:				// This isn't actually needed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1773
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1774 1775
    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
1776 1777 1778
    break;
#else
  {
1779
    char *fields, *pend;
1780 1781
    /* Locked closure of all tables */
    TABLE_LIST *locked_tables= NULL;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1782
    TABLE_LIST table_list;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1783
    LEX_STRING conv_name;
1784
    /* Saved variable value */
1785 1786 1787
    my_bool old_innodb_table_locks=  thd->variables.innodb_table_locks;


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

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

1792 1793
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1794 1795 1796
    bzero((char*) &table_list,sizeof(table_list));
    if (!(table_list.db=thd->db))
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1797
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1798 1799
      break;
    }
1800
    pend= strend(packet);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1801 1802
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1803
    table_list.alias= table_list.table_name= conv_name.str;
1804
    packet= pend+1;
1805 1806 1807 1808 1809 1810 1811 1812 1813

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

1814
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
1815 1816
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1817
    general_log_print(thd, command, "%s %s", table_list.table_name, fields);
1818
    if (lower_case_table_names)
1819 1820
      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
1821

monty@mysql.com's avatar
monty@mysql.com committed
1822
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
1823
		     0, 0, test(table_list.schema_table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1824
      break;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1825 1826
    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
1827
      break;
1828 1829 1830 1831 1832 1833
    /* 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
1834
    thd->lex->add_to_query_tables(&table_list);
1835

1836 1837
    /* 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
1838
    mysqld_list_fields(thd,&table_list,fields);
1839
    thd->lex->unit.cleanup();
1840
    thd->cleanup_after_query();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1841 1842 1843 1844
    break;
  }
#endif
  case COM_QUIT:
1845
    /* We don't calculate statistics for this command */
1846
    general_log_print(thd, command, NullS);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1847 1848 1849 1850
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

1851
  case COM_CREATE_DB:				// QQ: To be removed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1852
    {
1853
      char *db=thd->strdup(packet), *alias;
1854
      HA_CREATE_INFO create_info;
1855

1856 1857
      statistic_increment(thd->status_var.com_stat[SQLCOM_CREATE_DB],
			  &LOCK_status);
1858
      // null test to handle EOM
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
1859
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1860
      {
1861
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1862 1863
	break;
      }
1864
      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
1865
	break;
1866
      general_log_print(thd, command, packet);
1867
      bzero(&create_info, sizeof(create_info));
1868 1869
      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
1870 1871
      break;
    }
1872
  case COM_DROP_DB:				// QQ: To be removed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1873
    {
1874 1875
      statistic_increment(thd->status_var.com_stat[SQLCOM_DROP_DB],
			  &LOCK_status);
1876
      char *db=thd->strdup(packet);
monty@mysql.com's avatar
monty@mysql.com committed
1877
      /*  null test to handle EOM */
1878
      if (!db || check_db_name(db))
1879
      {
1880
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1881 1882
	break;
      }
1883
      if (check_access(thd,DROP_ACL,db,0,1,0,is_schema_db(db)))
1884
	break;
1885 1886
      if (thd->locked_tables || thd->active_transaction())
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1887 1888
	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
1889
	break;
1890
      }
1891
      general_log_print(thd, command, db);
1892
      mysql_rm_db(thd, db, 0, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1893 1894
      break;
    }
1895
#ifndef EMBEDDED_LIBRARY
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1896 1897
  case COM_BINLOG_DUMP:
    {
monty@mysql.com's avatar
monty@mysql.com committed
1898 1899 1900 1901
      ulong pos;
      ushort flags;
      uint32 slave_server_id;

1902
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1903
      thd->enable_slow_log= opt_log_slow_admin_statements;
1904
      if (check_global_access(thd, REPL_SLAVE_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1905
	break;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1906

1907
      /* TODO: The following has to be changed to an 8 byte integer */
1908 1909
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
1910
      thd->server_id=0; /* avoid suicide */
1911
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
1912
	kill_zombie_dump_threads(slave_server_id);
1913
      thd->server_id = slave_server_id;
monty@mysql.com's avatar
monty@mysql.com committed
1914

1915
      general_log_print(thd, command, "Log: '%s'  Pos: %ld", packet+10,
monty@mysql.com's avatar
monty@mysql.com committed
1916
                      (long) pos);
1917
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
1918
      unregister_slave(thd,1,1);
monty@mysql.com's avatar
monty@mysql.com committed
1919
      /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
1920 1921
      error = TRUE;
      net->error = 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1922 1923
      break;
    }
1924
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1925
  case COM_REFRESH:
1926 1927 1928 1929 1930 1931
  {
    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
1932
      break;
1933
    general_log_print(thd, command, NullS);
1934 1935 1936 1937
    if (!reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, &not_used))
      send_ok(thd);
    break;
  }
1938
#ifndef EMBEDDED_LIBRARY
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1939
  case COM_SHUTDOWN:
1940
  {
1941
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1942
    if (check_global_access(thd,SHUTDOWN_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1943
      break; /* purecov: inspected */
1944
    /*
1945 1946 1947 1948
      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].
1949
    */
1950 1951
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
1952
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1953 1954 1955 1956 1957 1958 1959
    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;
    }
1960
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1961
    general_log_print(thd, command, NullS);
1962
    send_eof(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1963 1964 1965
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1966
#ifndef OS2
1967
    send_eof(thd);				// This is for 'quit request'
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1968
#endif
1969
    close_connection(thd, 0, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1970 1971 1972 1973
    close_thread_tables(thd);			// Free before kill
    kill_mysql();
    error=TRUE;
    break;
1974
  }
1975
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1976 1977
  case COM_STATISTICS:
  {
1978
    general_log_print(thd, command, NullS);
1979 1980
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_STATUS],
			&LOCK_status);
hf@deer.(none)'s avatar
hf@deer.(none) committed
1981
#ifndef EMBEDDED_LIBRARY
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1982
    char buff[200];
hf@deer.(none)'s avatar
hf@deer.(none) committed
1983 1984 1985
#else
    char *buff= thd->net.last_error;
#endif
1986
    ulong uptime = (ulong) (thd->start_time - start_time);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1987
    sprintf((char*) buff,
1988
	    "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
1989
	    uptime,
1990 1991
	    (int) thread_count, (ulong) thd->query_id,
            (ulong) thd->status_var.long_query_count,
1992 1993
	    thd->status_var.opened_tables, refresh_version,
            cached_open_tables(),
1994 1995
	    (uptime ? (ulonglong2double(thd->query_id) / (double) uptime) :
	     (double) 0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1996
#ifdef SAFEMALLOC
1997
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1998
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
1999 2000
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
hf@deer.(none)'s avatar
hf@deer.(none) committed
2001 2002
#endif
#ifndef EMBEDDED_LIBRARY
2003
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2004
    VOID(net_flush(net));
hf@deer.(none)'s avatar
hf@deer.(none) committed
2005
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2006 2007 2008
    break;
  }
  case COM_PING:
2009
    statistic_increment(thd->status_var.com_other, &LOCK_status);
2010
    send_ok(thd);				// Tell client we are alive
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2011 2012
    break;
  case COM_PROCESS_INFO:
2013 2014
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST],
			&LOCK_status);
2015 2016
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd, PROCESS_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2017
      break;
2018
    general_log_print(thd, command, NullS);
hf@deer.(none)'s avatar
hf@deer.(none) committed
2019
    mysqld_list_processes(thd,
2020 2021
			  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
2022 2023 2024
    break;
  case COM_PROCESS_KILL:
  {
2025
    statistic_increment(thd->status_var.com_stat[SQLCOM_KILL], &LOCK_status);
2026
    ulong id=(ulong) uint4korr(packet);
hf@genie.(none)'s avatar
SCRUM  
hf@genie.(none) committed
2027
    kill_one_thread(thd,id,false);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2028 2029
    break;
  }
2030 2031
  case COM_SET_OPTION:
  {
2032 2033
    statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
			&LOCK_status);
2034 2035 2036 2037
    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;
2038
      send_eof(thd);
2039 2040 2041
      break;
    case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
2042
      send_eof(thd);
2043 2044
      break;
    default:
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2045
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
2046 2047 2048 2049
      break;
    }
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2050
  case COM_DEBUG:
2051
    statistic_increment(thd->status_var.com_other, &LOCK_status);
2052
    if (check_global_access(thd, SUPER_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2053
      break;					/* purecov: inspected */
2054
    mysql_print_status();
2055
    general_log_print(thd, command, NullS);
2056
    send_eof(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2057 2058 2059 2060 2061
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
2062
  case COM_END:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2063
  default:
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2064
    my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2065 2066
    break;
  }
2067 2068
  if (thd->lock || thd->open_tables || thd->derived_tables ||
      thd->prelocked_mode)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2069 2070 2071 2072
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }
2073 2074 2075 2076 2077 2078 2079 2080 2081 2082
  /*
    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())
2083
    thd->transaction.xid_state.xid.null();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2084

2085 2086 2087
  /* 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
2088
  if (thd->net.report_error)
2089
    net_send_error(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2090

2091
  log_slow_statement(thd);
2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106

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


2107
void log_slow_statement(THD *thd)
2108
{
2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119
  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;
2120
  thd->end_time();				// Set start time
2121

2122 2123 2124 2125 2126
  /*
    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
2127
  {
2128 2129
    thd->proc_info="logging slow query";

2130 2131
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2132 2133
	((thd->server_status &
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2134
	 (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES)))
2135
    {
2136
      thd->status_var.long_query_count++;
2137
      slow_log_print(thd, thd->query, thd->query_length, start_of_query);
2138
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2139 2140 2141
  }
}

2142

2143 2144 2145 2146 2147
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;
2148
  switch (schema_table_idx) {
2149 2150
  case SCH_SCHEMATA:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2151 2152
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0));   /* purecov: inspected */
2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
    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:
2163
  case SCH_TRIGGERS:
2164
  case SCH_EVENTS:
2165
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2166 2167
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2168 2169 2170 2171 2172 2173
    DBUG_RETURN(1);
#else
    {
      char *db= lex->select_lex.db ? lex->select_lex.db : thd->db;
      if (!db)
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2174 2175
	my_message(ER_NO_DB_ERROR,
                   ER(ER_NO_DB_ERROR), MYF(0)); /* purecov: inspected */
2176 2177 2178 2179 2180
        DBUG_RETURN(1);				/* purecov: inspected */
      }
      remove_escape(db);				// Fix escaped '_'
      if (check_db_name(db))
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2181
        my_error(ER_WRONG_DB_NAME, MYF(0), db);
2182 2183
        DBUG_RETURN(1);
      }
2184 2185
      if (check_access(thd, SELECT_ACL, db, &thd->col_access, 0, 0,
                       is_schema_db(db)))
2186 2187 2188
        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
2189
	my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
2190 2191
                 thd->security_ctx->priv_user, thd->security_ctx->priv_host,
                 db);
2192 2193
	DBUG_RETURN(1);
      }
2194 2195 2196 2197 2198
      /*
        We need to do a copy to make this prepared statement safe if this
        was thd->db
      */
      lex->select_lex.db= thd->strdup(db);
2199 2200 2201 2202 2203 2204
      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
2205 2206
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2207 2208 2209 2210 2211 2212
    DBUG_RETURN(1);
#else
    if (table_ident)
    {
      TABLE_LIST **query_tables_last= lex->query_tables_last;
      sel= new SELECT_LEX();
2213 2214
      /* 'parent_lex' is used in init_query() so it must be before it. */
      sel->parent_lex= lex;
2215
      sel->init_query();
monty@mishka.local's avatar
monty@mishka.local committed
2216
      if (!sel->add_table_to_list(thd, table_ident, 0, 0, TL_READ, 
2217 2218 2219 2220 2221 2222
                                 (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 '_'
2223
      remove_escape(table_list->table_name);
2224
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
2225 2226
                       &table_list->grant.privilege, 0, 0,
                       test(table_list->schema_table)))
2227 2228 2229 2230 2231 2232 2233
        DBUG_RETURN(1);				/* purecov: inspected */
      if (grant_option && check_grant(thd, SELECT_ACL, table_list, 2,
                                      UINT_MAX, 0))
        DBUG_RETURN(1);
      break;
    }
#endif
2234 2235 2236
  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
2237 2238
  case SCH_PROCEDURES:
  case SCH_CHARSETS:
2239
  case SCH_ENGINES:
2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258
  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;
2259
  table_list->schema_table_reformed= 1;
2260 2261
  statistic_increment(thd->status_var.com_stat[lex->orig_sql_command],
                      &LOCK_status);
2262 2263 2264 2265
  DBUG_RETURN(0);
}


2266 2267
/*
  Read query from packet and store in thd->query
2268
  Used in COM_QUERY and COM_STMT_PREPARE
2269 2270 2271 2272 2273 2274 2275

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
2276 2277
    FALSE ok
    TRUE  error;  In this case thd->fatal_error is set
2278 2279
*/

2280
bool alloc_query(THD *thd, const char *packet, uint packet_length)
2281 2282
{
  packet_length--;				// Remove end null
2283
  /* Remove garbage at start and end of query */
2284
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
2285 2286 2287 2288
  {
    packet++;
    packet_length--;
  }
2289
  const char *pos= packet + packet_length;     // Point at end null
peter@mysql.com's avatar
peter@mysql.com committed
2290
  while (packet_length > 0 &&
2291
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
2292 2293 2294 2295 2296
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
monty@mysql.com's avatar
monty@mysql.com committed
2297
  thd->query_length= 0;                        // Extra safety: Avoid races
2298 2299
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
2300 2301
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
2302
    return TRUE;
2303 2304
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
2305 2306 2307 2308

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

2310
  return FALSE;
2311 2312
}

2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328
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;
}

2329

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2330 2331 2332 2333 2334
/****************************************************************************
** mysql_execute_command
** Execute command saved in thd and current_lex->sql_command
****************************************************************************/

2335
bool
2336
mysql_execute_command(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2337
{
2338
  bool	res= FALSE;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2339
  int result= 0;
2340
  LEX	*lex= thd->lex;
monty@mysql.com's avatar
monty@mysql.com committed
2341
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2342
  SELECT_LEX *select_lex= &lex->select_lex;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2343
  /* first table of first SELECT_LEX */
monty@mysql.com's avatar
monty@mysql.com committed
2344
  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
2345 2346 2347
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
2348
  SELECT_LEX_UNIT *unit= &lex->unit;
2349
  /* Saved variable value */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2350
  DBUG_ENTER("mysql_execute_command");
2351
  thd->net.no_send_error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2352

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
  /*
    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();
2369
  /* should be assigned after making first tables same */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2370
  all_tables= lex->query_tables;
2371 2372 2373 2374
  /* 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
2375

2376 2377 2378 2379 2380
  /*
    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.
2381
    Don't reset warnings when executing a stored routine.
2382
  */
2383
  if ((all_tables || &lex->select_lex != lex->all_selects_list ||
2384
       lex->sroutines.records) && !thd->spcont ||
2385
      lex->time_zone_tables_used)
monty@mysql.com's avatar
monty@mysql.com committed
2386
    mysql_reset_errors(thd, 0);
2387

hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
2388
#ifdef HAVE_REPLICATION
2389
  if (unlikely(thd->slave_thread))
2390
  {
peter@mysql.com's avatar
peter@mysql.com committed
2391
    /*
2392 2393
      Check if statment should be skipped because of slave filtering
      rules
2394 2395

      Exceptions are:
2396 2397
      - UPDATE MULTI: For this statement, we want to check the filtering
        rules later in the code
2398
      - SET: we always execute it (Not that many SET commands exists in
lars@mysql.com's avatar
lars@mysql.com committed
2399 2400
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
2401 2402
      - 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
2403
    */
2404 2405
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
	!(lex->sql_command == SQLCOM_SET_OPTION) &&
2406
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2407
          lex->drop_temporary && lex->drop_if_exists) &&
guilhem@mysql.com's avatar
Merge  
guilhem@mysql.com committed
2408
        all_tables_not_ok(thd, all_tables))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2409 2410
    {
      /* we warn the slave SQL thread */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2411
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2412
      reset_one_shot_variables(thd);
2413
      DBUG_RETURN(0);
guilhem@mysql.com's avatar
guilhem@mysql.com committed
2414
    }
2415
  }
2416
  else
2417
#endif /* HAVE_REPLICATION */
2418

2419
  /*
2420 2421
    When option readonly is set deny operations which change non-temporary
    tables. Except for the replication thread and the 'super' users.
2422 2423
  */
  if (opt_readonly &&
2424 2425 2426 2427 2428 2429
      !(thd->security_ctx->master_access & SUPER_ACL) &&
      uc_update_queries[lex->sql_command] &&
      !((lex->sql_command == SQLCOM_CREATE_TABLE) &&
        (lex->create_info.options & HA_LEX_CREATE_TMP_TABLE)) &&
      ((lex->sql_command != SQLCOM_UPDATE_MULTI) &&
       some_non_temp_table_to_be_updated(thd, all_tables)))
2430
  {
2431
    my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
2432
    DBUG_RETURN(-1);
2433
  }
2434 2435 2436
  if(lex->orig_sql_command == SQLCOM_END)
    statistic_increment(thd->status_var.com_stat[lex->sql_command],
                        &LOCK_status);
2437

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2438 2439 2440
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2441 2442 2443 2444
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
2445 2446
	param->select_limit=
          new Item_int((ulonglong)thd->variables.select_limit);
2447 2448
    }

2449
    select_result *result=lex->result;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2450
    if (all_tables)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2451
    {
2452
      if (lex->orig_sql_command != SQLCOM_SHOW_STATUS_PROC &&
2453 2454
          lex->orig_sql_command != SQLCOM_SHOW_STATUS_FUNC &&
          lex->orig_sql_command != SQLCOM_SHOW_EVENTS)
2455 2456 2457 2458
        res= check_table_access(thd,
                                lex->exchange ? SELECT_ACL | FILE_ACL :
                                SELECT_ACL,
                                all_tables, 0);
2459 2460 2461
      else if (lex->orig_sql_command == SQLCOM_SHOW_EVENTS)
        res= check_access(thd, EVENT_ACL, thd->lex->select_lex.db, 0, 0, 0,
                       is_schema_db(thd->lex->select_lex.db));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2462 2463
    }
    else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2464 2465
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
2466
			any_db, 0, 0, 0, 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2467
    if (res)
2468
      goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2469

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2470
    if (!(res= open_and_lock_tables(thd, all_tables)))
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2471
    {
2472
      if (lex->describe)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2473
      {
2474 2475 2476 2477 2478 2479
        /*
          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.
        */
2480
	if (!(result= new select_send()))
2481
	  goto error;
2482 2483
	else
	  thd->send_explain_fields(result);
2484
	res= mysql_explain_union(thd, &thd->lex->unit, result);
2485 2486 2487 2488 2489
	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
2490
	  thd->lex->unit.print(&str);
2491 2492 2493 2494
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2495
	result->send_eof();
2496
        delete result;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2497 2498 2499
      }
      else
      {
2500
	if (!result && !(result= new select_send()))
2501
          goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2502
	query_cache_store_query(thd, all_tables);
2503
	res= handle_select(thd, lex, result, 0);
2504 2505
        if (result != lex->result)
          delete result;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2506
      }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2507
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2508 2509
    break;
  }
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2510
  case SQLCOM_PREPARE:
2511
  {
2512
    mysql_sql_stmt_prepare(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2513 2514 2515 2516
    break;
  }
  case SQLCOM_EXECUTE:
  {
2517
    mysql_sql_stmt_execute(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2518 2519 2520 2521
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2522
    mysql_sql_stmt_close(thd);
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2523 2524
    break;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2525
  case SQLCOM_DO:
2526 2527
    if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
        open_and_lock_tables(thd, all_tables))
2528
      goto error;
2529 2530

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

2533
  case SQLCOM_EMPTY_QUERY:
2534
    send_ok(thd);
2535 2536
    break;

2537 2538 2539 2540
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2541
#ifndef EMBEDDED_LIBRARY
2542
  case SQLCOM_PURGE:
2543
  {
2544
    if (check_global_access(thd, SUPER_ACL))
2545
      goto error;
monty@mysql.com's avatar
monty@mysql.com committed
2546
    /* PURGE MASTER LOGS TO 'file' */
2547 2548 2549
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2550 2551
  case SQLCOM_PURGE_BEFORE:
  {
2552 2553
    Item *it;

2554 2555
    if (check_global_access(thd, SUPER_ACL))
      goto error;
monty@mysql.com's avatar
monty@mysql.com committed
2556
    /* PURGE MASTER LOGS BEFORE 'data' */
2557
    it= (Item *)lex->value_list.head();
2558
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
2559
        it->check_cols(1))
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
    {
      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());
2571 2572
    break;
  }
2573
#endif
2574 2575
  case SQLCOM_SHOW_WARNS:
  {
2576 2577
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2578 2579 2580
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
2581 2582 2583 2584
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2585 2586
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
2587 2588
    break;
  }
2589 2590
  case SQLCOM_SHOW_NEW_MASTER:
  {
2591
    if (check_global_access(thd, REPL_SLAVE_ACL))
2592
      goto error;
2593
    /* This query don't work now. See comment in repl_failsafe.cc */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2594
#ifndef WORKING_NEW_MASTER
2595 2596
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "SHOW NEW MASTER");
    goto error;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2597
#else
2598 2599
    res = show_new_master(thd);
    break;
2600
#endif
2601
  }
2602

2603
#ifdef HAVE_REPLICATION
2604 2605
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
2606
    if (check_global_access(thd, REPL_SLAVE_ACL))
2607 2608 2609 2610
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
2611 2612
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
2613
    if (check_global_access(thd, REPL_SLAVE_ACL))
2614
      goto error;
2615
    res = mysql_show_binlog_events(thd);
2616 2617
    break;
  }
2618 2619
#endif

2620
  case SQLCOM_BACKUP_TABLE:
2621
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2622 2623 2624
    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) ||
2625
	check_global_access(thd, FILE_ACL))
2626
      goto error; /* purecov: inspected */
2627
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2628
    res = mysql_backup_table(thd, first_table);
2629
    select_lex->table_list.first= (byte*) first_table;
2630
    lex->query_tables=all_tables;
2631 2632
    break;
  }
2633
  case SQLCOM_RESTORE_TABLE:
2634
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2635 2636 2637
    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) ||
2638
	check_global_access(thd, FILE_ACL))
2639
      goto error; /* purecov: inspected */
2640
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2641
    res = mysql_restore_table(thd, first_table);
2642
    select_lex->table_list.first= (byte*) first_table;
2643
    lex->query_tables=all_tables;
2644 2645
    break;
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2646 2647
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2648 2649 2650
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
2651 2652
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2653
      goto error;
2654
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2655 2656
    break;
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2657 2658
  case SQLCOM_PRELOAD_KEYS:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2659 2660 2661
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
2662 2663
                     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
2664
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2665
    res = mysql_preload_keys(thd, first_table);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2666 2667
    break;
  }
2668
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2669
  case SQLCOM_CHANGE_MASTER:
2670
  {
2671
    if (check_global_access(thd, SUPER_ACL))
2672
      goto error;
2673
    pthread_mutex_lock(&LOCK_active_mi);
2674
    res = change_master(thd,active_mi);
2675
    pthread_mutex_unlock(&LOCK_active_mi);
2676 2677
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2678
  case SQLCOM_SHOW_SLAVE_STAT:
2679
  {
2680 2681
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2682
      goto error;
2683
    pthread_mutex_lock(&LOCK_active_mi);
2684
    res = show_master_info(thd,active_mi);
2685
    pthread_mutex_unlock(&LOCK_active_mi);
2686 2687
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2688
  case SQLCOM_SHOW_MASTER_STAT:
2689
  {
2690 2691
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2692 2693 2694 2695
      goto error;
    res = show_binlog_info(thd);
    break;
  }
peter@mysql.com's avatar
peter@mysql.com committed
2696

2697
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
2698
    if (check_global_access(thd, SUPER_ACL))
2699
      goto error;
2700
    if (end_active_trans(thd))
2701
      goto error;
2702 2703
    else
      res = load_master_data(thd);
2704
    break;
2705
#endif /* HAVE_REPLICATION */
2706
  case SQLCOM_SHOW_ENGINE_STATUS:
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2707
    {
2708
      if (check_global_access(thd, SUPER_ACL))
2709 2710
        goto error;
      res = ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_STATUS);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2711 2712
      break;
    }
2713
  case SQLCOM_SHOW_ENGINE_MUTEX:
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2714 2715
    {
      if (check_global_access(thd, SUPER_ACL))
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2716
        goto error;
2717
      res = ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_MUTEX);
vtkachenko@intelp4d.mysql.com's avatar
vtkachenko@intelp4d.mysql.com committed
2718 2719
      break;
    }
2720
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2721
  case SQLCOM_LOAD_MASTER_TABLE:
2722
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2723 2724 2725 2726
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (!first_table->db)
      first_table->db= thd->db;
    if (check_access(thd, CREATE_ACL, first_table->db,
2727 2728
		     &first_table->grant.privilege, 0, 0,
                     test(first_table->schema_table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2729 2730 2731 2732
      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
2733
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2734
	goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2735
    }
2736
    if (strlen(first_table->table_name) > NAME_LEN)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2737
    {
2738
      my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2739 2740
      break;
    }
2741
    pthread_mutex_lock(&LOCK_active_mi);
2742 2743 2744 2745
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2746
    if (!fetch_master_table(thd, first_table->db, first_table->table_name,
2747
			    active_mi, 0, 0))
2748
    {
2749
      send_ok(thd);
2750
    }
2751
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2752
    break;
2753
  }
2754
#endif /* HAVE_REPLICATION */
2755

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2756
  case SQLCOM_CREATE_TABLE:
2757
  {
2758
    /* If CREATE TABLE of non-temporary table, do implicit commit */
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
    {
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
    else 
    {
2769 2770
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
2771
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2772 2773 2774 2775 2776
    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
2777

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

2781 2782 2783
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
2784
    /* Fix names if symlinked tables */
2785
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
2786
			   create_table->table_name) ||
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2787
	append_file_to_dir(thd, &lex->create_info.index_file_name,
2788
			   create_table->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
2789
      goto end_with_restore_list;
2790
#endif
2791
    /*
2792
      If we are using SET CHARSET without DEFAULT, add an implicit
2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803
      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;
    }
2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818
    /*
      The create-select command will open and read-lock the select table
      and then create, open and write-lock the new table. If a global
      read lock steps in, we get a deadlock. The write lock waits for
      the global read lock, while the global read lock waits for the
      select table to be closed. So we wait until the global readlock is
      gone before starting both steps. Note that
      wait_if_global_read_lock() sets a protection against a new global
      read lock when it succeeds. This needs to be released by
      start_waiting_global_read_lock(). We protect the normal CREATE
      TABLE in the same way. That way we avoid that a new table is
      created during a gobal read lock.
    */
    if (wait_if_global_read_lock(thd, 0, 1))
    {
monty@mysql.com's avatar
monty@mysql.com committed
2819 2820
      res= 1;
      goto end_with_restore_list;
2821
    }
2822
    if (select_lex->item_list.elements)		// With select
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2823 2824
    {
      select_result *result;
2825

2826
      select_lex->options|= SELECT_NO_UNLOCK;
2827
      unit->set_limit(select_lex);
2828

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2829
      if (!(res= open_and_lock_tables(thd, select_tables)))
2830
      {
2831 2832 2833 2834
        /*
          Is table which we are changing used somewhere in other parts
          of query
        */
2835
        if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
2836
        {
2837
          TABLE_LIST *duplicate;
2838
          if ((duplicate= unique_table(thd, create_table, select_tables)))
2839 2840 2841 2842 2843
          {
            update_non_unique_table_error(create_table, "CREATE", duplicate);
            res= 1;
            goto end_with_restart_wait;
          }
2844
        }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2845 2846 2847 2848 2849 2850 2851 2852
        /* 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)
          {
2853
            TABLE_LIST *duplicate;
2854
            if ((duplicate= unique_table(thd, tab, select_tables)))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2855
            {
2856
              update_non_unique_table_error(tab, "CREATE", duplicate);
monty@mysql.com's avatar
monty@mysql.com committed
2857 2858
              res= 1;
              goto end_with_restart_wait;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2859 2860 2861
            }
          }
        }
2862

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2863 2864 2865 2866 2867
        if ((result= new select_create(create_table,
				       &lex->create_info,
				       lex->create_list,
				       lex->key_list,
				       select_lex->item_list,
2868 2869
				       lex->duplicates,
				       lex->ignore)))
2870 2871 2872 2873 2874
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
2875
          res= handle_select(thd, lex, result, 0);
2876
          delete result;
2877
        }
monty@mysql.com's avatar
monty@mysql.com committed
2878
	/* reset for PS */
2879 2880
	lex->create_list.empty();
	lex->key_list.empty();
2881 2882
      }
    }
monty@mysql.com's avatar
monty@mysql.com committed
2883
    else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2884
    {
monty@mysql.com's avatar
monty@mysql.com committed
2885
      /* regular create */
venu@myvenu.com's avatar
venu@myvenu.com committed
2886
      if (lex->name)
monty@mysql.com's avatar
monty@mysql.com committed
2887
        res= mysql_create_like_table(thd, create_table, &lex->create_info, 
venu@myvenu.com's avatar
venu@myvenu.com committed
2888 2889
                                     (Table_ident *)lex->name); 
      else
2890
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2891
        res= mysql_create_table(thd, create_table->db,
2892
				create_table->table_name, &lex->create_info,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2893
				lex->create_list,
monty@mysql.com's avatar
monty@mysql.com committed
2894
				lex->key_list, 0, 0);
2895
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2896
      if (!res)
2897
	send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2898
    }
2899

monty@mysql.com's avatar
monty@mysql.com committed
2900
end_with_restart_wait:
2901 2902 2903 2904 2905 2906
    /*
      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);

monty@mysql.com's avatar
monty@mysql.com committed
2907
    /* put tables back for PS rexecuting */
monty@mysql.com's avatar
monty@mysql.com committed
2908
end_with_restore_list:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2909
    lex->link_first_table_back(create_table, link_to_local);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2910
    break;
2911
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2912
  case SQLCOM_CREATE_INDEX:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2913 2914
    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
2915
      goto error; /* purecov: inspected */
2916
    thd->enable_slow_log= opt_log_slow_admin_statements;
2917
    if (end_active_trans(thd))
2918
      goto error;
2919
    else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2920
      res = mysql_create_index(thd, first_table, lex->key_list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2921 2922
    break;

2923
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2924
  case SQLCOM_SLAVE_START:
2925
  {
2926
    pthread_mutex_lock(&LOCK_active_mi);
2927
    start_slave(thd,active_mi,1 /* net report*/);
2928
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2929
    break;
2930
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2931
  case SQLCOM_SLAVE_STOP:
2932 2933 2934 2935 2936 2937
  /*
    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,
2938
      so it waits for the client thread because t is locked by it.
2939
    - then the client thread does SLAVE STOP.
2940 2941
      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.
2942 2943 2944
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
2945
  if (thd->locked_tables || thd->active_transaction() || thd->global_read_lock)
2946
  {
2947 2948
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
2949
    goto error;
2950
  }
2951
  {
2952
    pthread_mutex_lock(&LOCK_active_mi);
2953
    stop_slave(thd,active_mi,1/* net report*/);
2954
    pthread_mutex_unlock(&LOCK_active_mi);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2955
    break;
2956
  }
2957
#endif /* HAVE_REPLICATION */
2958

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2959
  case SQLCOM_ALTER_TABLE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2960
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2961
#if defined(DONT_ALLOW_SHOW_COMMANDS)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2962 2963
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
2964
    goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2965 2966
#else
    {
2967
      ulong priv=0;
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
2968
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2969
      {
2970
	my_error(ER_WRONG_TABLE_NAME, MYF(0), lex->name);
2971
        goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2972
      }
2973
      if (!select_lex->db)
2974 2975 2976 2977 2978 2979 2980 2981 2982 2983
      {
        /*
          In the case of ALTER TABLE ... RENAME we should supply the
          default database if the new name is not explicitly qualified
          by a database. (Bug #11493)
        */
        if (lex->alter_info.flags & ALTER_RENAME)
        {
          if (! thd->db)
          {
ingo@mysql.com's avatar
ingo@mysql.com committed
2984
            my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
2985 2986 2987 2988 2989
            goto error;
          }
          select_lex->db= thd->db;
        }
        else
2990
          select_lex->db= first_table->db;
2991
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
2992
      if (check_access(thd, ALTER_ACL, first_table->db,
2993 2994 2995 2996
		       &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
2997
	  check_merge_table_access(thd, first_table->db,
2998 2999 3000
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3001 3002
      if (grant_option)
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3003
	if (check_grant(thd, ALTER_ACL, all_tables, 0, UINT_MAX, 0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3004 3005 3006 3007 3008
	  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));
3009
	  tmp_table.table_name=lex->name;
3010
	  tmp_table.db=select_lex->db;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3011
	  tmp_table.grant.privilege=priv;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3012 3013
	  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
3014 3015 3016
	    goto error;
	}
      }
3017 3018
      /* Don't yet allow changing of symlinks with ALTER TABLE */
      lex->create_info.data_file_name=lex->create_info.index_file_name=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3019
      /* ALTER TABLE ends previous transaction */
3020
      if (end_active_trans(thd))
3021
	goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3022
      else
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3023
      {
3024
        thd->enable_slow_log= opt_log_slow_admin_statements;
3025
	res= mysql_alter_table(thd, select_lex->db, lex->name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3026
			       &lex->create_info,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3027
			       first_table, lex->create_list,
3028
			       lex->key_list,
3029
			       select_lex->order_list.elements,
3030
                               (ORDER *) select_lex->order_list.first,
monty@mysql.com's avatar
monty@mysql.com committed
3031 3032
			       lex->duplicates, lex->ignore, &lex->alter_info,
                               1);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3033
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3034 3035
      break;
    }
hf@deer.(none)'s avatar
hf@deer.(none) committed
3036
#endif /*DONT_ALLOW_SHOW_COMMANDS*/
3037
  case SQLCOM_RENAME_TABLE:
3038
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3039
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3040
    TABLE_LIST *table;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3041
    if (check_db_used(thd, all_tables))
3042
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3043
    for (table= first_table; table; table= table->next_local->next_local)
3044
    {
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3045
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
3046
		       &table->grant.privilege,0,0, test(table->schema_table)) ||
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3047
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next_local->db,
3048 3049
		       &table->next_local->grant.privilege, 0, 0,
                       test(table->next_local->schema_table)))
3050 3051 3052
	goto error;
      if (grant_option)
      {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3053
	TABLE_LIST old_list, new_list;
3054 3055 3056 3057
	/*
	  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
3058 3059 3060 3061
	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,
3062
			    INSERT_ACL | CREATE_ACL) &&
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3063
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0, 1, 0)))
3064 3065 3066
	  goto error;
      }
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3067
    query_cache_invalidate3(thd, first_table, 0);
3068 3069
    if (end_active_trans(thd) || mysql_rename_tables(thd, first_table))
      goto error;
3070
    break;
3071
  }
3072
#ifndef EMBEDDED_LIBRARY
3073 3074
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3075 3076
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3077
    goto error;
3078 3079
#else
    {
3080
      if (check_global_access(thd, SUPER_ACL))
3081 3082 3083 3084
	goto error;
      res = show_binlogs(thd);
      break;
    }
peter@mysql.com's avatar
peter@mysql.com committed
3085
#endif
3086
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3087
  case SQLCOM_SHOW_CREATE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3088
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3089
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3090 3091
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3092
    goto error;
3093
#else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3094
    {
3095 3096 3097 3098
      /* 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
3099 3100
      if (check_db_used(thd, all_tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, first_table->db,
3101 3102
		       &first_table->grant.privilege, 0, 0, 
                       test(first_table->schema_table)))
3103
	goto error;
monty@mishka.local's avatar
monty@mishka.local committed
3104
      if (grant_option && check_grant(thd, SELECT_ACL, all_tables, 2, UINT_MAX, 0))
3105
	goto error;
monty@mishka.local's avatar
monty@mishka.local committed
3106
      res= mysqld_show_create(thd, first_table);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3107 3108
      break;
    }
3109
#endif
3110 3111
  case SQLCOM_CHECKSUM:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3112 3113 3114
    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))
3115
      goto error; /* purecov: inspected */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3116
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
3117 3118
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3119
  case SQLCOM_REPAIR:
3120
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3121 3122 3123
    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))
3124
      goto error; /* purecov: inspected */
3125
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3126
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
3127 3128 3129 3130 3131
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
3132
	thd->clear_error(); // No binlog error generated
3133
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3134 3135 3136
        mysql_bin_log.write(&qinfo);
      }
    }
3137
    select_lex->table_list.first= (byte*) first_table;
3138
    lex->query_tables=all_tables;
3139 3140
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3141
  case SQLCOM_CHECK:
3142
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3143 3144 3145
    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))
3146
      goto error; /* purecov: inspected */
3147
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3148
    res = mysql_check_table(thd, first_table, &lex->check_opt);
3149
    select_lex->table_list.first= (byte*) first_table;
3150
    lex->query_tables=all_tables;
3151 3152
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3153 3154
  case SQLCOM_ANALYZE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3155 3156 3157
    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
3158
      goto error; /* purecov: inspected */
3159
    thd->enable_slow_log= opt_log_slow_admin_statements;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3160
    res = mysql_analyze_table(thd, first_table, &lex->check_opt);
3161 3162 3163 3164 3165
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
3166
	thd->clear_error(); // No binlog error generated
3167
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3168 3169 3170
        mysql_bin_log.write(&qinfo);
      }
    }
3171
    select_lex->table_list.first= (byte*) first_table;
3172
    lex->query_tables=all_tables;
3173
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3174
  }
3175

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3176 3177
  case SQLCOM_OPTIMIZE:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3178 3179 3180
    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
3181
      goto error; /* purecov: inspected */
3182
    thd->enable_slow_log= opt_log_slow_admin_statements;
3183
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3184 3185
      mysql_recreate_table(thd, first_table, 1) :
      mysql_optimize_table(thd, first_table, &lex->check_opt);
3186 3187 3188 3189 3190
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
3191
	thd->clear_error(); // No binlog error generated
3192
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3193 3194 3195
        mysql_bin_log.write(&qinfo);
      }
    }
3196
    select_lex->table_list.first= (byte*) first_table;
3197
    lex->query_tables=all_tables;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3198 3199 3200
    break;
  }
  case SQLCOM_UPDATE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3201 3202
    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
3203
      break;
3204 3205
    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
3206 3207 3208 3209 3210 3211
    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,
3212
                               unit->select_limit_cnt,
3213
                               lex->duplicates, lex->ignore));
3214
    /* 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
3215
    if (result != 2)
3216
      break;
3217
  case SQLCOM_UPDATE_MULTI:
3218 3219 3220 3221
  {
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    /* if we switched from normal update, rights are checked */
    if (result != 2)
3222
    {
3223 3224 3225 3226 3227
      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
3228

3229 3230
    if ((res= mysql_multi_update_prepare(thd)))
      break;
3231

3232
#ifdef HAVE_REPLICATION
3233
    /* Check slave filtering rules */
3234
    if (unlikely(thd->slave_thread))
3235
    {
3236 3237 3238 3239 3240 3241
      if (all_tables_not_ok(thd, all_tables))
      {
        /* we warn the slave SQL thread */
        my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
        break;
      }
3242
    }
3243
    else
3244
#endif /* HAVE_REPLICATION */
3245 3246 3247 3248 3249 3250 3251
    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;
    }
3252

3253 3254 3255 3256 3257 3258
    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
3259
    break;
monty@mysql.com's avatar
monty@mysql.com committed
3260
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3261
  case SQLCOM_REPLACE:
3262 3263
  case SQLCOM_INSERT:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3264
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
monty@mysql.com's avatar
monty@mysql.com committed
3265
    if ((res= insert_precheck(thd, all_tables)))
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3266
      break;
3267 3268
    /* Skip first table, which is the table we are inserting in */
    select_lex->context.table_list= first_table->next_local;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3269
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
monty@mishka.local's avatar
monty@mishka.local committed
3270
		      lex->update_list, lex->value_list,
3271
                      lex->duplicates, lex->ignore);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3272 3273
    if (first_table->view && !first_table->contain_auto_increment)
      thd->last_insert_id= 0; // do not show last insert ID if VIEW have not it
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3274
    break;
3275
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3276 3277 3278
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
monty@mysql.com's avatar
monty@mysql.com committed
3279
    select_result *result;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3280
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
monty@mishka.local's avatar
monty@mishka.local committed
3281
    if ((res= insert_precheck(thd, all_tables)))
3282
      break;
monty@mysql.com's avatar
monty@mysql.com committed
3283

3284
    /* Fix lock for first table */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3285 3286
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
3287

3288 3289
    /* 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
3290

3291
    unit->set_limit(select_lex);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3292
    if (!(res= open_and_lock_tables(thd, all_tables)))
3293
    {
3294
      /* Skip first table, which is the table we are inserting in */
3295 3296
      TABLE_LIST *second_table= first_table->next_local;
      select_lex->table_list.first= (byte*) second_table;
3297 3298
      select_lex->context.table_list= 
        select_lex->context.first_name_resolution_table= second_table;
3299 3300 3301
      res= mysql_insert_select_prepare(thd);
      if (!res && (result= new select_insert(first_table, first_table->table,
                                             &lex->field_list,
3302 3303
                                             &lex->update_list,
                                             &lex->value_list,
3304
                                             lex->duplicates, lex->ignore)))
3305
      {
3306 3307 3308 3309 3310 3311 3312
        /*
          Skip first table, which is the table we are inserting in.
          Below we set context.table_list again because the call above to
          mysql_insert_select_prepare() calls resolve_in_table_list_only(),
          which in turn resets context.table_list and
          context.first_name_resolution_table.
        */
3313 3314
        select_lex->context.table_list= 
          select_lex->context.first_name_resolution_table= second_table;
3315
	res= handle_select(thd, lex, result, OPTION_SETUP_TABLES_DONE);
3316 3317
        delete result;
      }
3318
      /* revert changes for SP */
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
3319
      select_lex->table_list.first= (byte*) first_table;
3320
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3321 3322 3323

    if (first_table->view && !first_table->contain_auto_increment)
      thd->last_insert_id= 0; // do not show last insert ID if VIEW have not it
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3324 3325
    break;
  }
3326
  case SQLCOM_TRUNCATE:
3327 3328 3329 3330 3331
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3332 3333
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
3334
      goto error;
3335 3336 3337 3338
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
3339
    if ((thd->locked_tables && !lex->sphead) || thd->active_transaction())
3340
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3341 3342
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3343 3344
      goto error;
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3345

monty@mysql.com's avatar
monty@mysql.com committed
3346
    res= mysql_truncate(thd, first_table, 0);
3347
    break;
3348
  case SQLCOM_DELETE:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3349
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3350 3351
    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
3352
      break;
3353 3354
    DBUG_ASSERT(select_lex->offset_limit == 0);
    unit->set_limit(select_lex);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3355
    res = mysql_delete(thd, all_tables, select_lex->where,
3356
                       &select_lex->order_list,
osku@127.(none)'s avatar
osku@127.(none) committed
3357 3358
                       unit->select_limit_cnt, select_lex->options,
                       FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3359 3360
    break;
  }
3361
  case SQLCOM_DELETE_MULTI:
3362
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3363
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3364 3365
    TABLE_LIST *aux_tables=
      (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
3366
    multi_delete *result;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3367

3368
    if ((res= multi_delete_precheck(thd, all_tables)))
3369
      break;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3370

3371
    /* condition will be TRUE on SP re-excuting */
3372 3373
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3374
    if (add_item_to_list(thd, new Item_null()))
3375
      goto error;
3376

3377
    thd->proc_info="init";
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3378 3379 3380 3381
    if ((res= open_and_lock_tables(thd, all_tables)))
      break;

    if ((res= mysql_multi_delete_prepare(thd)))
3382
      goto error;
3383

3384
    if (!thd->is_fatal_error && (result= new multi_delete(aux_tables,
3385
							  lex->table_count)))
3386
    {
3387 3388 3389
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3390
			select_lex->item_list,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3391
			select_lex->where,
3392
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3393 3394
			(ORDER *)NULL,
			select_lex->options | thd->options |
3395 3396
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                        OPTION_SETUP_TABLES_DONE,
3397
			result, unit, select_lex);
3398
      delete result;
3399 3400
    }
    else
3401
      res= TRUE;                                // Error
3402 3403
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3404
  case SQLCOM_DROP_TABLE:
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
3405
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3406
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3407 3408
    if (!lex->drop_temporary)
    {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3409
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
3410 3411
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
3412
        goto error;
3413
    }
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
3414
    else
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3415 3416 3417 3418 3419 3420
    {
      /*
	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
3421 3422
	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
3423 3424 3425
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
3426

3427 3428
      /* 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
3429
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3430 3431
    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
3432 3433
  }
  break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3434
  case SQLCOM_DROP_INDEX:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3435 3436
    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
3437
      goto error;				/* purecov: inspected */
3438
    if (end_active_trans(thd))
3439
      goto error;
3440
    else
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3441
      res = mysql_drop_index(thd, first_table, &lex->alter_info);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3442 3443
    break;
  case SQLCOM_SHOW_PROCESSLIST:
3444 3445
    if (!thd->security_ctx->priv_user[0] &&
        check_global_access(thd,PROCESS_ACL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3446
      break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
3447
    mysqld_list_processes(thd,
3448 3449 3450 3451
			  (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
3452
    break;
3453 3454
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
3455
    break;
brian@grrr.local's avatar
brian@grrr.local committed
3456 3457 3458
  case SQLCOM_SHOW_AUTHORS:
    res= mysqld_show_authors(thd);
    break;
3459 3460 3461 3462 3463 3464
  case SQLCOM_SHOW_PRIVILEGES:
    res= mysqld_show_privileges(thd);
    break;
  case SQLCOM_SHOW_COLUMN_TYPES:
    res= mysqld_show_column_types(thd);
    break;
3465
  case SQLCOM_SHOW_ENGINE_LOGS:
tim@cane.mysql.fi's avatar
tim@cane.mysql.fi committed
3466
#ifdef DONT_ALLOW_SHOW_COMMANDS
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3467 3468
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
3469
    goto error;
tim@cane.mysql.fi's avatar
tim@cane.mysql.fi committed
3470 3471
#else
    {
3472
      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
3473
	goto error;
3474
      res= ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_LOGS);
tim@cane.mysql.fi's avatar
tim@cane.mysql.fi committed
3475 3476
      break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3477 3478
#endif
  case SQLCOM_CHANGE_DB:
3479 3480
    if (!mysql_change_db(thd,select_lex->db,FALSE))
      send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3481
    break;
3482

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3483 3484
  case SQLCOM_LOAD:
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3485
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3486
    uint privilege= (lex->duplicates == DUP_REPLACE ?
3487 3488
		     INSERT_ACL | DELETE_ACL : INSERT_ACL) |
                    (lex->local_file ? 0 : FILE_ACL);
3489

3490
    if (lex->local_file)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3491
    {
3492
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
3493
          !opt_local_infile)
3494
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3495
	my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
3496 3497
	goto error;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3498
    }
3499 3500 3501 3502

    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
3503
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
3504
                    lex->update_list, lex->value_list, lex->duplicates,
3505
                    lex->ignore, (bool) lex->local_file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3506 3507
    break;
  }
3508

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3509
  case SQLCOM_SET_OPTION:
3510 3511
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
3512
    if ((check_table_access(thd, SELECT_ACL, all_tables, 0) ||
3513 3514
	 open_and_lock_tables(thd, all_tables)))
      goto error;
3515 3516
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
3517 3518
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
      goto error;
3519 3520 3521 3522 3523 3524 3525 3526
    }
    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;
3527
      send_ok(thd);
3528
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3529
    break;
3530
  }
3531

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3532
  case SQLCOM_UNLOCK_TABLES:
3533 3534 3535 3536 3537 3538
    /*
      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.
    */
3539
    unlock_locked_tables(thd);
3540 3541
    if (thd->options & OPTION_TABLE_LOCK)
    {
3542
      end_active_trans(thd);
3543
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3544 3545
    }
    if (thd->global_read_lock)
3546
      unlock_global_read_lock(thd);
3547
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3548 3549
    break;
  case SQLCOM_LOCK_TABLES:
3550
    unlock_locked_tables(thd);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3551
    if (check_db_used(thd, all_tables) || end_active_trans(thd))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3552
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3553
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3554
      goto error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3555
    thd->in_lock_tables=1;
3556
    thd->options|= OPTION_TABLE_LOCK;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3557

3558
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3559
    {
3560 3561
#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
3562
	query_cache.invalidate_locked_for_write(first_table);
3563
#endif /*HAVE_QUERY_CACHE*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3564 3565
      thd->locked_tables=thd->lock;
      thd->lock=0;
3566
      send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3567
    }
3568 3569
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3570 3571 3572
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3573
  {
3574 3575 3576 3577 3578
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3579
    char *alias;
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
3580
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3581
    {
3582
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3583 3584
      break;
    }
3585 3586 3587
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
3588
      For that reason, db_ok() in sql/slave.cc did not check the
3589 3590 3591
      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.
    */
3592
#ifdef HAVE_REPLICATION
3593 3594 3595
    if (thd->slave_thread && 
	(!rpl_filter->db_ok(lex->name) ||
	 !rpl_filter->db_ok_with_wild_table(lex->name)))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3596
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3597
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3598
      break;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3599
    }
3600
#endif
3601
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3602
      break;
monty@mysql.com's avatar
monty@mysql.com committed
3603
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
monty@mysql.com's avatar
monty@mysql.com committed
3604
			 &lex->create_info, 0);
3605 3606
    break;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3607
  case SQLCOM_DROP_DB:
3608
  {
3609 3610 3611 3612 3613
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
3614
    if (check_db_name(lex->name))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3615
    {
3616
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3617 3618
      break;
    }
3619 3620 3621 3622 3623 3624 3625
    /*
      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.
    */
3626
#ifdef HAVE_REPLICATION
3627
    if (thd->slave_thread && 
3628 3629
	(!rpl_filter->db_ok(lex->name) ||
	 !rpl_filter->db_ok_with_wild_table(lex->name)))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3630
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3631
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3632
      break;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3633
    }
3634
#endif
3635
    if (check_access(thd,DROP_ACL,lex->name,0,1,0,is_schema_db(lex->name)))
3636
      break;
3637 3638
    if (thd->locked_tables || thd->active_transaction())
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3639 3640
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3641 3642
      goto error;
    }
3643
    res= mysql_rm_db(thd, lex->name, lex->drop_if_exists, 0);
3644 3645
    break;
  }
3646 3647
  case SQLCOM_ALTER_DB:
  {
3648 3649
    char *db= lex->name ? lex->name : thd->db;
    if (!db)
3650
    {
monty@mishka.local's avatar
monty@mishka.local committed
3651 3652
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      break;
3653 3654
    }
    if (!strip_sp(db) || check_db_name(db))
3655
    {
3656
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
3657 3658
      break;
    }
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3659 3660 3661
    /*
      If in a slave thread :
      ALTER DATABASE DB may not be preceded by USE DB.
3662
      For that reason, maybe db_ok() in sql/slave.cc did not check the
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3663 3664 3665 3666
      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
3667
    if (thd->slave_thread &&
3668 3669
	(!rpl_filter->db_ok(lex->name) ||
	 !rpl_filter->db_ok_with_wild_table(lex->name)))
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3670
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3671
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3672 3673 3674
      break;
    }
#endif
3675
    if (check_access(thd, ALTER_ACL, db, 0, 1, 0, is_schema_db(db)))
3676 3677 3678
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3679 3680
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3681 3682
      goto error;
    }
3683
    res= mysql_alter_db(thd, db, &lex->create_info);
3684 3685
    break;
  }
3686 3687 3688 3689
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3690
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
3691 3692
      break;
    }
3693
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
3694 3695
    break;
  }
3696 3697
  case SQLCOM_CREATE_EVENT:
  case SQLCOM_ALTER_EVENT:
3698
  case SQLCOM_DROP_EVENT:
3699
  {
andrey@lmy004's avatar
andrey@lmy004 committed
3700
    uint rows_affected= 1;
3701
    DBUG_ASSERT(lex->et);
3702 3703 3704 3705 3706 3707 3708
    do {
      if (! lex->et->dbname.str)
      {
        my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
        res= true;
        break;
      }
andrey@lmy004's avatar
andrey@lmy004 committed
3709

3710 3711 3712
      if (check_access(thd, EVENT_ACL, lex->et->dbname.str, 0, 0, 0,
                       is_schema_db(lex->et->dbname.str)))
        break;
andrey@lmy004's avatar
andrey@lmy004 committed
3713

3714 3715
      switch (lex->sql_command) {
      case SQLCOM_CREATE_EVENT:
andrey@lmy004's avatar
andrey@lmy004 committed
3716 3717
        res= evex_create_event(thd, lex->et, (uint) lex->create_info.options,
                               &rows_affected);
3718 3719
        break;
      case SQLCOM_ALTER_EVENT:
andrey@lmy004's avatar
andrey@lmy004 committed
3720
        res= evex_update_event(thd, lex->et, lex->spname, &rows_affected);
3721 3722
        break;
      case SQLCOM_DROP_EVENT:
andrey@lmy004's avatar
andrey@lmy004 committed
3723
        res= evex_drop_event(thd, lex->et, lex->drop_if_exists, &rows_affected);
3724 3725 3726
      default:;
      }
      if (!res)
andrey@lmy004's avatar
andrey@lmy004 committed
3727
        send_ok(thd, rows_affected);
3728

3729 3730
      /* lex->unit.cleanup() is called outside, no need to call it here */
    } while (0);  
andrey@lmy004's avatar
andrey@lmy004 committed
3731
    lex->et->free_sphead_on_delete= true;
3732 3733 3734 3735 3736 3737
    delete lex->et;
    lex->et= 0;
    break;
  }
  case SQLCOM_SHOW_CREATE_EVENT:
  {
andrey@lmy004's avatar
andrey@lmy004 committed
3738 3739
    if (check_access(thd, EVENT_ACL, lex->spname->m_db.str, 0, 0, 0,
                     is_schema_db(lex->spname->m_db.str)))
3740 3741 3742 3743 3744 3745 3746
      break;

    if (lex->spname->m_name.length > NAME_LEN)
    {
      my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
      goto error;
    }
andrey@lmy004's avatar
andrey@lmy004 committed
3747
    /* TODO : Implement it */
3748 3749 3750
    send_ok(thd, 1);
    break;
  }
monty@mysql.com's avatar
monty@mysql.com committed
3751
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
monty@mysql.com's avatar
monty@mysql.com committed
3752
  {
3753
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0))
monty@mysql.com's avatar
monty@mysql.com committed
3754
      break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3755
#ifdef HAVE_DLOPEN
3756 3757
    if (sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                        &thd->sp_func_cache, FALSE))
monty@mysql.com's avatar
monty@mysql.com committed
3758
    {
3759
      my_error(ER_UDF_EXISTS, MYF(0), lex->spname->m_name.str);
monty@mysql.com's avatar
monty@mysql.com committed
3760 3761
      goto error;
    }
3762
    if (!(res = mysql_create_function(thd, &lex->udf)))
monty@mysql.com's avatar
monty@mysql.com committed
3763
      send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3764
#else
hf@deer.(none)'s avatar
hf@deer.(none) committed
3765
    my_error(ER_CANT_OPEN_LIBRARY, MYF(0), lex->udf.dl, 0, "feature disabled");
3766
    res= TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3767 3768
#endif
    break;
monty@mysql.com's avatar
monty@mysql.com committed
3769
  }
hf@deer.(none)'s avatar
hf@deer.(none) committed
3770
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3771 3772
  case SQLCOM_CREATE_USER:
  {
3773
    if (check_access(thd, INSERT_ACL, "mysql", 0, 1, 1, 0) &&
3774
        check_global_access(thd,CREATE_USER_ACL))
3775
      break;
3776 3777
    if (end_active_trans(thd))
      goto error;
3778 3779 3780 3781
    if (!(res= mysql_create_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3782 3783
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3784 3785 3786 3787 3788
      }
      send_ok(thd);
    }
    break;
  }
3789 3790
  case SQLCOM_DROP_USER:
  {
3791
    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 1, 0) &&
3792
        check_global_access(thd,CREATE_USER_ACL))
3793
      break;
3794 3795
    if (end_active_trans(thd))
      goto error;
3796 3797 3798 3799
    if (!(res= mysql_drop_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3800 3801
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3802 3803 3804 3805 3806 3807 3808
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_RENAME_USER:
  {
3809
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
3810
        check_global_access(thd,CREATE_USER_ACL))
3811
      break;
3812 3813
    if (end_active_trans(thd))
      goto error;
3814 3815 3816 3817
    if (!(res= mysql_rename_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3818 3819
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3820 3821 3822 3823 3824 3825 3826
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
3827
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1, 0) &&
3828
        check_global_access(thd,CREATE_USER_ACL))
3829 3830 3831 3832 3833
      break;
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3834 3835
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3836 3837 3838 3839 3840
      }
      send_ok(thd);
    }
    break;
  }
3841 3842 3843 3844
  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
3845
		     first_table ?  first_table->db : select_lex->db,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3846
		     first_table ? &first_table->grant.privilege : 0,
3847 3848 3849
		     first_table ? 0 : 1, 0,
                     first_table ? (bool) first_table->schema_table :
                     select_lex->db ? is_schema_db(select_lex->db) : 0))
3850 3851
      goto error;

3852
    if (thd->security_ctx->user)              // If not replication
3853 3854
    {
      LEX_USER *user;
3855 3856
      uint counter;

3857
      List_iterator <LEX_USER> user_list(lex->users_list);
3858
      while ((user= user_list++))
3859
      {
3860 3861 3862 3863 3864 3865 3866 3867
        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);
3868
        if (strcmp(thd->security_ctx->user, user->user.str) ||
3869
            my_strcasecmp(system_charset_info,
3870
                          user->host.str, thd->security_ctx->host_or_ip))
3871 3872 3873
        {
          // TODO: use check_change_password()
          if (check_acl_user(user, &counter) && user->password.str &&
3874
              check_access(thd, UPDATE_ACL,"mysql",0,1,1,0))
3875 3876 3877 3878 3879 3880
          {
            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
3881 3882
      }
    }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3883
    if (first_table)
3884
    {
3885 3886
      if (lex->type == TYPE_ENUM_PROCEDURE ||
          lex->type == TYPE_ENUM_FUNCTION)
3887 3888 3889 3890 3891
      {
        uint grants= lex->all_privileges 
		   ? (PROC_ACLS & ~GRANT_ACL) | (lex->grant & GRANT_ACL)
		   : lex->grant;
        if (grant_option && 
3892 3893
	    check_grant_routine(thd, grants | GRANT_ACL, all_tables,
                                lex->type == TYPE_ENUM_PROCEDURE, 0))
3894
	  goto error;
3895 3896 3897 3898
        res= mysql_routine_grant(thd, all_tables,
                                 lex->type == TYPE_ENUM_PROCEDURE, 
                                 lex->users_list, grants,
                                 lex->sql_command == SQLCOM_REVOKE, 0);
3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911
      }
      else
      {
	if (grant_option && check_grant(thd,
					(lex->grant | lex->grant_tot_col |
					 GRANT_ACL),
					all_tables, 0, UINT_MAX, 0))
	  goto error;
        res= mysql_table_grant(thd, all_tables, lex->users_list,
			       lex->columns, lex->grant,
			       lex->sql_command == SQLCOM_REVOKE);
      }
      if (!res && mysql_bin_log.is_open())
3912
      {
pem@mysql.com's avatar
pem@mysql.com committed
3913
        thd->clear_error();
3914 3915
        thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
3916 3917 3918 3919
      }
    }
    else
    {
3920
      if (lex->columns.elements || lex->type)
3921
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3922 3923
	my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE),
                   MYF(0));
3924
        goto error;
3925 3926 3927 3928 3929 3930 3931 3932
      }
      else
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
	if (mysql_bin_log.is_open())
	{
guilhem@mysql.com's avatar
guilhem@mysql.com committed
3933
          thd->clear_error();
3934 3935
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
3936
	}
3937
	if (lex->sql_command == SQLCOM_GRANT)
3938
	{
3939 3940 3941
	  List_iterator <LEX_USER> str_list(lex->users_list);
	  LEX_USER *user;
	  while ((user=str_list++))
monty@mysql.com's avatar
monty@mysql.com committed
3942
	    reset_mqh(user);
3943
	}
3944 3945 3946 3947
      }
    }
    break;
  }
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
3948
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
3949
  case SQLCOM_RESET:
3950 3951 3952
    /*
      RESET commands are never written to the binary log, so we have to
      initialize this variable because RESET shares the same code as FLUSH
3953 3954 3955 3956
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
3957
    bool write_to_binlog;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3958
    if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, all_tables))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3959
      goto error;
3960 3961 3962 3963
    /*
      reload_acl_and_cache() will tell us if we are allowed to write to the
      binlog or not.
    */
3964
    if (!reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
3965 3966 3967 3968 3969 3970 3971 3972 3973
    {
      /*
        We WANT to write and we CAN write.
        ! we write after unlocking the table.
      */
      if (!lex->no_write_to_binlog && write_to_binlog)
      {
        if (mysql_bin_log.is_open())
        {
3974
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3975 3976 3977 3978 3979
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3980
    break;
3981
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3982
  case SQLCOM_KILL:
3983 3984 3985
  {
    Item *it= (Item *)lex->value_list.head();

3986
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) || it->check_cols(1))
3987 3988 3989 3990 3991 3992
    {
      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
3993
    break;
3994
  }
hf@deer.(none)'s avatar
hf@deer.(none) committed
3995
#ifndef NO_EMBEDDED_ACCESS_CHECKS
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3996
  case SQLCOM_SHOW_GRANTS:
3997 3998
    if ((thd->security_ctx->priv_user &&
	 !strcmp(thd->security_ctx->priv_user, lex->grant_user->user.str)) ||
3999
	!check_access(thd, SELECT_ACL, "mysql",0,1,0,0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4000 4001 4002 4003
    {
      res = mysql_show_grants(thd,lex->grant_user);
    }
    break;
hf@deer.(none)'s avatar
hf@deer.(none) committed
4004
#endif
4005
  case SQLCOM_HA_OPEN:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4006 4007 4008
    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))
4009
      goto error;
monty@mysql.com's avatar
monty@mysql.com committed
4010
    res= mysql_ha_open(thd, first_table, 0);
4011 4012
    break;
  case SQLCOM_HA_CLOSE:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4013 4014
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables))
4015
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4016
    res= mysql_ha_close(thd, first_table);
4017 4018
    break;
  case SQLCOM_HA_READ:
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4019
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
4020 4021 4022 4023 4024
    /*
      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
4025
    if (check_db_used(thd, all_tables))
4026
      goto error;
4027
    unit->set_limit(select_lex);
4028
    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
4029
                       lex->insert_list, lex->ha_rkey_mode, select_lex->where,
4030
                       unit->select_limit_cnt, unit->offset_limit_cnt);
4031 4032
    break;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4033
  case SQLCOM_BEGIN:
4034 4035 4036 4037 4038 4039
    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;
    }
4040
    if (begin_trans(thd))
4041
      goto error;
serg@serg.mylan's avatar
serg@serg.mylan committed
4042
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4043 4044
    break;
  case SQLCOM_COMMIT:
4045
    if (end_trans(thd, lex->tx_release ? COMMIT_RELEASE :
serg@serg.mylan's avatar
serg@serg.mylan committed
4046
                              lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
4047
      goto error;
4048
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4049 4050
    break;
  case SQLCOM_ROLLBACK:
4051
    if (end_trans(thd, lex->tx_release ? ROLLBACK_RELEASE :
serg@serg.mylan's avatar
serg@serg.mylan committed
4052
                              lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
4053
      goto error;
4054
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4055
    break;
serg@serg.mylan's avatar
serg@serg.mylan committed
4056
  case SQLCOM_RELEASE_SAVEPOINT:
serg@serg.mylan's avatar
serg@serg.mylan committed
4057
  {
4058 4059
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
serg@serg.mylan's avatar
serg@serg.mylan committed
4060 4061 4062
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4063
                       (uchar *)sv->name, sv->length) == 0)
serg@serg.mylan's avatar
serg@serg.mylan committed
4064 4065
        break;
    }
4066
    if (sv)
serg@serg.mylan's avatar
serg@serg.mylan committed
4067
    {
4068
      if (ha_release_savepoint(thd, sv))
serg@serg.mylan's avatar
serg@serg.mylan committed
4069
        res= TRUE; // cannot happen
serg@serg.mylan's avatar
serg@serg.mylan committed
4070 4071
      else
        send_ok(thd);
4072
      thd->transaction.savepoints=sv->prev;
serg@serg.mylan's avatar
serg@serg.mylan committed
4073
    }
4074
    else
serg@serg.mylan's avatar
serg@serg.mylan committed
4075
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4076
    break;
serg@serg.mylan's avatar
serg@serg.mylan committed
4077
  }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4078
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
serg@serg.mylan's avatar
serg@serg.mylan committed
4079
  {
4080 4081
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
4082 4083 4084
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
4085
                       (uchar *)sv->name, sv->length) == 0)
4086 4087
        break;
    }
4088
    if (sv)
4089
    {
4090
      if (ha_rollback_to_savepoint(thd, sv))
4091 4092
        res= TRUE; // cannot happen
      else
serg@serg.mylan's avatar
serg@serg.mylan committed
4093 4094 4095 4096 4097 4098 4099 4100
      {
        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);
      }
4101
      thd->transaction.savepoints=sv;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4102 4103
    }
    else
4104
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4105
    break;
4106
  }
4107
  case SQLCOM_SAVEPOINT:
4108 4109
    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
4110
      send_ok(thd);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4111
    else
4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149
    {
      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);
      }
    }
4150
    break;
4151 4152
  case SQLCOM_CREATE_PROCEDURE:
  case SQLCOM_CREATE_SPFUNCTION:
monty@mysql.com's avatar
monty@mysql.com committed
4153
  {
4154
    uint namelen;
4155
    char *name, *db;
4156
    int result;
4157

4158
    DBUG_ASSERT(lex->sphead != 0);
4159

4160 4161
    if (!lex->sphead->m_db.str || !lex->sphead->m_db.str[0])
    {
4162
      if (!thd->db)
4163 4164 4165 4166 4167 4168 4169 4170 4171 4172
      {
        my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
        delete lex->sphead;
        lex->sphead= 0;
        goto error;
      }
      lex->sphead->m_db.length= strlen(thd->db);
      lex->sphead->m_db.str= thd->db;
    }

4173 4174
    if (check_access(thd, CREATE_PROC_ACL, lex->sphead->m_db.str, 0, 0, 0,
                     is_schema_db(lex->sphead->m_db.str)))
4175 4176 4177 4178 4179 4180
    {
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
    }

4181
    if (end_active_trans(thd)) 
4182
    {
4183 4184 4185
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
4186
    }
4187 4188

    name= lex->sphead->name(&namelen);
4189
#ifdef HAVE_DLOPEN
monty@mysql.com's avatar
monty@mysql.com committed
4190 4191 4192
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
4193

monty@mysql.com's avatar
monty@mysql.com committed
4194
      if (udf)
4195
      {
4196
	my_error(ER_UDF_EXISTS, MYF(0), name);
4197
	delete lex->sphead;
4198
	lex->sphead= 0;
4199
	goto error;
4200
      }
monty@mysql.com's avatar
monty@mysql.com committed
4201 4202 4203
    }
#endif

4204 4205 4206 4207 4208
    /*
      We need to copy name and db in order to use them for
      check_routine_access which is called after lex->sphead has
      been deleted.
    */
4209
    name= thd->strdup(name); 
4210 4211
    lex->sphead->m_db.str= db= thd->strmake(lex->sphead->m_db.str,
                                            lex->sphead->m_db.length);
4212
    res= (result= lex->sphead->create(thd));
4213 4214
    if (result == SP_OK)
    {
4215 4216 4217 4218 4219 4220
      /*
        We must cleanup the unit and the lex here because
        sp_grant_privileges calls (indirectly) db_find_routine,
        which in turn may call yyparse with THD::lex.
        TODO: fix db_find_routine to use a temporary lex.
      */
4221
      lex->unit.cleanup();
monty@mysql.com's avatar
monty@mysql.com committed
4222 4223
      delete lex->sphead;
      lex->sphead= 0;
4224
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4225
      /* only add privileges if really neccessary */
4226
      if (sp_automatic_privileges && !opt_noacl &&
4227 4228 4229
          check_routine_access(thd, DEFAULT_CREATE_PROC_ACLS,
      			       db, name,
                               lex->sql_command == SQLCOM_CREATE_PROCEDURE, 1))
4230
      {
4231 4232
        if (sp_grant_privileges(thd, db, name, 
                                lex->sql_command == SQLCOM_CREATE_PROCEDURE))
4233 4234 4235
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
	  	       ER_PROC_AUTO_GRANT_FAIL,
		       ER(ER_PROC_AUTO_GRANT_FAIL));
4236
        close_thread_tables(thd);
4237
      }
4238
#endif
4239
      send_ok(thd);
4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259
    }
    else
    {
      switch (result) {
      case SP_WRITE_ROW_FAILED:
	my_error(ER_SP_ALREADY_EXISTS, MYF(0), SP_TYPE_STRING(lex), name);
	break;
      case SP_NO_DB_ERROR:
	my_error(ER_BAD_DB_ERROR, MYF(0), lex->sphead->m_db.str);
	break;
      case SP_BAD_IDENTIFIER:
	my_error(ER_TOO_LONG_IDENT, MYF(0), name);
	break;
      case SP_BODY_TOO_LONG:
	my_error(ER_TOO_LONG_BODY, MYF(0), name);
	break;
      default:
	my_error(ER_SP_STORE_FAILED, MYF(0), SP_TYPE_STRING(lex), name);
	break;
      }
4260
      lex->unit.cleanup();
monty@mysql.com's avatar
monty@mysql.com committed
4261 4262 4263
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
4264
    }
monty@mysql.com's avatar
monty@mysql.com committed
4265 4266
    break;
  }
4267 4268 4269 4270
  case SQLCOM_CALL:
    {
      sp_head *sp;

4271 4272 4273 4274 4275 4276 4277 4278 4279
      /*
        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;

      /*
4280 4281
        By this moment all needed SPs should be in cache so no need to look 
        into DB. 
4282
      */
4283 4284
      if (!(sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                                &thd->sp_proc_cache, TRUE)))
4285
      {
4286
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PROCEDURE",
4287
                 lex->spname->m_qname.str);
4288
	goto error;
4289 4290 4291
      }
      else
      {
4292
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4293
	Security_context *save_ctx;
4294
#endif
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4295
	ha_rows select_limit;
monty@mysql.com's avatar
monty@mysql.com committed
4296 4297
        /* bits that should be cleared in thd->server_status */
	uint bits_to_be_cleared= 0;
4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309
        /*
          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;
        }
4310

4311 4312
	my_bool nsok= thd->net.no_send_ok;
	thd->net.no_send_ok= TRUE;
4313
	if (sp->m_flags & sp_head::MULTI_RESULTS)
4314
	{
4315
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
4316
	  {
4317 4318 4319 4320
            /*
              The client does not support multiple result sets being sent
              back
            */
4321
	    my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str);
4322 4323 4324
	    thd->net.no_send_ok= nsok;
	    goto error;
	  }
monty@mysql.com's avatar
monty@mysql.com committed
4325 4326 4327 4328 4329 4330 4331
          /*
            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;
4332 4333
	}

4334
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4335 4336 4337
	if (check_routine_access(thd, EXECUTE_ACL,
				 sp->m_db.str, sp->m_name.str, TRUE, 0) ||
          sp_change_security_context(thd, sp, &save_ctx))
4338 4339 4340 4341
	{
	  thd->net.no_send_ok= nsok;
	  goto error;
	}
4342 4343 4344
	if (save_ctx &&
            check_routine_access(thd, EXECUTE_ACL,
                                 sp->m_db.str, sp->m_name.str, TRUE, 0))
4345 4346
	{
	  thd->net.no_send_ok= nsok;
4347
	  sp_restore_security_context(thd, save_ctx);
4348 4349 4350
	  goto error;
	}

4351
#endif
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4352 4353
	select_limit= thd->variables.select_limit;
	thd->variables.select_limit= HA_POS_ERROR;
4354

4355
        thd->row_count_func= 0;
4356 4357
        
        /* 
4358
          We never write CALL statements into binlog:
4359 4360 4361 4362 4363
           - 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.
4364
        */
4365
	res= sp->execute_procedure(thd, &lex->value_list);
4366 4367 4368
	/*
          If warnings have been cleared, we have to clear total_warn_count
          too, otherwise the clients get confused.
4369 4370 4371 4372
	 */
	if (thd->warn_list.is_empty())
	  thd->total_warn_count= 0;

pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
4373
	thd->variables.select_limit= select_limit;
4374
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4375
	sp_restore_security_context(thd, save_ctx);
4376
#endif
4377

4378
	thd->net.no_send_ok= nsok;
monty@mysql.com's avatar
monty@mysql.com committed
4379
        thd->server_status&= ~bits_to_be_cleared;
4380

4381
	if (!res)
monty@mysql.com's avatar
monty@mysql.com committed
4382 4383
	  send_ok(thd, (ulong) (thd->row_count_func < 0 ? 0 :
                                thd->row_count_func));
4384 4385
	else
	  goto error;		// Substatement should already have sent error
4386
      }
4387
      break;
4388 4389
    }
  case SQLCOM_ALTER_PROCEDURE:
4390
  case SQLCOM_ALTER_FUNCTION:
4391
    {
4392
      int result;
4393 4394 4395 4396
      sp_head *sp;
      st_sp_chistics chistics;

      memcpy(&chistics, &lex->sp_chistics, sizeof(chistics));
4397
      if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4398 4399
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
4400
      else
4401 4402
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
monty@mysql.com's avatar
monty@mysql.com committed
4403
      mysql_reset_errors(thd, 0);
4404
      if (! sp)
4405 4406 4407 4408 4409 4410 4411 4412 4413
      {
	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;
	}
      }
4414 4415
      else
      {
4416 4417 4418
        if (check_routine_access(thd, ALTER_PROC_ACL, sp->m_db.str, 
				 sp->m_name.str,
                                 lex->sql_command == SQLCOM_ALTER_PROCEDURE, 0))
4419
	  goto error;
4420 4421 4422

        if (end_active_trans(thd)) 
          goto error;
4423
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
4424 4425
        if ((sp->m_type == TYPE_ENUM_FUNCTION) &&
            !trust_function_creators &&  mysql_bin_log.is_open() &&
4426 4427 4428 4429 4430 4431 4432 4433 4434 4435
            !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
        {
4436 4437 4438 4439 4440 4441
          /*
            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.
          */
4442 4443 4444 4445 4446
          if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
            result= sp_update_procedure(thd, lex->spname, &lex->sp_chistics);
          else
            result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
        }
4447
      }
4448
      switch (result)
4449
      {
4450
      case SP_OK:
4451 4452 4453
        if (mysql_bin_log.is_open())
        {
          thd->clear_error();
4454 4455
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
4456
        }
4457
	send_ok(thd);
4458 4459
	break;
      case SP_KEY_NOT_FOUND:
4460 4461
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4462 4463
	goto error;
      default:
4464 4465
	my_error(ER_SP_CANT_ALTER, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4466
	goto error;
4467
      }
4468
      break;
4469 4470
    }
  case SQLCOM_DROP_PROCEDURE:
4471
  case SQLCOM_DROP_FUNCTION:
4472
    {
4473
      sp_head *sp;
4474
      int result;
4475
      char *db, *name;
4476

4477
      if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
4478 4479
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
4480
      else
4481 4482
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
monty@mysql.com's avatar
monty@mysql.com committed
4483
      mysql_reset_errors(thd, 0);
4484
      if (sp)
4485
      {
4486 4487
        db= thd->strdup(sp->m_db.str);
	name= thd->strdup(sp->m_name.str);
4488 4489
	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
4490
          goto error;
4491 4492 4493

        if (end_active_trans(thd)) 
          goto error;
4494
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4495
	if (sp_automatic_privileges && !opt_noacl &&
4496 4497
	    sp_revoke_privileges(thd, db, name, 
                                 lex->sql_command == SQLCOM_DROP_PROCEDURE))
4498 4499 4500 4501 4502
	{
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
		       ER_PROC_AUTO_REVOKE_FAIL,
		       ER(ER_PROC_AUTO_REVOKE_FAIL));
	}
4503
#endif
4504
	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
4505
	  result= sp_drop_procedure(thd, lex->spname);
4506
	else
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
4507
	  result= sp_drop_function(thd, lex->spname);
4508 4509 4510
      }
      else
      {
4511
#ifdef HAVE_DLOPEN
4512 4513 4514 4515 4516 4517
	if (lex->sql_command == SQLCOM_DROP_FUNCTION)
	{
          udf_func *udf = find_udf(lex->spname->m_name.str,
                                   lex->spname->m_name.length);
          if (udf)
          {
4518
	    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 0, 0))
4519 4520
	      goto error;
	    if (!(res = mysql_drop_function(thd, &lex->spname->m_name)))
4521
	    {
4522 4523
	      send_ok(thd);
	      break;
4524 4525
	    }
	  }
4526
	}
4527
#endif
4528 4529 4530 4531 4532 4533 4534
	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;
	}
4535
      }
4536 4537
      res= result;
      switch (result)
4538 4539
      {
      case SP_OK:
4540 4541 4542
        if (mysql_bin_log.is_open())
        {
          thd->clear_error();
4543 4544
          thd->binlog_query(THD::MYSQL_QUERY_TYPE,
                            thd->query, thd->query_length, FALSE, FALSE);
4545
        }
4546
	send_ok(thd);
4547 4548
	break;
      case SP_KEY_NOT_FOUND:
4549 4550
	if (lex->drop_if_exists)
	{
4551
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
4552
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
4553
			      SP_COM_STRING(lex), lex->spname->m_name.str);
4554
	  res= FALSE;
4555 4556 4557
	  send_ok(thd);
	  break;
	}
4558 4559
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4560 4561
	goto error;
      default:
4562 4563
	my_error(ER_SP_DROP_FAILED, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4564
	goto error;
4565
      }
4566
      break;
4567
    }
4568 4569
  case SQLCOM_SHOW_CREATE_PROC:
    {
4570
      if (lex->spname->m_name.length > NAME_LEN)
4571
      {
4572
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
4573 4574
	goto error;
      }
4575
      if (sp_show_create_procedure(thd, lex->spname) != SP_OK)
4576
      {			/* We don't distinguish between errors for now */
4577 4578
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
4579 4580 4581 4582 4583 4584
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
4585
      if (lex->spname->m_name.length > NAME_LEN)
4586
      {
4587
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
4588 4589
	goto error;
      }
4590
      if (sp_show_create_function(thd, lex->spname) != SP_OK)
4591
      {			/* We don't distinguish between errors for now */
4592 4593
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
4594 4595 4596 4597 4598 4599
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
4600
      res= sp_show_status_procedure(thd, (lex->wild ?
4601 4602 4603 4604 4605
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
4606
      res= sp_show_status_function(thd, (lex->wild ? 
4607 4608 4609
					 lex->wild->ptr() : NullS));
      break;
    }
pem@mysql.com's avatar
pem@mysql.com committed
4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621
#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
4622 4623
        sp= sp_find_routine(thd, TYPE_ENUM_PROCEDURE, lex->spname,
                            &thd->sp_proc_cache, FALSE);
pem@mysql.com's avatar
pem@mysql.com committed
4624
      else
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4625 4626
        sp= sp_find_routine(thd, TYPE_ENUM_FUNCTION, lex->spname,
                            &thd->sp_func_cache, FALSE);
pem@mysql.com's avatar
pem@mysql.com committed
4627
      if (!sp || !sp->show_routine_code(thd))
4628 4629
      {
        /* We don't distinguish between errors for now */
pem@mysql.com's avatar
pem@mysql.com committed
4630 4631 4632 4633 4634 4635 4636
        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
4637 4638
  case SQLCOM_CREATE_VIEW:
    {
4639 4640 4641
      if (end_active_trans(thd))
        goto error;

4642 4643 4644
      if (!(res= mysql_create_view(thd, thd->lex->create_view_mode)) &&
          mysql_bin_log.is_open())
      {
4645
        String buff;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4646 4647 4648 4649
        const LEX_STRING command[3]=
          {{(char *)STRING_WITH_LEN("CREATE ")},
           {(char *)STRING_WITH_LEN("ALTER ")},
           {(char *)STRING_WITH_LEN("CREATE OR REPLACE ")}};
4650
        thd->clear_error();
4651 4652 4653 4654

        buff.append(command[thd->lex->create_view_mode].str,
                    command[thd->lex->create_view_mode].length);
        view_store_options(thd, first_table, &buff);
4655
        buff.append(STRING_WITH_LEN("VIEW "));
4656 4657
        /* Test if user supplied a db (ie: we did not use thd->db) */
        if (first_table->db != thd->db && first_table->db[0])
4658 4659 4660 4661 4662 4663 4664
        {
          append_identifier(thd, &buff, first_table->db,
                            first_table->db_length);
          buff.append('.');
        }
        append_identifier(thd, &buff, first_table->table_name,
                          first_table->table_name_length);
4665
        buff.append(STRING_WITH_LEN(" AS "));
4666 4667
        buff.append(first_table->source.str, first_table->source.length);

4668 4669
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          buff.ptr(), buff.length(), FALSE, FALSE);
4670
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4671 4672 4673 4674
      break;
    }
  case SQLCOM_DROP_VIEW:
    {
4675 4676 4677
      if (check_table_access(thd, DROP_ACL, all_tables, 0) ||
          end_active_trans(thd))
        goto error;
4678 4679 4680
      if (!(res= mysql_drop_view(thd, first_table, thd->lex->drop_mode)) &&
          mysql_bin_log.is_open())
      {
4681
        thd->clear_error();
4682 4683
        thd->binlog_query(THD::STMT_QUERY_TYPE,
                          thd->query, thd->query_length, FALSE, FALSE);
4684
      }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4685 4686
      break;
    }
4687 4688
  case SQLCOM_CREATE_TRIGGER:
  {
4689 4690 4691
    if (end_active_trans(thd))
      goto error;

4692 4693 4694
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

    /* We don't care about trigger body after this point */
4695 4696 4697 4698 4699 4700
    delete lex->sphead;
    lex->sphead= 0;
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
4701 4702 4703
    if (end_active_trans(thd))
      goto error;

4704 4705 4706
    res= mysql_create_or_drop_trigger(thd, all_tables, 0);
    break;
  }
4707
  case SQLCOM_XA_START:
4708 4709
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
        thd->lex->xa_opt == XA_RESUME)
4710
    {
4711
      if (! thd->transaction.xid_state.xid.eq(thd->lex->xid))
4712 4713 4714 4715
      {
        my_error(ER_XAER_NOTA, MYF(0));
        break;
      }
4716
      thd->transaction.xid_state.xa_state=XA_ACTIVE;
4717 4718 4719
      send_ok(thd);
      break;
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
4720
    if (thd->lex->xa_opt != XA_NONE)
4721 4722 4723 4724
    { // JOIN is not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
4725
    if (thd->transaction.xid_state.xa_state != XA_NOTR)
4726
    {
4727
      my_error(ER_XAER_RMFAIL, MYF(0),
4728
               xa_state_names[thd->transaction.xid_state.xa_state]);
4729 4730 4731 4732 4733 4734 4735
      break;
    }
    if (thd->active_transaction() || thd->locked_tables)
    {
      my_error(ER_XAER_OUTSIDE, MYF(0));
      break;
    }
4736 4737 4738 4739 4740 4741 4742 4743 4744
    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);
4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756
    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;
    }
4757
    if (thd->transaction.xid_state.xa_state != XA_ACTIVE)
4758
    {
4759
      my_error(ER_XAER_RMFAIL, MYF(0),
4760
               xa_state_names[thd->transaction.xid_state.xa_state]);
4761 4762
      break;
    }
4763
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4764 4765 4766 4767
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
4768
    thd->transaction.xid_state.xa_state=XA_IDLE;
4769 4770 4771
    send_ok(thd);
    break;
  case SQLCOM_XA_PREPARE:
4772
    if (thd->transaction.xid_state.xa_state != XA_IDLE)
4773
    {
4774
      my_error(ER_XAER_RMFAIL, MYF(0),
4775
               xa_state_names[thd->transaction.xid_state.xa_state]);
4776 4777
      break;
    }
4778
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4779 4780 4781 4782 4783 4784 4785
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
    if (ha_prepare(thd))
    {
      my_error(ER_XA_RBROLLBACK, MYF(0));
4786 4787
      xid_cache_delete(&thd->transaction.xid_state);
      thd->transaction.xid_state.xa_state=XA_NOTR;
4788 4789
      break;
    }
4790
    thd->transaction.xid_state.xa_state=XA_PREPARED;
4791 4792 4793
    send_ok(thd);
    break;
  case SQLCOM_XA_COMMIT:
4794
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4795
    {
4796 4797
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
4798
        my_error(ER_XAER_NOTA, MYF(0));
serg@serg.mylan's avatar
serg@serg.mylan committed
4799
      else
4800 4801 4802
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 1);
        xid_cache_delete(xs);
serg@serg.mylan's avatar
serg@serg.mylan committed
4803
        send_ok(thd);
4804
      }
4805 4806
      break;
    }
4807
    if (thd->transaction.xid_state.xa_state == XA_IDLE &&
monty@mysql.com's avatar
monty@mysql.com committed
4808
        thd->lex->xa_opt == XA_ONE_PHASE)
4809
    {
4810 4811 4812
      int r;
      if ((r= ha_commit(thd)))
        my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0));
4813 4814 4815
      else
        send_ok(thd);
    }
4816
    else if (thd->transaction.xid_state.xa_state == XA_PREPARED &&
monty@mysql.com's avatar
monty@mysql.com committed
4817
             thd->lex->xa_opt == XA_NONE)
4818
    {
4819 4820 4821
      if (wait_if_global_read_lock(thd, 0, 0))
      {
        ha_rollback(thd);
4822
        my_error(ER_XAER_RMERR, MYF(0));
4823
      }
4824
      else
4825 4826 4827 4828 4829 4830 4831
      {
        if (ha_commit_one_phase(thd, 1))
          my_error(ER_XAER_RMERR, MYF(0));
        else
          send_ok(thd);
        start_waiting_global_read_lock(thd);
      }
4832 4833 4834
    }
    else
    {
4835
      my_error(ER_XAER_RMFAIL, MYF(0),
4836
               xa_state_names[thd->transaction.xid_state.xa_state]);
4837 4838 4839 4840
      break;
    }
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
4841 4842
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
4843 4844
    break;
  case SQLCOM_XA_ROLLBACK:
4845
    if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
4846
    {
4847 4848
      XID_STATE *xs=xid_cache_search(thd->lex->xid);
      if (!xs || xs->in_thd)
4849
        my_error(ER_XAER_NOTA, MYF(0));
serg@serg.mylan's avatar
serg@serg.mylan committed
4850
      else
4851 4852 4853
      {
        ha_commit_or_rollback_by_xid(thd->lex->xid, 0);
        xid_cache_delete(xs);
serg@serg.mylan's avatar
serg@serg.mylan committed
4854
        send_ok(thd);
4855
      }
4856 4857
      break;
    }
4858 4859
    if (thd->transaction.xid_state.xa_state != XA_IDLE &&
        thd->transaction.xid_state.xa_state != XA_PREPARED)
4860
    {
4861
      my_error(ER_XAER_RMFAIL, MYF(0),
4862
               xa_state_names[thd->transaction.xid_state.xa_state]);
4863 4864 4865 4866 4867 4868 4869 4870
      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;
4871 4872
    xid_cache_delete(&thd->transaction.xid_state);
    thd->transaction.xid_state.xa_state=XA_NOTR;
4873 4874
    break;
  case SQLCOM_XA_RECOVER:
4875
    res= mysql_xa_recover(thd);
4876
    break;
4877 4878 4879 4880 4881 4882
  case SQLCOM_ALTER_TABLESPACE:
    if (check_access(thd, ALTER_ACL, thd->db, 0, 1, 0, thd->db ? is_schema_db(thd->db) : 0))
      break;
    if (!(res= mysql_alter_tablespace(thd, lex->alter_tablespace_info)))
      send_ok(thd);
    break;
4883 4884 4885 4886 4887 4888 4889 4890 4891
  case SQLCOM_INSTALL_PLUGIN:
    if (! (res= mysql_install_plugin(thd, &thd->lex->comment,
                                     &thd->lex->ident)))
      send_ok(thd);
    break;
  case SQLCOM_UNINSTALL_PLUGIN:
    if (! (res= mysql_uninstall_plugin(thd, &thd->lex->comment)))
      send_ok(thd);
    break;
4892 4893 4894 4895 4896 4897 4898 4899 4900
  case SQLCOM_BINLOG_BASE64_EVENT:
  {
#ifndef EMBEDDED_LIBRARY
    mysql_client_binlog_statement(thd);
#else /* EMBEDDED_LIBRARY */
    my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "embedded");
#endif /* EMBEDDED_LIBRARY */
    break;
  }
4901 4902
  default:
    DBUG_ASSERT(0);                             /* Impossible */
4903
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4904 4905
    break;
  }
monty@mysql.com's avatar
monty@mysql.com committed
4906
  thd->proc_info="query end";
4907 4908

  /*
4909
    Binlog-related cleanup:
4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920
    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);

4921
  /*
4922 4923 4924 4925 4926 4927
    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.
4928
   */
4929 4930
  if (lex->sql_command != SQLCOM_CALL && lex->sql_command != SQLCOM_EXECUTE &&
      uc_update_queries[lex->sql_command]<2)
4931
    thd->row_count_func= -1;
4932
  DBUG_RETURN(res || thd->net.report_error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4933 4934

error:
4935
  DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4936 4937 4938
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4939 4940
/*
  Check grants for commands which work only with one table and all other
4941
  tables belonging to subselects or implicitly opened tables.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4942

4943
  SYNOPSIS
monty@mysql.com's avatar
monty@mysql.com committed
4944 4945
    check_one_table_access()
    thd			Thread handler
4946
    privilege		requested privilege
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4947
    all_tables		global table list of query
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4948 4949 4950

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

4954
bool check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *all_tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4955
{
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4956
  if (check_access(thd, privilege, all_tables->db,
4957 4958
		   &all_tables->grant.privilege, 0, 0,
                   test(all_tables->schema_table)))
monty@mysql.com's avatar
monty@mysql.com committed
4959
    return 1;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4960

4961
  /* Show only 1 table for check_grant */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4962
  if (grant_option && check_grant(thd, privilege, all_tables, 0, 1, 0))
monty@mysql.com's avatar
monty@mysql.com committed
4963
    return 1;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4964

4965
  /* Check rights on tables of subselects and implictly opened tables */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4966
  TABLE_LIST *subselects_tables;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4967
  if ((subselects_tables= all_tables->next_global))
monty@mysql.com's avatar
monty@mysql.com committed
4968
  {
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4969
    if ((check_table_access(thd, SELECT_ACL, subselects_tables, 0)))
monty@mysql.com's avatar
monty@mysql.com committed
4970 4971 4972
      return 1;
  }
  return 0;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4973 4974 4975
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4976
/****************************************************************************
4977
  Get the user (global) and database privileges for all used tables
4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990

  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
4991 4992
                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
4993 4994 4995
****************************************************************************/

bool
4996
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
4997
	     bool dont_check_global_grants, bool no_errors, bool schema_db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4998
{
4999
  Security_context *sctx= thd->security_ctx;
5000 5001
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
5002
  bool  db_is_pattern= test(want_access & GRANT_ACL);
5003 5004
#endif
  ulong dummy;
5005 5006
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
5007
                      db ? db : "", want_access, sctx->master_access));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5008 5009 5010 5011 5012
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

5013
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5014
  {
5015
    DBUG_PRINT("error",("No database"));
5016
    if (!no_errors)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5017 5018
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                 MYF(0));                       /* purecov: tested */
5019
    DBUG_RETURN(TRUE);				/* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5020 5021
  }

5022 5023 5024 5025 5026
  if (schema_db)
  {
    if (want_access & ~(SELECT_ACL | EXTRA_ACL))
    {
      if (!no_errors)
5027 5028
      {
        const char *db_name= db ? db : thd->db;
5029
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5030 5031
                 sctx->priv_user, sctx->priv_host, db_name);
      }
5032 5033 5034 5035 5036 5037 5038 5039 5040
      DBUG_RETURN(TRUE);
    }
    else
    {
      *save_priv= SELECT_ACL;
      DBUG_RETURN(FALSE);
    }
  }

monty@mysql.com's avatar
monty@mysql.com committed
5041 5042 5043
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
5044
  if ((sctx->master_access & want_access) == want_access)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5045
  {
5046 5047 5048 5049 5050
    /*
      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
    */
5051 5052
    db_access= sctx->db_access;
    if (!(sctx->master_access & SELECT_ACL) &&
5053
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
5054 5055 5056
      db_access=acl_get(sctx->host, sctx->ip, sctx->priv_user, db,
                        db_is_pattern);
    *save_priv=sctx->master_access | db_access;
5057
    DBUG_RETURN(FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5058
  }
5059
  if (((want_access & ~sctx->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
5060
      ! db && dont_check_global_grants)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5061
  {						// We can never grant this
5062
    DBUG_PRINT("error",("No possible access"));
5063
    if (!no_errors)
5064
      my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
5065 5066
               sctx->priv_user,
               sctx->priv_host,
5067 5068 5069
               (thd->password ?
                ER(ER_YES) :
                ER(ER_NO)));                    /* purecov: tested */
5070
    DBUG_RETURN(TRUE);				/* purecov: tested */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5071 5072 5073
  }

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

5076
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
5077 5078
    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
5079
  else
5080
    db_access= sctx->db_access;
5081
  DBUG_PRINT("info",("db_access: %lu", db_access));
monty@mysql.com's avatar
monty@mysql.com committed
5082
  /* Remove SHOW attribute and access rights we already have */
5083
  want_access &= ~(sctx->master_access | EXTRA_ACL);
5084 5085
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
5086
  db_access= ((*save_priv=(db_access | sctx->master_access)) & want_access);
5087 5088

  /* grant_option is set if there exists a single table or column grant */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5089
  if (db_access == want_access ||
5090
      (grant_option && !dont_check_global_grants &&
5091
       !(want_access & ~(db_access | TABLE_ACLS | PROC_ACLS))))
5092
    DBUG_RETURN(FALSE);				/* Ok */
5093 5094

  DBUG_PRINT("error",("Access denied"));
5095
  if (!no_errors)
5096
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5097
             sctx->priv_user, sctx->priv_host,
5098 5099 5100
             (db ? db : (thd->db ?
                         thd->db :
                         "unknown")));          /* purecov: tested */
5101
  DBUG_RETURN(TRUE);				/* purecov: tested */
monty@mysql.com's avatar
monty@mysql.com committed
5102
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5103 5104 5105
}


5106 5107 5108 5109 5110 5111 5112 5113 5114
/*
  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
5115
    One gets access right if one has ANY of the rights in want_access
5116 5117 5118 5119 5120 5121 5122 5123
    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
*/
5124 5125

bool check_global_access(THD *thd, ulong want_access)
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5126
{
monty@mysql.com's avatar
monty@mysql.com committed
5127 5128 5129
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
5130
  char command[128];
5131
  if ((thd->security_ctx->master_access & want_access))
5132 5133
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
5134
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
5135
  return 1;
monty@mysql.com's avatar
monty@mysql.com committed
5136
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
5137 5138 5139
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
5140
/*
5141 5142
  Check the privilege for all used tables.  Table privileges are cached
  in the table list for GRANT checking
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5143 5144
*/

5145
bool
5146
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
5147
		   bool no_errors)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5148
{
5149 5150
  uint found=0;
  ulong found_access=0;
5151 5152 5153
  TABLE_LIST *org_tables= tables;
  TABLE_LIST *first_not_own_table= thd->lex->first_not_own_table();
  /*
5154 5155 5156
    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.
5157
  */
5158
  for (; tables != first_not_own_table; tables= tables->next_global)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5159
  {
5160
    if (tables->schema_table && 
5161
        (want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
5162 5163 5164
    {
      if (!no_errors)
        my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
5165
                 thd->security_ctx->priv_user, thd->security_ctx->priv_host,
5166 5167 5168
                 information_schema_name.str);
      return TRUE;
    }
5169 5170 5171 5172 5173
    /*
       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);
5174
    if (tables->derived || tables->schema_table || tables->belong_to_view ||
5175
        (tables->table && (int)tables->table->s->tmp_table) ||
5176 5177
        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
5178
      continue;
5179 5180
    if ((thd->security_ctx->master_access & want_access) ==
        (want_access & ~EXTRA_ACL) &&
5181
	thd->db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5182
      tables->grant.privilege= want_access;
5183
    else if (tables->db && tables->db == thd->db)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5184 5185 5186 5187 5188
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
5189
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5190
			 0, no_errors, test(tables->schema_table)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5191 5192
	  return TRUE;				// Access denied
	found_access=tables->grant.privilege;
5193
	found=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5194 5195
      }
    }
5196
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
5197
			  0, no_errors, test(tables->schema_table)))
5198
      return TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5199 5200
  }
  if (grant_option)
5201
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5202
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5203 5204 5205
  return FALSE;
}

5206

5207
bool
5208 5209
check_routine_access(THD *thd, ulong want_access,char *db, char *name,
		     bool is_proc, bool no_errors)
5210 5211 5212 5213 5214
{
  TABLE_LIST tables[1];
  
  bzero((char *)tables, sizeof(TABLE_LIST));
  tables->db= db;
5215
  tables->table_name= tables->alias= name;
5216
  
monty@mysql.com's avatar
monty@mysql.com committed
5217 5218 5219 5220 5221 5222 5223
  /*
    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)
5224 5225
    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
5226
			0, no_errors, 0))
5227 5228
    return TRUE;
  
5229
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5230
  if (grant_option)
5231
    return check_grant_routine(thd, want_access, tables, is_proc, no_errors);
5232
#endif
5233 5234 5235 5236

  return FALSE;
}

5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251

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

5252 5253
bool check_some_routine_access(THD *thd, const char *db, const char *name,
                               bool is_proc)
5254 5255
{
  ulong save_priv;
5256
  if (thd->security_ctx->master_access & SHOW_PROC_ACLS)
5257
    return FALSE;
5258 5259 5260 5261 5262
  /*
    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) ||
5263 5264
      (save_priv & SHOW_PROC_ACLS))
    return FALSE;
5265
  return check_routine_level_acl(thd, db, name, is_proc);
5266 5267 5268
}


5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293
/*
  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,
5294 5295
                        &table->grant.privilege, 0, 1,
                        test(table->schema_table)) &&
5296 5297 5298 5299 5300 5301 5302 5303 5304
          !grant_option || !check_grant(thd, access, table, 0, 1, 1))
        DBUG_RETURN(0);
    }
  }
  DBUG_PRINT("exit",("no matching access rights"));
  DBUG_RETURN(1);
}


5305 5306
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
5307 5308 5309 5310
{
  int error=0;
  if (table_list)
  {
5311
    /* Check that all tables use the current database */
5312
    TABLE_LIST *tmp;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5313
    for (tmp= table_list; tmp; tmp= tmp->next_local)
5314 5315 5316 5317
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
5318
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
hf@deer.(none)'s avatar
hf@deer.(none) committed
5319
			     table_list,0);
5320 5321 5322 5323
  }
  return error;
}

hf@deer.(none)'s avatar
hf@deer.(none) committed
5324 5325 5326

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5327
  for (; tables; tables= tables->next_global)
hf@deer.(none)'s avatar
hf@deer.(none) committed
5328 5329 5330 5331 5332
  {
    if (!tables->db)
    {
      if (!(tables->db=thd->db))
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5333 5334
	my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                   MYF(0));                     /* purecov: tested */
hf@deer.(none)'s avatar
hf@deer.(none) committed
5335 5336 5337 5338 5339 5340
	return TRUE;				/* purecov: tested */
      }
    }
  }
  return FALSE;
}
5341

5342

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5343 5344 5345 5346 5347 5348 5349 5350 5351 5352
/****************************************************************************
	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
5353 5354 5355 5356
#ifndef DBUG_OFF
long max_stack_used;
#endif

5357
#ifndef EMBEDDED_LIBRARY
5358 5359 5360 5361 5362 5363 5364 5365
/*
  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
5366 5367
{
  long stack_used;
5368
  DBUG_ASSERT(thd == current_thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5369
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
monty@mysql.com's avatar
monty@mysql.com committed
5370
      (long) (thread_stack - margin))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5371
  {
5372 5373 5374
    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));
5375
    thd->fatal_error();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5376 5377
    return 1;
  }
monty@mysql.com's avatar
monty@mysql.com committed
5378 5379 5380
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5381 5382
  return 0;
}
5383
#endif /* EMBEDDED_LIBRARY */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5384 5385 5386 5387

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

5388
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5389 5390
{
  LEX	*lex=current_lex;
5391
  ulong old_info=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417
  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;
}


/****************************************************************************
5418
  Initialize global thd variables needed for query
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5419 5420
****************************************************************************/

5421
void
5422
mysql_init_query(THD *thd, uchar *buf, uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5423 5424
{
  DBUG_ENTER("mysql_init_query");
5425
  lex_start(thd, buf, length);
5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446
  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");
5447
  thd->free_list= 0;
5448
  thd->select_number= 1;
5449
  thd->last_insert_id_used= thd->query_start_used= thd->insert_id_used=0;
5450
  thd->is_fatal_error= thd->time_zone_used= 0;
monty@mysql.com's avatar
monty@mysql.com committed
5451
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
monty@mysql.com's avatar
monty@mysql.com committed
5452 5453
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
5454
  DBUG_ASSERT(thd->security_ctx== &thd->main_security_ctx);
5455
  thd->tmp_table_used= 0;
5456 5457
  if (!thd->in_sub_stmt)
  {
5458
    if (opt_bin_log)
5459
    {
5460
      reset_dynamic(&thd->user_var_events);
5461 5462
      thd->user_var_events_alloc= thd->mem_root;
    }
5463
    thd->clear_error();
5464 5465 5466 5467
    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
5468 5469 5470
  DBUG_VOID_RETURN;
}

5471

5472 5473 5474
void
mysql_init_select(LEX *lex)
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5475
  SELECT_LEX *select_lex= lex->current_select;
5476
  select_lex->init_select();
5477
  lex->wild= 0;
5478 5479
  if (select_lex == &lex->select_lex)
  {
5480
    DBUG_ASSERT(lex->result == 0);
5481 5482
    lex->exchange= 0;
  }
5483 5484
}

5485

5486
bool
5487
mysql_new_select(LEX *lex, bool move_down)
5488
{
5489
  SELECT_LEX *select_lex;
5490
  THD *thd= lex->thd;
5491 5492
  DBUG_ENTER("mysql_new_select");

5493
  if (!(select_lex= new (thd->mem_root) SELECT_LEX()))
5494
    DBUG_RETURN(1);
5495
  select_lex->select_number= ++thd->select_number;
5496
  select_lex->parent_lex= lex; /* Used in init_query. */
5497 5498
  select_lex->init_query();
  select_lex->init_select();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5499 5500
  lex->nest_level++;
  select_lex->nest_level= lex->nest_level;
5501 5502 5503 5504 5505
  /*
    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
5506
  if (thd->stmt_arena->is_stmt_prepare())
5507
    select_lex->uncacheable|= UNCACHEABLE_PREPARE;
5508 5509
  if (move_down)
  {
5510
    SELECT_LEX_UNIT *unit;
5511
    lex->subqueries= TRUE;
5512
    /* first select_lex of subselect or derived table */
5513
    if (!(unit= new (thd->mem_root) SELECT_LEX_UNIT()))
5514
      DBUG_RETURN(1);
5515

5516 5517
    unit->init_query();
    unit->init_select();
5518
    unit->thd= thd;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5519
    unit->include_down(lex->current_select);
5520 5521
    unit->link_next= 0;
    unit->link_prev= 0;
5522
    unit->return_to= lex->current_select;
5523
    select_lex->include_down(unit);
5524 5525 5526 5527 5528
    /*
      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;
5529 5530
  }
  else
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5531
  {
5532
    Name_resolution_context *outer_context;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5533 5534
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
5535
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
5536
      DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
5537
    }
5538
    select_lex->include_neighbour(lex->current_select);
5539 5540 5541 5542 5543 5544
    /*
      we are not sure that we have one level of SELECTs above, so we take
      outer_context address from first select of unit
    */
    outer_context=
      select_lex->master_unit()->first_select()->context.outer_context;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5545 5546 5547 5548 5549 5550 5551 5552
    SELECT_LEX_UNIT *unit= select_lex->master_unit();
    SELECT_LEX *fake= unit->fake_select_lex;
    if (!fake)
    {
      /*
	as far as we included SELECT_LEX for UNION unit should have
	fake SELECT_LEX for UNION processing
      */
5553
      if (!(fake= unit->fake_select_lex= new (thd->mem_root) SELECT_LEX()))
5554
        DBUG_RETURN(1);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5555 5556 5557
      fake->include_standalone(unit,
			       (SELECT_LEX_NODE**)&unit->fake_select_lex);
      fake->select_number= INT_MAX;
5558
      fake->parent_lex= lex; /* Used in init_query. */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5559 5560
      fake->make_empty_select();
      fake->linkage= GLOBAL_OPTIONS_TYPE;
5561
      fake->select_limit= 0;
5562 5563 5564 5565 5566

      fake->context.outer_context= outer_context;
      /* allow item list resolving in fake select for ORDER BY */
      fake->context.resolve_in_select_list= TRUE;
      fake->context.select_lex= fake;
5567 5568 5569 5570 5571
      /*
        Remove the name resolution context of the fake select from the
        context stack.
       */
      lex->pop_context();
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5572
    }
5573
    select_lex->context.outer_context= outer_context;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5574
  }
peter@mysql.com's avatar
peter@mysql.com committed
5575

5576
  select_lex->master_unit()->global_parameters= select_lex;
5577
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
5578
  lex->current_select= select_lex;
5579 5580 5581 5582 5583
  /*
    in subquery is SELECT query and we allow resolution of names in SELECT
    list
  */
  select_lex->context.resolve_in_select_list= TRUE;
5584
  DBUG_RETURN(0);
5585
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5586

5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601
/*
  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)
{
5602
  THD *thd;
5603
  LEX *lex;
5604
  LEX_STRING tmp, null_lex_string;
5605 5606
  Item *var;
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
5607
  DBUG_ENTER("create_select_for_variable");
5608 5609

  thd= current_thd;
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
5610
  lex= thd->lex;
5611 5612 5613 5614
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
5615
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
5616 5617 5618 5619
  /*
    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
5620 5621 5622 5623 5624 5625
  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);
  }
5626 5627 5628
  DBUG_VOID_RETURN;
}

5629

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5630 5631
void mysql_init_multi_delete(LEX *lex)
{
5632
  lex->sql_command=  SQLCOM_DELETE_MULTI;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5633
  mysql_init_select(lex);
5634 5635
  lex->select_lex.select_limit= 0;
  lex->unit.select_limit_cnt= HA_POS_ERROR;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5636
  lex->select_lex.table_list.save_and_clear(&lex->auxilliary_table_list);
5637
  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
5638 5639
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5640
}
5641

5642 5643 5644 5645
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
5646

5647
void mysql_parse(THD *thd, char *inBuf, uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5648 5649
{
  DBUG_ENTER("mysql_parse");
5650
  mysql_init_query(thd, (uchar*) inBuf, length);
5651
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5652
  {
5653
    LEX *lex= thd->lex;
5654
    
5655 5656
    sp_cache_flush_obsolete(&thd->sp_proc_cache);
    sp_cache_flush_obsolete(&thd->sp_func_cache);
5657
    
5658
    if (!yyparse((void *)thd) && ! thd->is_fatal_error)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5659
    {
hf@deer.(none)'s avatar
hf@deer.(none) committed
5660
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5661
      if (mqh_used && thd->user_connect &&
5662
	  check_mqh(thd, lex->sql_command))
5663 5664 5665 5666
      {
	thd->net.error = 0;
      }
      else
hf@deer.(none)'s avatar
hf@deer.(none) committed
5667
#endif
5668
      {
5669
	if (thd->net.report_error)
5670 5671
	{
	  if (thd->lex->sphead)
5672 5673 5674 5675
	  {
	    delete thd->lex->sphead;
	    thd->lex->sphead= NULL;
	  }
andrey@lmy004's avatar
andrey@lmy004 committed
5676 5677
          if (thd->lex->et)
          {
andrey@lmy004's avatar
andrey@lmy004 committed
5678
            thd->lex->et->free_sphead_on_delete= true;
andrey@lmy004's avatar
andrey@lmy004 committed
5679 5680 5681
            delete thd->lex->et;
            thd->lex->et= NULL;
          }
5682
	}
5683 5684
	else
	{
5685 5686 5687 5688 5689 5690 5691 5692 5693 5694
          /*
            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
5695 5696
          if (lex->found_semicolon &&
              (thd->query_length= (ulong)(lex->found_semicolon - thd->query)))
5697 5698
            thd->query_length--;
          /* Actually execute the query */
5699
	  mysql_execute_command(thd);
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
5700
	  query_cache_end_of_result(thd);
5701
	}
5702
      }
5703
      lex->unit.cleanup();
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5704 5705
    }
    else
5706 5707
    {
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
5708
			 thd->is_fatal_error));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5709
      query_cache_abort(&thd->net);
5710
      lex->unit.cleanup();
5711
      if (thd->lex->sphead)
5712
      {
monty@mysql.com's avatar
monty@mysql.com committed
5713
	/* Clean up after failed stored procedure/function */
5714 5715 5716
	delete thd->lex->sphead;
	thd->lex->sphead= NULL;
      }
andrey@lmy004's avatar
andrey@lmy004 committed
5717 5718
      if (thd->lex->et)
      {
andrey@lmy004's avatar
andrey@lmy004 committed
5719
        thd->lex->et->free_sphead_on_delete= true;
andrey@lmy004's avatar
andrey@lmy004 committed
5720 5721 5722
        delete thd->lex->et;
        thd->lex->et= NULL;
      }
5723
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5724
    thd->proc_info="freeing items";
5725
    thd->end_statement();
5726
    thd->cleanup_after_query();
5727
    DBUG_ASSERT(thd->change_list.is_empty());
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5728
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5729 5730 5731 5732
  DBUG_VOID_RETURN;
}


monty@mysql.com's avatar
monty@mysql.com committed
5733
#ifdef HAVE_REPLICATION
5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744
/*
  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)
{
5745
  LEX *lex= thd->lex;
5746
  bool error= 0;
monty@mysql.com's avatar
monty@mysql.com committed
5747
  DBUG_ENTER("mysql_test_parse_for_slave");
5748

5749
  mysql_init_query(thd, (uchar*) inBuf, length);
monty@mysql.com's avatar
monty@mysql.com committed
5750
  if (!yyparse((void*) thd) && ! thd->is_fatal_error &&
5751
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
monty@mysql.com's avatar
monty@mysql.com committed
5752
    error= 1;                  /* Ignore question */
5753
  thd->end_statement();
5754
  thd->cleanup_after_query();
monty@mysql.com's avatar
monty@mysql.com committed
5755
  DBUG_RETURN(error);
5756
}
monty@mysql.com's avatar
monty@mysql.com committed
5757
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5758

5759

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5761 5762 5763 5764 5765
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5766
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
5767
		       char *length, char *decimals,
5768
		       uint type_modifier,
5769 5770
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
5771 5772
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
5773
		       uint uint_geom_type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5774 5775
{
  register create_field *new_field;
5776
  LEX  *lex= thd->lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5777 5778 5779 5780
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
5781
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5782 5783 5784 5785 5786
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
5787
    lex->key_list.push_back(new Key(Key::PRIMARY, NullS, HA_KEY_ALG_UNDEF,
5788
				    0, lex->col_list));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5789 5790 5791 5792 5793
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
5794
    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
5795 5796 5797 5798
				    lex->col_list));
    lex->col_list.empty();
  }

5799
  if (default_value)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5800
  {
5801
    /* 
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5802 5803
      Default value should be literal => basic constants =>
      no need fix_fields()
5804 5805 5806
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
5807
    */
5808 5809 5810
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
5811
    {
5812
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
5813 5814 5815
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5816
    {
5817
      default_value= 0;
5818 5819 5820
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
5821
	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
5822 5823 5824 5825 5826
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
5827
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5828 5829 5830
      DBUG_RETURN(1);
    }
  }
5831 5832 5833

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
5834
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
5835 5836
    DBUG_RETURN(1);
  }
5837

5838 5839 5840 5841 5842 5843
  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
5844
    char buf[32];
5845
    my_snprintf(buf, sizeof(buf), "TIMESTAMP(%s)", length);
5846 5847 5848
    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
5849
                        buf, "TIMESTAMP");
5850 5851
  }

5852 5853 5854 5855
  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
5856
    DBUG_RETURN(1);
5857 5858 5859 5860 5861 5862

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

5863

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5864 5865 5866 5867 5868 5869 5870 5871
/* Store position for column in ALTER TABLE .. ADD column */

void store_position_for_column(const char *name)
{
  current_lex->last_field->after=my_const_cast(char*) (name);
}

bool
5872
add_proc_to_list(THD* thd, Item *item)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5873 5874 5875 5876
{
  ORDER *order;
  Item	**item_ptr;

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5877
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5878 5879 5880 5881 5882
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
5883
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5884 5885 5886 5887 5888 5889 5890 5891
  return 0;
}


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

static void remove_escape(char *name)
{
5892 5893
  if (!*name)					// For empty DB names
    return;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5894 5895
  char *to;
#ifdef USE_MB
5896
  char *strend=name+(uint) strlen(name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5897 5898 5899 5900 5901
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
5902 5903
    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
5904 5905 5906 5907 5908 5909 5910 5911
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5912
      name++;					// Skip '\\'
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5913 5914 5915 5916 5917 5918 5919 5920 5921 5922
    *to++= *name;
  }
  *to=0;
}

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


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5923
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5924 5925 5926
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
5927
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5928
    DBUG_RETURN(1);
5929 5930
  order->item_ptr= item;
  order->item= &order->item_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5931 5932 5933
  order->asc = asc;
  order->free_me=0;
  order->used=0;
5934
  order->counter_used= 0;
5935
  list.link_in_list((byte*) order,(byte**) &order->next);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5936 5937 5938 5939
  DBUG_RETURN(0);
}


monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958
/*
  Add a table to list of used tables

  SYNOPSIS
    add_table_to_list()
    table		Table to add
    alias		alias for table (or null if no alias)
    table_options	A set of the following bits:
			TL_OPTION_UPDATING	Table will be updated
			TL_OPTION_FORCE_INDEX	Force usage of index
    lock_type		How table should be locked
    use_index		List of indexed used in USE INDEX
    ignore_index	List of indexed used in IGNORE INDEX

    RETURN
      0		Error
      #		Pointer to TABLE_LIST element added to the total table list
*/

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5959 5960
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
5961
					     LEX_STRING *alias,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5962 5963
					     ulong table_options,
					     thr_lock_type lock_type,
5964 5965
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5966
                                             LEX_STRING *option)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5967 5968
{
  register TABLE_LIST *ptr;
5969
  TABLE_LIST *previous_table_ref; /* The table preceding the current one. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5970
  char *alias_str;
5971
  LEX *lex= thd->lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5972
  DBUG_ENTER("add_table_to_list");
5973
  LINT_INIT(previous_table_ref);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5974 5975 5976 5977

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
5978
  if (check_table_name(table->table.str,table->table.length))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5979
  {
5980
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5981 5982
    DBUG_RETURN(0);
  }
5983 5984 5985 5986 5987
  if (table->db.str && check_db_name(table->db.str))
  {
    my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
    DBUG_RETURN(0);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5988 5989

  if (!alias)					/* Alias is case sensitive */
5990 5991 5992
  {
    if (table->sel)
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5993 5994
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
5995 5996
      DBUG_RETURN(0);
    }
5997
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5998
      DBUG_RETURN(0);
5999
  }
6000
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6001
    DBUG_RETURN(0);				/* purecov: inspected */
peter@mysql.com's avatar
peter@mysql.com committed
6002
  if (table->db.str)
6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013
  {
    ptr->db= table->db.str;
    ptr->db_length= table->db.length;
  }
  else if (thd->db)
  {
    ptr->db= thd->db;
    ptr->db_length= thd->db_length;
  }
  else
  {
6014 6015
    /* The following can't be "" as we may do 'casedn_str()' on it */
    ptr->db= empty_c_string;
6016 6017
    ptr->db_length= 0;
  }
konstantin@mysql.com's avatar
konstantin@mysql.com committed
6018
  if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
6019
    ptr->db= thd->strdup(ptr->db);
peter@mysql.com's avatar
peter@mysql.com committed
6020

6021
  ptr->alias= alias_str;
6022 6023
  if (lower_case_table_names && table->table.length)
    my_casedn_str(files_charset_info, table->table.str);
6024 6025
  ptr->table_name=table->table.str;
  ptr->table_name_length=table->table.length;
6026
  ptr->lock_type=   lock_type;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6027 6028
  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
6029
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
6030
  ptr->derived=	    table->sel;
6031 6032
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
                                      information_schema_name.str))
6033
  {
6034
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
6035 6036 6037
    if (!schema_table ||
        (schema_table->hidden && 
         lex->orig_sql_command == SQLCOM_END))  // not a 'show' command
6038
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6039
      my_error(ER_UNKNOWN_TABLE, MYF(0),
6040
               ptr->table_name, information_schema_name.str);
6041 6042
      DBUG_RETURN(0);
    }
6043
    ptr->schema_table_name= ptr->table_name;
6044 6045
    ptr->schema_table= schema_table;
  }
6046
  ptr->select_lex=  lex->current_select;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6047
  ptr->cacheable_table= 1;
6048 6049 6050 6051 6052 6053
  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
6054
  ptr->option= option ? option->str : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6055
  /* check that used name is unique */
6056
  if (lock_type != TL_IGNORE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6057
  {
timour@mysql.com's avatar
timour@mysql.com committed
6058 6059 6060 6061
    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 ;
6062
	 tables ;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6063
	 tables=tables->next_local)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6064
    {
6065 6066
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
6067
      {
6068
	my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
6069 6070
	DBUG_RETURN(0);				/* purecov: tested */
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6071 6072
    }
  }
6073 6074 6075
  /* Store the table reference preceding the current one. */
  if (table_list.elements > 0)
  {
6076 6077 6078 6079 6080 6081
    /*
      table_list.next points to the last inserted TABLE_LIST->next_local'
      element
    */
    previous_table_ref= (TABLE_LIST*) (table_list.next -
                                       offsetof(TABLE_LIST, next_local));
6082
    DBUG_ASSERT(previous_table_ref);
6083 6084 6085 6086 6087 6088 6089 6090
    /*
      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;
6091
  }
6092

6093 6094 6095 6096 6097 6098
  /*
    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
6099
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
6100
  ptr->next_name_resolution_table= NULL;
6101
  /* Link table in global list (all used tables) */
6102
  lex->add_to_query_tables(ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6103 6104 6105
  DBUG_RETURN(ptr);
}

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

6107 6108 6109 6110
/*
  Initialize a new table list for a nested join

  SYNOPSIS
6111
    init_nested_join()
6112
    thd         current thread
6113

6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132
  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");
6133

6134 6135
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6136
    DBUG_RETURN(1);
6137 6138 6139
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159
  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
6160
    moves it one level up, eliminating the nest.
6161 6162 6163 6164 6165 6166 6167 6168 6169

  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;
6170
  NESTED_JOIN *nested_join;
6171
  DBUG_ENTER("end_nested_join");
6172

6173
  DBUG_ASSERT(embedding);
6174 6175 6176
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
6177
  nested_join= ptr->nested_join;
6178 6179 6180 6181 6182 6183 6184 6185 6186
  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;
  }
6187
  else if (nested_join->join_list.elements == 0)
6188 6189
  {
    join_list->pop();
6190
    ptr= 0;                                     // return value
6191
  }
6192 6193 6194 6195 6196 6197 6198 6199
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
6200
    nest_last_join()
6201 6202 6203 6204 6205 6206
    thd         current thread

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

  RETURN VALUE
6207 6208 6209
    0  Error
    #  Pointer to TABLE_LIST element created for the new nested join

6210 6211 6212 6213 6214 6215
*/

TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
6216
  List<TABLE_LIST> *embedded_list;
6217
  DBUG_ENTER("nest_last_join");
6218

6219 6220
  if (!(ptr= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
                                       sizeof(NESTED_JOIN))))
6221
    DBUG_RETURN(0);
6222 6223 6224
  nested_join= ptr->nested_join=
    ((NESTED_JOIN*) ((byte*) ptr + ALIGN_SIZE(sizeof(TABLE_LIST))));

6225 6226
  ptr->embedding= embedding;
  ptr->join_list= join_list;
6227
  embedded_list= &nested_join->join_list;
6228
  embedded_list->empty();
6229 6230

  for (uint i=0; i < 2; i++)
6231 6232 6233 6234 6235
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248
    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;
      }
    }
6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288
  }
  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
6289 6290 6291

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314
    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
*/

6315
TABLE_LIST *st_select_lex::convert_right_join()
6316 6317
{
  TABLE_LIST *tab2= join_list->pop();
6318
  TABLE_LIST *tab1= join_list->pop();
6319 6320 6321 6322 6323 6324 6325 6326 6327
  DBUG_ENTER("convert_right_join");

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

  DBUG_RETURN(tab1);
}

6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340
/*
  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
*/

6341
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
6342 6343 6344 6345 6346 6347
{
  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
6348 6349 6350
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
6351 6352 6353 6354 6355 6356 6357
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

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

6359
/*
6360 6361
  Push a new name resolution context for a JOIN ... ON clause to the
  context stack of a query block.
6362 6363

  SYNOPSIS
6364
    push_new_name_resolution_context()
6365
    thd       pointer to current thread
timour@mysql.com's avatar
timour@mysql.com committed
6366
    left_op   left  operand of the JOIN
6367 6368 6369 6370
    right_op  rigth operand of the JOIN

  DESCRIPTION
    Create a new name resolution context for a JOIN ... ON clause,
6371 6372 6373
    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.
6374 6375

  RETURN
6376 6377
    FALSE  if all is OK
    TRUE   if a memory allocation error occured
6378 6379
*/

6380 6381 6382
bool
push_new_name_resolution_context(THD *thd,
                                 TABLE_LIST *left_op, TABLE_LIST *right_op)
6383 6384
{
  Name_resolution_context *on_context;
6385
  if (!(on_context= new (thd->mem_root) Name_resolution_context))
6386
    return TRUE;
6387 6388 6389 6390 6391
  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();
6392
  return thd->lex->push_context(on_context);
6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412
}


/*
  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
6413
{
6414
  if (expr)
6415
  {
6416
    if (!b->on_expr)
6417
      b->on_expr= expr;
6418 6419
    else
    {
6420 6421 6422 6423 6424 6425
      /*
        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);
6426 6427
    }
    b->on_expr->top_level_item();
6428
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6429 6430 6431
}


6432
/*
6433 6434
  Mark that there is a NATURAL JOIN or JOIN ... USING between two
  tables.
6435 6436 6437

  SYNOPSIS
    add_join_natural()
6438 6439 6440 6441
    a			Left join argument
    b			Right join argument
    using_fields        Field names from USING clause
  
6442
  IMPLEMENTATION
6443 6444 6445 6446 6447 6448 6449 6450 6451 6452
    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
6453 6454 6455
    SELECT * FROM t1 NATURAL LEFT JOIN t2
     <=>
    SELECT * FROM t1 LEFT JOIN t2 ON (t1.i=t2.i and t1.j=t2.j ... )
6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466

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

6469
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
6470
{
6471 6472
  b->natural_join= a;
  b->join_using_fields= using_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6473 6474
}

6475

6476
/*
6477 6478 6479 6480
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
6481
    thd			Thread handler (can be NULL!)
6482 6483 6484 6485 6486
    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
6487 6488 6489
                        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.
6490 6491 6492

  RETURN
    0	 ok
6493
    !=0  error.  thd->killed or thd->net.report_error is set
6494 6495
*/

6496 6497
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
6498 6499 6500
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
6501
  bool tmp_write_to_binlog= 1;
6502

6503
  if (thd && thd->in_sub_stmt)
6504 6505 6506 6507 6508
  {
    my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "FLUSH");
    return 1;
  }

hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
6509
#ifndef NO_EMBEDDED_ACCESS_CHECKS
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6510 6511
  if (options & REFRESH_GRANT)
  {
6512 6513 6514 6515 6516 6517
    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)))
6518 6519
    {
      thd->thread_stack= (char*) &tmp_thd;
6520
      thd->store_globals();
6521
    }
6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533
    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;
    }
6534
    reset_mqh((LEX_USER *)NULL, TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6535
  }
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
6536
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6537 6538
  if (options & REFRESH_LOG)
  {
6539
    /*
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6540
      Flush the normal query log, the update log, the binary log,
6541 6542
      the slow query log, the relay log (if it exists) and the log
      tables.
6543
    */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6544

6545
    /*
monty@mysql.com's avatar
monty@mysql.com committed
6546 6547 6548 6549
      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)
6550 6551
    */
    tmp_write_to_binlog= 0;
6552
    mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
6553
#ifdef HAVE_REPLICATION
6554
    pthread_mutex_lock(&LOCK_active_mi);
6555
    rotate_relay_log(active_mi);
6556
    pthread_mutex_unlock(&LOCK_active_mi);
6557
#endif
6558 6559 6560 6561

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

6562
    if (ha_flush_logs(NULL))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6563
      result=1;
6564 6565
    if (flush_error_log())
      result=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6566
  }
6567
#ifdef HAVE_QUERY_CACHE
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6568 6569
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
6570
    query_cache.pack();				// FLUSH QUERY CACHE
6571
    options &= ~REFRESH_QUERY_CACHE;    // Don't flush cache, just free memory
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6572 6573 6574
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
6575
    query_cache.flush();			// RESET QUERY CACHE
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6576
  }
6577
#endif /*HAVE_QUERY_CACHE*/
6578 6579 6580 6581 6582
  /*
    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
6583
  {
6584
    if ((options & REFRESH_READ_LOCK) && thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6585
    {
6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596
      /*
        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
6597
        {
6598 6599 6600 6601 6602
          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
6603
        }
6604
      }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
6605 6606 6607 6608
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
6609
      tmp_write_to_binlog= 0;
6610
      if (lock_global_read_lock(thd))
6611
	return 1;                               // Killed
6612 6613
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
6614
      if (make_global_read_lock_block_commit(thd)) // Killed
6615 6616 6617 6618 6619
      {
        /* 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
6620
    }
6621 6622
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
6623
    my_dbopt_cleanup();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6624 6625 6626
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
monty@mysql.com's avatar
monty@mysql.com committed
6627
  if (thd && (options & REFRESH_STATUS))
6628
    refresh_status(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6629 6630
  if (options & REFRESH_THREADS)
    flush_thread_cache();
6631
#ifdef HAVE_REPLICATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6632
  if (options & REFRESH_MASTER)
6633 6634
  {
    tmp_write_to_binlog= 0;
6635
    if (reset_master(thd))
6636
    {
6637
      result=1;
6638 6639
      thd->fatal_error();                       // Ensure client get error
    }
6640
  }
6641
#endif
6642
#ifdef OPENSSL
6643 6644 6645 6646 6647 6648
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
6649
#ifdef HAVE_REPLICATION
6650 6651
 if (options & REFRESH_SLAVE)
 {
6652
   tmp_write_to_binlog= 0;
6653
   pthread_mutex_lock(&LOCK_active_mi);
6654
   if (reset_slave(thd, active_mi))
6655
     result=1;
6656
   pthread_mutex_unlock(&LOCK_active_mi);
6657
 }
6658
#endif
6659
 if (options & REFRESH_USER_RESOURCES)
monty@mysql.com's avatar
monty@mysql.com committed
6660
   reset_mqh((LEX_USER *) NULL);
6661
 *write_to_binlog= tmp_write_to_binlog;
6662
 return result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6663 6664
}

6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676
/*
  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
6677
void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6678 6679 6680
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
6681 6682
  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
6683 6684
  while ((tmp=it++))
  {
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
6685 6686
    if (tmp->command == COM_DAEMON)
      continue;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6687 6688
    if (tmp->thread_id == id)
    {
6689 6690
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6691 6692 6693
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
6694 6695
  if (tmp)
  {
6696 6697
    if ((thd->security_ctx->master_access & SUPER_ACL) ||
	!strcmp(thd->security_ctx->user, tmp->security_ctx->user))
6698
    {
hf@genie.(none)'s avatar
SCRUM  
hf@genie.(none) committed
6699
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
6700 6701 6702 6703 6704 6705 6706
      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
6707
  if (!error)
6708
    send_ok(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6709
  else
6710
    my_error(error, MYF(0), id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6711 6712
}

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6714 6715
/* Clear most status variables */

6716
static void refresh_status(THD *thd)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6717 6718
{
  pthread_mutex_lock(&LOCK_status);
serg@serg.mylan's avatar
serg@serg.mylan committed
6719 6720 6721 6722 6723

  /* We must update the global status before cleaning up the thread */
  add_to_status(&global_status_var, &thd->status_var);
  bzero((char*) &thd->status_var, sizeof(thd->status_var));

6724 6725
  for (SHOW_VAR *ptr= status_vars; ptr->name; ptr++)
    if (ptr->type == SHOW_LONG) // note that SHOW_LONG_NOFLUSH variables are not reset
6726
      *(ulong*) ptr->value= 0;
6727

timour@mysql.com's avatar
timour@mysql.com committed
6728 6729
  /* Reset the counters of all key caches (default and named). */
  process_key_caches(reset_key_cache_counters);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6730 6731
  pthread_mutex_unlock(&LOCK_status);
}
6732 6733 6734 6735


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

6736 6737
bool append_file_to_dir(THD *thd, const char **filename_ptr,
                        const char *table_name)
6738
{
6739
  char buff[FN_REFLEN],*ptr, *end;
6740 6741 6742 6743 6744 6745 6746
  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))
  {
6747
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
6748 6749 6750 6751
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
6752
  end=convert_dirname(buff, *filename_ptr, NullS);
6753
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
6754 6755
    return 1;					// End of memory
  *filename_ptr=ptr;
6756
  strxmov(ptr,buff,table_name,NullS);
6757 6758
  return 0;
}
6759

6760

6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774
/*
  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;
6775 6776
  LEX *lex= thd->lex;
  if (lex->current_select != &lex->select_lex)
6777 6778
  {
    char command[80];
6779 6780
    strmake(command, lex->yylval->symbol.str,
	    min(lex->yylval->symbol.length, sizeof(command)-1));
6781
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
6782 6783 6784 6785
    return 1;
  }
  return 0;
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6786

6787

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6788
Comp_creator *comp_eq_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6789
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6790
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6791 6792
}

6793

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6794
Comp_creator *comp_ge_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6795
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6796
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6797 6798
}

6799

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6800
Comp_creator *comp_gt_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6801
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6802
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6803 6804
}

6805

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6806
Comp_creator *comp_le_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6807
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6808
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6809 6810
}

6811

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6812
Comp_creator *comp_lt_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6813
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6814
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6815 6816
}

6817

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6818
Comp_creator *comp_ne_creator(bool invert)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6819
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6820
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6821
}
6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841


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

  if ((cmp == &comp_ne_creator) && all)        // <> ALL <=> NOT IN
6846 6847 6848
    return new Item_func_not(new Item_in_subselect(left_expr, select_lex));

  Item_allany_subselect *it=
6849
    new Item_allany_subselect(left_expr, (*cmp)(all), select_lex, all);
6850
  if (all)
6851
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
6852

6853
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
6854
}
6855 6856


6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868
/*
  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.
*/

6869
bool mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
6870 6871
{
  List<create_field> fields;
6872 6873
  ALTER_INFO alter_info;
  alter_info.flags= ALTER_ADD_INDEX;
6874 6875 6876
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_create_index");
  bzero((char*) &create_info,sizeof(create_info));
6877
  create_info.db_type= (handlerton*) &default_hton;
6878
  create_info.default_table_charset= thd->variables.collation_database;
6879
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
6880
				&create_info, table_list,
6881
				fields, keys, 0, (ORDER*)0,
monty@mysql.com's avatar
monty@mysql.com committed
6882
				DUP_ERROR, 0, &alter_info, 1));
6883 6884 6885
}


6886
bool mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
6887 6888 6889 6890 6891 6892
{
  List<create_field> fields;
  List<Key> keys;
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_drop_index");
  bzero((char*) &create_info,sizeof(create_info));
6893
  create_info.db_type= (handlerton*) &default_hton;
6894
  create_info.default_table_charset= thd->variables.collation_database;
6895 6896
  alter_info->clear();
  alter_info->flags= ALTER_DROP_INDEX;
6897
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
6898
				&create_info, table_list,
6899
				fields, keys, 0, (ORDER*)0,
monty@mysql.com's avatar
monty@mysql.com committed
6900
				DUP_ERROR, 0, alter_info, 1));
6901
}
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
6902 6903


6904 6905 6906 6907 6908
/*
  Multi update query pre-check

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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6912
  RETURN VALUE
6913 6914
    FALSE OK
    TRUE  Error
6915
*/
6916

6917
bool multi_update_precheck(THD *thd, TABLE_LIST *tables)
6918 6919 6920 6921 6922
{
  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
6923
  DBUG_ENTER("multi_update_precheck");
6924 6925 6926

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
6927
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
6928
    DBUG_RETURN(TRUE);
6929 6930 6931 6932 6933
  }
  /*
    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
6934
  for (table= tables; table; table= table->next_local)
6935
  {
6936 6937 6938
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
6939 6940
                           &table->grant.privilege, 0, 1,
                           test(table->schema_table)) ||
6941 6942
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
monty@mysql.com's avatar
monty@mysql.com committed
6943
             (check_access(thd, SELECT_ACL, table->db,
6944 6945
                           &table->grant.privilege, 0, 0,
                           test(table->schema_table)) ||
monty@mysql.com's avatar
monty@mysql.com committed
6946
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
6947
      DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6948

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6949
    table->table_in_first_from_clause= 1;
6950
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6951 6952 6953
  /*
    Is there tables of subqueries?
  */
6954
  if (&lex->select_lex != lex->all_selects_list || lex->time_zone_tables_used)
6955
  {
6956
    DBUG_PRINT("info",("Checking sub query list"));
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
6957
    for (table= tables; table; table= table->next_global)
6958
    {
monty@mysql.com's avatar
monty@mysql.com committed
6959 6960 6961
      if (!my_tz_check_n_skip_implicit_tables(&table,
                                              lex->time_zone_tables_used) &&
          !table->table_in_first_from_clause)
6962 6963
      {
	if (check_access(thd, SELECT_ACL, table->db,
6964 6965
			 &table->grant.privilege, 0, 0,
                         test(table->schema_table)) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6966
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
6967
	  DBUG_RETURN(TRUE);
6968 6969 6970 6971 6972 6973
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
6974
  else if (select_lex->select_limit)
6975 6976 6977 6978
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
6979
    DBUG_RETURN(TRUE);
6980
  }
6981
  DBUG_RETURN(FALSE);
6982 6983 6984 6985 6986 6987 6988
}

/*
  Multi delete query pre-check

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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6992
  RETURN VALUE
6993 6994
    FALSE OK
    TRUE  error
6995
*/
6996

6997
bool multi_delete_precheck(THD *thd, TABLE_LIST *tables)
6998 6999 7000 7001
{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  TABLE_LIST *aux_tables=
    (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7002
  DBUG_ENTER("multi_delete_precheck");
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7003

7004 7005 7006 7007 7008
  /* sql_yacc guarantees that tables and aux_tables are not zero */
  DBUG_ASSERT(aux_tables != 0);
  if (check_db_used(thd, tables) || check_db_used(thd,aux_tables) ||
      check_table_access(thd,SELECT_ACL, tables,0) ||
      check_table_access(thd,DELETE_ACL, aux_tables,0))
7009
    DBUG_RETURN(TRUE);
7010 7011
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7012 7013
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
7014
    DBUG_RETURN(TRUE);
7015
  }
7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042
  DBUG_RETURN(FALSE);
}


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

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

  RETURN VALUE
    FALSE - success
    TRUE  - error
*/

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

  lex->table_count= 0;

  for (target_tbl= (TABLE_LIST *)lex->auxilliary_table_list.first;
       target_tbl; target_tbl= target_tbl->next_local)
7043
  {
7044
    lex->table_count++;
7045 7046
    /* 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
7047
    for (walk= tables; walk; walk= walk->next_local)
7048
    {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7049 7050 7051
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
7052 7053 7054 7055
	break;
    }
    if (!walk)
    {
7056
      my_error(ER_UNKNOWN_TABLE, MYF(0),
7057
               target_tbl->table_name, "MULTI DELETE");
7058
      DBUG_RETURN(TRUE);
7059
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
7060 7061 7062 7063 7064
    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
7065
    walk->updating= target_tbl->updating;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7066
    walk->lock_type= target_tbl->lock_type;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
7067
    target_tbl->correspondent_table= walk;	// Remember corresponding table
7068
  }
7069
  DBUG_RETURN(FALSE);
7070 7071 7072
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7073 7074 7075 7076 7077
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
7078 7079
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7080 7081

  RETURN VALUE
7082 7083
    FALSE OK
    TRUE  Error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7084
*/
7085

7086
bool update_precheck(THD *thd, TABLE_LIST *tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7087 7088 7089 7090
{
  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
7091
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
7092
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7093
  }
7094 7095
  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
7096 7097 7098 7099 7100 7101 7102 7103
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
7104 7105
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7106 7107

  RETURN VALUE
7108 7109
    FALSE  OK
    TRUE   error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7110
*/
7111

7112
bool delete_precheck(THD *thd, TABLE_LIST *tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7113 7114 7115
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
7116
    DBUG_RETURN(TRUE);
7117
  /* Set privilege for the WHERE clause */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7118
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
7119
  DBUG_RETURN(FALSE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7120 7121 7122 7123 7124 7125 7126 7127
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
7128 7129
    thd		Thread handler
    tables	Global table list
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7130 7131

  RETURN VALUE
7132 7133
    FALSE  OK
    TRUE   error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7134
*/
7135

bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7136
bool insert_precheck(THD *thd, TABLE_LIST *tables)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7137 7138 7139 7140
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

7141 7142 7143 7144
  /*
    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
7145 7146 7147
  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
7148 7149

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

7152
  if (lex->update_list.elements != lex->value_list.elements)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7153
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7154
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
7155
    DBUG_RETURN(TRUE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7156
  }
7157
  DBUG_RETURN(FALSE);
7158
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7159 7160 7161 7162 7163 7164 7165


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
7166 7167 7168
    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
7169 7170

  RETURN VALUE
7171 7172
    FALSE   OK
    TRUE   Error
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7173
*/
7174

7175 7176
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
7177 7178
{
  LEX *lex= thd->lex;
7179 7180
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
7181
  bool error= TRUE;                                 // Error message is given
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7182
  DBUG_ENTER("create_table_precheck");
7183 7184 7185

  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
7186 7187
  lex->create_info.alias= create_table->alias;
  if (check_access(thd, want_priv, create_table->db,
7188 7189
		   &create_table->grant.privilege, 0, 0,
                   test(create_table->schema_table)) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7190 7191 7192
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
7193 7194 7195 7196 7197 7198 7199 7200 7201
    goto err;
  if (grant_option && want_priv != CREATE_TMP_ACL &&
      check_grant(thd, want_priv, create_table, 0, UINT_MAX, 0))
    goto err;

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

7202 7203
#ifdef NOT_NECESSARY_TO_CHECK_CREATE_TABLE_EXIST_WHEN_PREPARING_STATEMENT
    /* This code throws an ill error for CREATE TABLE t1 SELECT * FROM t1 */
7204
    /*
monty@mysql.com's avatar
monty@mysql.com committed
7205 7206 7207
      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).
7208
    */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
7209
    if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
7210
    {
monty@mysql.com's avatar
monty@mysql.com committed
7211 7212 7213 7214
      /*
        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
7215
          find_table_in_global_list(tables, create_table->db,
7216
                                    create_table->table_name))
monty@mysql.com's avatar
monty@mysql.com committed
7217
      {
7218
	error= FALSE;
monty@mysql.com's avatar
monty@mysql.com committed
7219 7220 7221
        goto err;
      }
    }
7222
#endif
7223 7224 7225
    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
7226
  error= FALSE;
7227 7228 7229

err:
  DBUG_RETURN(error);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7230
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7231 7232 7233 7234 7235 7236 7237


/*
  negate given expression

  SYNOPSIS
    negate_expression()
7238
    thd  thread handler
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266
    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);
}
7267

7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306
/*
  Set the specified definer to the default value, which is the current user in
  the thread. Also check that the current user satisfies to the definers
  requirements.
 
  SYNOPSIS
    get_default_definer()
    thd       [in] thread handler
    definer   [out] definer
 
  RETURN
    error status, that is:
      - FALSE -- on success;
      - TRUE -- on error (current user can not be a definer).
*/
 
bool get_default_definer(THD *thd, LEX_USER *definer)
{
  /* Check that current user has non-empty host name. */

  const Security_context *sctx= thd->security_ctx;

  if (sctx->priv_host[0] == 0)
  {
    my_error(ER_MALFORMED_DEFINER, MYF(0));
    return TRUE;
  }

  /* Fill in. */

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

  return FALSE;
}

7307 7308

/*
7309 7310
  Create definer with the given user and host names. Also check that the user
  and host names satisfy definers requirements.
7311 7312

  SYNOPSIS
7313 7314 7315 7316
    create_definer()
    thd         [in] thread handler
    user_name   [in] user name
    host_name   [in] host name
7317 7318

  RETURN
7319 7320 7321
    On success, return a valid pointer to the created and initialized
    LEX_STRING, which contains definer information.
    On error, return 0.
7322 7323
*/

7324
LEX_USER *create_definer(THD *thd, LEX_STRING *user_name, LEX_STRING *host_name)
7325
{
7326 7327 7328
  LEX_USER *definer;

  /* Check that specified host name is valid. */
7329

7330
  if (host_name->length == 0)
7331
  {
7332 7333
    my_error(ER_MALFORMED_DEFINER, MYF(0));
    return 0;
7334
  }
7335

7336 7337
  /* Create and initialize. */

7338
  if (! (definer= (LEX_USER*) thd->alloc(sizeof(LEX_USER))))
7339 7340 7341 7342 7343 7344
    return 0;

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

  return definer;
7345
}