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

unknown's avatar
unknown 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

unknown's avatar
unknown 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

unknown's avatar
unknown 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"
19
#include "repl_failsafe.h"
unknown's avatar
unknown committed
20 21 22 23
#include <m_ctype.h>
#include <myisam.h>
#include <my_dir.h>

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

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

46 47 48
#ifdef SOLARIS
extern "C" int gethostname(char *name, int namelen);
#endif
unknown's avatar
unknown committed
49

50
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
unknown's avatar
unknown committed
51
#ifndef NO_EMBEDDED_ACCESS_CHECKS
52
static int check_for_max_user_connections(THD *thd, USER_CONN *uc);
unknown's avatar
unknown committed
53
#endif
54
static void decrease_user_connections(USER_CONN *uc);
unknown's avatar
unknown committed
55
static bool check_db_used(THD *thd,TABLE_LIST *tables);
unknown's avatar
unknown committed
56
static bool check_multi_update_lock(THD *thd, TABLE_LIST *tables, 
unknown's avatar
unknown committed
57
				    List<Item> *fields, SELECT_LEX *select_lex);
unknown's avatar
unknown committed
58 59
static void remove_escape(char *name);
static void refresh_status(void);
unknown's avatar
unknown committed
60 61
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name);
62 63 64
             
static TABLE_LIST* get_table_by_alias(TABLE_LIST* tl, const char* db,
  const char* alias);      
unknown's avatar
unknown committed
65

66
const char *any_db="*any*";	// Special symbol for check_access
unknown's avatar
unknown committed
67 68 69 70

const char *command_name[]={
  "Sleep", "Quit", "Init DB", "Query", "Field List", "Create DB",
  "Drop DB", "Refresh", "Shutdown", "Statistics", "Processlist",
71
  "Connect","Kill","Debug","Ping","Time","Delayed insert","Change user",
unknown's avatar
unknown committed
72
  "Binlog Dump","Table Dump",  "Connect Out", "Register Slave",
73
  "Prepare", "Execute", "Long Data", "Close stmt",
74
  "Reset stmt", "Set option",
75
  "Error"					// Last command number
unknown's avatar
unknown committed
76 77
};

78
static char empty_c_string[1]= {0};		// Used for not defined 'db'
unknown's avatar
unknown committed
79 80 81 82

#ifdef __WIN__
static void  test_signal(int sig_ptr)
{
unknown's avatar
unknown committed
83
#if !defined( DBUG_OFF)
unknown's avatar
unknown committed
84 85
  MessageBox(NULL,"Test signal","DBUG",MB_OK);
#endif
unknown's avatar
unknown committed
86
#if defined(OS2)
87 88
  fprintf(stderr, "Test signal %d\n", sig_ptr);
  fflush(stderr);
unknown's avatar
unknown committed
89
#endif
unknown's avatar
unknown committed
90 91 92 93
}
static void init_signals(void)
{
  int signals[7] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGBREAK,SIGABRT } ;
94
  for (int i=0 ; i < 7 ; i++)
unknown's avatar
unknown committed
95 96 97 98
    signal( signals[i], test_signal) ;
}
#endif

unknown's avatar
unknown committed
99 100 101 102 103 104 105 106 107 108
static void unlock_locked_tables(THD *thd)
{
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
    thd->locked_tables=0;			// Will be automaticly closed
    close_thread_tables(thd);			// Free tables
  }
}

109

unknown's avatar
unknown committed
110
static bool end_active_trans(THD *thd)
111
{
unknown's avatar
unknown committed
112
  int error=0;
unknown's avatar
unknown committed
113
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
unknown's avatar
unknown committed
114
		      OPTION_TABLE_LOCK))
115
  {
116 117
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
118
    if (ha_commit(thd))
unknown's avatar
unknown committed
119
      error=1;
120
  }
unknown's avatar
unknown committed
121
  return error;
122 123 124
}


unknown's avatar
unknown committed
125
#ifdef HAVE_REPLICATION
126 127 128
/*
  Returns true if all tables should be ignored
*/
129 130
inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables)
{
131
  return (table_rules_on && tables && !tables_ok(thd,tables));
132
}
unknown's avatar
unknown committed
133
#endif
134 135


136 137
static HASH hash_user_connections;

unknown's avatar
unknown committed
138 139
static int get_or_create_user_conn(THD *thd, const char *user,
				   const char *host,
unknown's avatar
unknown committed
140
				   USER_RESOURCES *mqh)
141
{
142
  int return_val= 0;
unknown's avatar
unknown committed
143
  uint temp_len, user_len;
144 145 146 147 148 149
  char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];
  struct  user_conn *uc;

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

150
  user_len= strlen(user);
151
  temp_len= (strmov(strmov(temp_user, user)+1, host) - temp_user)+1;
152
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
153 154
  if (!(uc = (struct  user_conn *) hash_search(&hash_user_connections,
					       (byte*) temp_user, temp_len)))
155
  {
unknown's avatar
unknown committed
156 157 158
    /* First connection for user; Create a user connection object */
    if (!(uc= ((struct user_conn*)
	       my_malloc(sizeof(struct user_conn) + temp_len+1,
unknown's avatar
unknown committed
159 160
			 MYF(MY_WME)))))
    {
161
      send_error(thd, 0, NullS);		// Out of memory
162
      return_val= 1;
163
      goto end;
unknown's avatar
unknown committed
164
    }
165 166
    uc->user=(char*) (uc+1);
    memcpy(uc->user,temp_user,temp_len+1);
167
    uc->user_len= user_len;
168 169 170 171 172 173
    uc->host= uc->user + uc->user_len +  1;
    uc->len= temp_len;
    uc->connections= 0;
    uc->questions= uc->updates= uc->conn_per_hour=0;
    uc->user_resources= *mqh;
    uc->intime= thd->thr_create_time;
unknown's avatar
SCRUM  
unknown committed
174
    if (my_hash_insert(&hash_user_connections, (byte*) uc))
175 176
    {
      my_free((char*) uc,0);
177
      send_error(thd, 0, NullS);		// Out of memory
178
      return_val= 1;
179 180 181 182
      goto end;
    }
  }
  thd->user_connect=uc;
183
  uc->connections++;
184 185 186
end:
  (void) pthread_mutex_unlock(&LOCK_user_conn);
  return return_val;
unknown's avatar
unknown committed
187

188
}
189 190 191


/*
192
    Check if user exist and password supplied is correct. 
193 194
  SYNOPSIS
    check_user()
195 196 197 198 199 200 201 202 203
    thd          thread handle, thd->{host,user,ip} are used
    command      originator of the check: now check_user is called
                 during connect and change user procedures; used for 
                 logging.
    passwd       scrambled password recieved from client
    passwd_len   length of scrambled password
    db           database name to connect to, may be NULL
    check_count  dont know exactly

204 205
    Note, that host, user and passwd may point to communication buffer.
    Current implementation does not depened on that, but future changes
206 207 208
    should be done with this in mind; 'thd' is INOUT, all other params
    are 'IN'.

209 210 211
  RETURN VALUE
    0  OK; thd->user, thd->master_access, thd->priv_user, thd->db and
       thd->db_access are updated; OK is sent to client;
unknown's avatar
unknown committed
212 213
   -1  access denied or handshake error; error is sent to client;
   >0  error, not sent to client
unknown's avatar
unknown committed
214 215
*/

unknown's avatar
unknown committed
216 217 218
int check_user(THD *thd, enum enum_server_command command, 
	       const char *passwd, uint passwd_len, const char *db,
	       bool check_count)
unknown's avatar
unknown committed
219
{
220
  DBUG_ENTER("check_user");
unknown's avatar
unknown committed
221
  
unknown's avatar
unknown committed
222 223
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  thd->master_access= GLOBAL_ACLS;			// Full rights
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
  /* Change database if necessary: OK or FAIL is sent in mysql_change_db */
  if (db && db[0])
  {
    thd->db= 0;
    thd->db_length= 0;
    if (mysql_change_db(thd, db))
    {
      if (thd->user_connect)
	decrease_user_connections(thd->user_connect);
      DBUG_RETURN(-1);
    }
  }
  else
    send_ok(thd);
  DBUG_RETURN(0);
unknown's avatar
unknown committed
239 240
#else

241 242 243 244 245
  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);
  
246
  /*
247 248
    If the server is running in secure auth mode, short scrambles are 
    forbidden.
249
  */
250
  if (opt_secure_auth_local && passwd_len == SCRAMBLE_LENGTH_323)
unknown's avatar
unknown committed
251
  {
252 253 254
    net_printf(thd, ER_NOT_SUPPORTED_AUTH_MODE);
    mysql_log.write(thd, COM_CONNECT, ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
255
  }
unknown's avatar
unknown committed
256 257 258 259
  if (passwd_len != 0 &&
      passwd_len != SCRAMBLE_LENGTH &&
      passwd_len != SCRAMBLE_LENGTH_323)
    DBUG_RETURN(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
260

261
  /*
262 263 264 265
    Clear thd->db as it points to something, that will be freed when 
    connection is closed. We don't want to accidently free a wrong pointer
    if connect failed. Also in case of 'CHANGE USER' failure, current
    database will be switched to 'no database selected'.
266
  */
267 268
  thd->db= 0;
  thd->db_length= 0;
unknown's avatar
unknown committed
269
  
270
  USER_RESOURCES ur;
271
  int res= acl_getroot(thd, &ur, passwd, passwd_len);
unknown's avatar
unknown committed
272
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
273
  if (res == -1)
unknown's avatar
unknown committed
274
  {
unknown's avatar
unknown committed
275 276 277 278 279 280
    /*
      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.
    */
281
    NET *net= &thd->net;
282
    if (opt_secure_auth_local)
283
    {
284 285 286 287 288 289
      net_printf(thd, ER_SERVER_IS_IN_SECURE_AUTH_MODE,
                 thd->user, thd->host_or_ip);
      mysql_log.write(thd, COM_CONNECT, ER(ER_SERVER_IS_IN_SECURE_AUTH_MODE),
                      thd->user, thd->host_or_ip);
      DBUG_RETURN(-1);
    }
290
    if (send_old_password_request(thd) ||
unknown's avatar
unknown committed
291 292 293 294 295 296 297
        my_net_read(net) != SCRAMBLE_LENGTH_323 + 1) // We have to read very
    {                                                // specific packet size
      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 */
298
    res= acl_getroot(thd, &ur, (char *) net->read_pos, SCRAMBLE_LENGTH_323);
unknown's avatar
unknown committed
299
  }
unknown's avatar
unknown committed
300
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
301 302
  /* here res is always >= 0 */
  if (res == 0)
unknown's avatar
unknown committed
303
  {
unknown's avatar
unknown committed
304
    if (!(thd->master_access & NO_ACCESS)) // authentification is OK 
305
    {
unknown's avatar
unknown committed
306 307 308 309 310 311 312 313 314 315
      DBUG_PRINT("info",
                 ("Capabilities: %d  packet_length: %ld  Host: '%s'  "
                  "Login user: '%s' Priv_user: '%s'  Using password: %s "
                  "Access: %u  db: '%s'",
                  thd->client_capabilities, thd->max_client_packet_length,
                  thd->host_or_ip, thd->user, thd->priv_user,
                  passwd_len ? "yes": "no",
                  thd->master_access, thd->db ? thd->db : "*none*"));

      if (check_count)
316
      {
unknown's avatar
unknown committed
317 318
        VOID(pthread_mutex_lock(&LOCK_thread_count));
        bool count_ok= thread_count < max_connections + delayed_insert_threads
319
                       || (thd->master_access & SUPER_ACL);
unknown's avatar
unknown committed
320 321 322 323 324 325
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
        if (!count_ok)
        {                                         // too many connections 
          send_error(thd, ER_CON_COUNT_ERROR);
          DBUG_RETURN(-1);
        }
326
      }
unknown's avatar
unknown committed
327

unknown's avatar
unknown committed
328 329 330 331 332 333 334 335
      /* Why logging is performed before all checks've passed? */
      mysql_log.write(thd,command,
                      (thd->priv_user == thd->user ?
                       (char*) "%s@%s on %s" :
                       (char*) "%s@%s as anonymous on %s"),
                      thd->user, thd->host_or_ip,
                      db ? db : (char*) "");

336
      /*
337 338 339
        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.
340
      */
unknown's avatar
unknown committed
341 342 343
      thd->db_access=0;

      /* Don't allow user to connect if he has done too many queries */
unknown's avatar
unknown committed
344 345 346 347 348 349 350 351 352
      if ((ur.questions || ur.updates || ur.connections ||
	   max_user_connections) &&
	  get_or_create_user_conn(thd,thd->user,thd->host_or_ip,&ur))
	DBUG_RETURN(-1);
      if (thd->user_connect &&
	  (thd->user_connect->user_resources.connections ||
	   max_user_connections) &&
	  check_for_max_user_connections(thd, thd->user_connect))
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
353 354 355

      /* Change database if necessary: OK or FAIL is sent in mysql_change_db */
      if (db && db[0])
356
      {
unknown's avatar
unknown committed
357 358 359 360 361 362
        if (mysql_change_db(thd, db))
        {
          if (thd->user_connect)
            decrease_user_connections(thd->user_connect);
          DBUG_RETURN(-1);
        }
363 364
      }
      else
unknown's avatar
unknown committed
365
	send_ok(thd);
unknown's avatar
unknown committed
366 367 368
      thd->password= test(passwd_len);          // remember for error messages 
      /* Ready to handle queries */
      DBUG_RETURN(0);
unknown's avatar
unknown committed
369 370
    }
  }
unknown's avatar
unknown committed
371
  else if (res == 2) // client gave short hash, server has long hash
unknown's avatar
unknown committed
372
  {
unknown's avatar
unknown committed
373 374 375
    net_printf(thd, ER_NOT_SUPPORTED_AUTH_MODE);
    mysql_log.write(thd,COM_CONNECT,ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
376
  }
unknown's avatar
unknown committed
377 378 379 380 381 382 383 384 385
  net_printf(thd, ER_ACCESS_DENIED_ERROR,
             thd->user,
             thd->host_or_ip,
             passwd_len ? ER(ER_YES) : ER(ER_NO));
  mysql_log.write(thd, COM_CONNECT, ER(ER_ACCESS_DENIED_ERROR),
                  thd->user,
                  thd->host_or_ip,
                  passwd_len ? ER(ER_YES) : ER(ER_NO));
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
386
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
387 388
}

unknown's avatar
unknown committed
389
/*
unknown's avatar
unknown committed
390 391
  Check for maximum allowable user connections, if the mysqld server is
  started with corresponding variable that is greater then 0.
unknown's avatar
unknown committed
392 393
*/

394 395
extern "C" byte *get_key_conn(user_conn *buff, uint *length,
			      my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
396 397 398 399 400
{
  *length=buff->len;
  return (byte*) buff->user;
}

401
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
402 403 404 405
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
406
void init_max_user_conn(void)
unknown's avatar
unknown committed
407
{
unknown's avatar
unknown committed
408 409
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
410
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
411
		   0);
unknown's avatar
unknown committed
412 413 414
}


unknown's avatar
unknown committed
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
/*
  check if user has already too many connections
  
  SYNOPSIS
  check_for_max_user_connections()
  thd			Thread handle
  uc			User connect object

  NOTES
    If check fails, we decrease user connection count, which means one
    shouldn't call decrease_user_connections() after this function.

  RETURN
    0	ok
    1	error
*/

unknown's avatar
unknown committed
432 433
#ifndef NO_EMBEDDED_ACCESS_CHECKS

434
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
435
{
436
  int error=0;
437
  DBUG_ENTER("check_for_max_user_connections");
unknown's avatar
unknown committed
438

439
  (void) pthread_mutex_lock(&LOCK_user_conn);
440
  if (max_user_connections &&
unknown's avatar
unknown committed
441
      max_user_connections < (uint) uc->connections)
unknown's avatar
unknown committed
442
  {
443
    net_printf(thd,ER_TOO_MANY_USER_CONNECTIONS, uc->user);
444 445
    error=1;
    goto end;
unknown's avatar
unknown committed
446
  }
447
  time_out_user_resource_limits(thd, uc);
448
  if (uc->user_resources.connections &&
449
      uc->user_resources.connections <= uc->conn_per_hour)
450
  {
451
    net_printf(thd, ER_USER_LIMIT_REACHED, uc->user,
452
	       "max_connections_per_hour",
453 454 455 456
	       (long) uc->user_resources.connections);
    error=1;
    goto end;
  }
457
  uc->conn_per_hour++;
unknown's avatar
unknown committed
458 459

  end:
460 461
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
462
  (void) pthread_mutex_unlock(&LOCK_user_conn);
463
  DBUG_RETURN(error);
unknown's avatar
unknown committed
464
}
unknown's avatar
unknown committed
465
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
466

unknown's avatar
unknown committed
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
/*
  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.
*/

485
static void decrease_user_connections(USER_CONN *uc)
unknown's avatar
unknown committed
486
{
487
  DBUG_ENTER("decrease_user_connections");
488 489 490
  (void) pthread_mutex_lock(&LOCK_user_conn);
  DBUG_ASSERT(uc->connections);
  if (!--uc->connections && !mqh_used)
unknown's avatar
unknown committed
491 492
  {
    /* Last connection for user; Delete it */
unknown's avatar
unknown committed
493
    (void) hash_delete(&hash_user_connections,(byte*) uc);
unknown's avatar
unknown committed
494
  }
495
  (void) pthread_mutex_unlock(&LOCK_user_conn);
496
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
497 498
}

499

unknown's avatar
unknown committed
500 501 502 503 504
void free_max_user_conn(void)
{
  hash_free(&hash_user_connections);
}

unknown's avatar
unknown committed
505

506 507 508
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
unknown's avatar
unknown committed
509 510 511

  sql_command is actually set to SQLCOM_END sometimes
  so we need the +1 to include it in the array.
512 513
*/

unknown's avatar
unknown committed
514
char  uc_update_queries[SQLCOM_END+1];
515 516 517

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

520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
  uc_update_queries[SQLCOM_UPDATE]=1;
  uc_update_queries[SQLCOM_INSERT]=1;
  uc_update_queries[SQLCOM_INSERT_SELECT]=1;
  uc_update_queries[SQLCOM_DELETE]=1;
  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;
  uc_update_queries[SQLCOM_REPLACE]=1;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=1;
  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_DELETE_MULTI]=1;
  uc_update_queries[SQLCOM_DROP_INDEX]=1;
539
  uc_update_queries[SQLCOM_UPDATE_MULTI]=1;
540 541
}

unknown's avatar
unknown committed
542 543
bool is_update_query(enum enum_sql_command command)
{
unknown's avatar
unknown committed
544
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
unknown's avatar
unknown committed
545 546
  return uc_update_queries[command];
}
547

unknown's avatar
unknown committed
548
/*
549 550
  Reset per-hour user resource limits when it has been more than
  an hour since they were last checked
unknown's avatar
unknown committed
551

552 553 554 555
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
unknown's avatar
unknown committed
556

557 558 559 560
  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.
*/
561

562
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
563
{
unknown's avatar
unknown committed
564
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
565
  DBUG_ENTER("time_out_user_resource_limits");
unknown's avatar
unknown committed
566

unknown's avatar
unknown committed
567
  /* If more than a hour since last check, reset resource checking */
568 569 570 571 572 573 574
  if (check_time  - uc->intime >= 3600)
  {
    uc->questions=1;
    uc->updates=0;
    uc->conn_per_hour=0;
    uc->intime=check_time;
  }
575 576 577 578 579 580 581 582 583 584 585 586

  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)
{
587 588
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  bool error= 0;
589 590 591 592 593 594 595 596
  USER_CONN *uc=thd->user_connect;
  DBUG_ENTER("check_mqh");
  DBUG_ASSERT(uc != 0);

  (void) pthread_mutex_lock(&LOCK_user_conn);

  time_out_user_resource_limits(thd, uc);

unknown's avatar
unknown committed
597
  /* Check that we have not done too many questions / hour */
598 599 600
  if (uc->user_resources.questions &&
      uc->questions++ >= uc->user_resources.questions)
  {
601
    net_printf(thd, ER_USER_LIMIT_REACHED, uc->user, "max_questions",
602 603 604 605
	       (long) uc->user_resources.questions);
    error=1;
    goto end;
  }
606
  if (check_command < (uint) SQLCOM_END)
unknown's avatar
unknown committed
607
  {
unknown's avatar
unknown committed
608 609 610 611
    /* 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)
    {
612
      net_printf(thd, ER_USER_LIMIT_REACHED, uc->user, "max_updates",
unknown's avatar
unknown committed
613 614 615 616
		 (long) uc->user_resources.updates);
      error=1;
      goto end;
    }
unknown's avatar
unknown committed
617 618
  }
end:
619
  (void) pthread_mutex_unlock(&LOCK_user_conn);
620
  DBUG_RETURN(error);
621 622
#else
  return (0);
unknown's avatar
unknown committed
623
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
624 625
}

unknown's avatar
unknown committed
626

unknown's avatar
unknown committed
627
static void reset_mqh(THD *thd, LEX_USER *lu, bool get_them= 0)
628
{
unknown's avatar
unknown committed
629
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
630
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
631
  if (lu)  // for GRANT
632
  {
633
    USER_CONN *uc;
634
    uint temp_len=lu->user.length+lu->host.length+2;
635 636
    char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];

unknown's avatar
unknown committed
637 638
    memcpy(temp_user,lu->user.str,lu->user.length);
    memcpy(temp_user+lu->user.length+1,lu->host.str,lu->host.length);
639
    temp_user[lu->user.length]='\0'; temp_user[temp_len-1]=0;
unknown's avatar
unknown committed
640
    if ((uc = (struct  user_conn *) hash_search(&hash_user_connections,
641
						(byte*) temp_user, temp_len)))
642 643
    {
      uc->questions=0;
644
      get_mqh(temp_user,&temp_user[lu->user.length+1],uc);
645 646
      uc->updates=0;
      uc->conn_per_hour=0;
647 648
    }
  }
649
  else // for FLUSH PRIVILEGES and FLUSH USER_RESOURCES
650
  {
unknown's avatar
unknown committed
651
    for (uint idx=0;idx < hash_user_connections.records; idx++)
652
    {
unknown's avatar
unknown committed
653 654
      USER_CONN *uc=(struct user_conn *) hash_element(&hash_user_connections,
						      idx);
655 656 657 658 659
      if (get_them)
	get_mqh(uc->user,uc->host,uc);
      uc->questions=0;
      uc->updates=0;
      uc->conn_per_hour=0;
660 661
    }
  }
unknown's avatar
unknown committed
662
  (void) pthread_mutex_unlock(&LOCK_user_conn);
unknown's avatar
unknown committed
663
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
664
}
unknown's avatar
unknown committed
665

unknown's avatar
unknown committed
666
/*
667
    Perform handshake, authorize client and update thd ACL variables.
668
  SYNOPSIS
669
    check_connection()
670
    thd  thread handle
671 672

  RETURN
673
     0  success, OK is sent to user, thd is updated.
674 675
    -1  error, which is sent to user
   > 0  error code (not sent to user)
unknown's avatar
unknown committed
676 677
*/

unknown's avatar
unknown committed
678 679
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
unknown's avatar
unknown committed
680
{
681
  uint connect_errors= 0;
unknown's avatar
unknown committed
682
  NET *net= &thd->net;
unknown's avatar
unknown committed
683 684
  ulong pkt_len= 0;
  char *end;
685

686 687 688
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));

unknown's avatar
unknown committed
689 690
  if (!thd->host)                           // If TCP/IP connection
  {
691
    char ip[30];
692

693
    if (vio_peer_addr(net->vio, ip, &thd->peer_port))
unknown's avatar
unknown committed
694
      return (ER_BAD_HOST_ERROR);
695
    if (!(thd->ip= my_strdup(ip,MYF(0))))
unknown's avatar
unknown committed
696
      return (ER_OUT_OF_RESOURCES);
697
    thd->host_or_ip= thd->ip;
unknown's avatar
unknown committed
698
    vio_in_addr(net->vio,&thd->remote.sin_addr);
699
    if (!(specialflag & SPECIAL_NO_RESOLVE))
unknown's avatar
unknown committed
700
    {
701 702 703 704
      vio_in_addr(net->vio,&thd->remote.sin_addr);
      thd->host=ip_to_hostname(&thd->remote.sin_addr,&connect_errors);
      /* Cut very long hostnames to avoid possible overflows */
      if (thd->host)
705
      {
706 707 708
        if (thd->host != my_localhost)
          thd->host[min(strlen(thd->host), HOSTNAME_LENGTH)]= 0;
        thd->host_or_ip= thd->host;
709
      }
710 711
      if (connect_errors > max_connect_errors)
        return(ER_HOST_IS_BLOCKED);
unknown's avatar
unknown committed
712
    }
unknown's avatar
unknown committed
713 714 715
    DBUG_PRINT("info",("Host: %s  ip: %s",
		       thd->host ? thd->host : "unknown host",
		       thd->ip ? thd->ip : "unknown ip"));
unknown's avatar
unknown committed
716 717 718
    if (acl_check_host(thd->host,thd->ip))
      return(ER_HOST_NOT_PRIVILEGED);
  }
719
  else /* Hostname given means that the connection was on a socket */
unknown's avatar
unknown committed
720
  {
unknown's avatar
unknown committed
721
    DBUG_PRINT("info",("Host: %s",thd->host));
722 723
    thd->host_or_ip= thd->host;
    thd->ip= 0;
724 725
    /* Reset sin_addr */
    bzero((char*) &thd->remote, sizeof(thd->remote));
unknown's avatar
unknown committed
726 727 728
  }
  vio_keepalive(net->vio, TRUE);
  {
unknown's avatar
unknown committed
729
    /* buff[] needs to big enough to hold the server_version variable */
730
    char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH + 64];
731 732
    ulong client_flags = (CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB |
			  CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION);
unknown's avatar
unknown committed
733

734 735 736 737 738
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
739 740 741 742
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
      client_flags |= CLIENT_SSL;       /* Wow, SSL is avalaible! */
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
743

744 745 746 747 748 749 750 751 752 753 754
    end= strnmov(buff, server_version, SERVER_VERSION_LENGTH) + 1;
    int4store((uchar*) end, thd->thread_id);
    end+= 4;
    /*
      So as check_connection is the only entry point to authorization
      procedure, scramble is set here. This gives us new scramble for
      each handshake.
    */
    create_random_string(thd->scramble, SCRAMBLE_LENGTH, &thd->rand);
    /*
      Old clients does not understand long scrambles, but can ignore packet
unknown's avatar
unknown committed
755
      tail: that's why first part of the scramble is placed here, and second
756 757
      part at the end of packet.
    */
758
    end= strmake(end, thd->scramble, SCRAMBLE_LENGTH_323) + 1;
759 760 761
   
    int2store(end, client_flags);
    /* write server characteristics: up to 16 bytes allowed */
762
    end[2]=(char) default_charset_info->number;
763 764 765 766 767 768 769 770 771
    int2store(end+3, thd->server_status);
    bzero(end+5, 13);
    end+= 18;
    /* write scramble tail */
    end= strmake(end, thd->scramble + SCRAMBLE_LENGTH_323, 
                 SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323) + 1;

    /* At this point we write connection message and read reply */
    if (net_write_command(net, (uchar) protocol_version, "", 0, buff,
unknown's avatar
unknown committed
772
			  (uint) (end-buff)) ||
773
	(pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
774 775 776 777 778 779 780 781 782 783 784
	pkt_len < MIN_HANDSHAKE_SIZE)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
#ifdef _CUSTOMCONFIG_
#include "_cust_sql_parse.h"
#endif
  if (connect_errors)
    reset_host_errors(&thd->remote.sin_addr);
unknown's avatar
unknown committed
785
  if (thd->packet.alloc(thd->variables.net_buffer_length))
unknown's avatar
unknown committed
786 787 788
    return(ER_OUT_OF_RESOURCES);

  thd->client_capabilities=uint2korr(net->read_pos);
789 790 791 792 793 794 795 796 797 798 799
#ifdef TO_BE_REMOVED_IN_4_1_RELEASE
  /*
    This is just a safety check against any client that would use the old
    CLIENT_CHANGE_USER flag
  */
  if ((thd->client_capabilities & CLIENT_PROTOCOL_41) &&
      !(thd->client_capabilities & (CLIENT_RESERVED |
				    CLIENT_SECURE_CONNECTION |
				    CLIENT_MULTI_RESULTS)))
    thd->client_capabilities&= ~CLIENT_PROTOCOL_41;
#endif
800 801 802 803
  if (thd->client_capabilities & CLIENT_PROTOCOL_41)
  {
    thd->client_capabilities|= ((ulong) uint2korr(net->read_pos+2)) << 16;
    thd->max_client_packet_length= uint4korr(net->read_pos+4);
unknown's avatar
unknown committed
804 805 806
    DBUG_PRINT("info", ("client_character_set: %d", (uint) net->read_pos[8]));
    /*
      Use server character set and collation if
807
      - opt_character_set_client_handshake is not set
unknown's avatar
unknown committed
808 809 810 811
      - client has not specified a character set
      - client character set is the same as the servers
      - client character set doesn't exists in server
    */
812
    if (!opt_character_set_client_handshake ||
813
        !(thd->variables.character_set_client=
unknown's avatar
unknown committed
814 815 816 817
	  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))
818
    {
819 820
      thd->variables.character_set_client=
	global_system_variables.character_set_client;
821 822
      thd->variables.collation_connection=
	global_system_variables.collation_connection;
823 824
      thd->variables.character_set_results=
	global_system_variables.character_set_results;
825 826 827
    }
    else
    {
828
      thd->variables.character_set_results=
829 830 831
      thd->variables.collation_connection= 
	thd->variables.character_set_client;
    }
unknown's avatar
unknown committed
832
    thd->update_charset();
833
    end= (char*) net->read_pos+32;
834 835 836 837 838 839 840
  }
  else
  {
    thd->max_client_packet_length= uint3korr(net->read_pos+2);
    end= (char*) net->read_pos+5;
  }

841
  if (thd->client_capabilities & CLIENT_IGNORE_SPACE)
842
    thd->variables.sql_mode|= MODE_IGNORE_SPACE;
unknown's avatar
unknown committed
843
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
844
  DBUG_PRINT("info", ("client capabilities: %d", thd->client_capabilities));
unknown's avatar
unknown committed
845 846 847
  if (thd->client_capabilities & CLIENT_SSL)
  {
    /* Do the SSL layering. */
848 849 850 851 852
    if (!ssl_acceptor_fd)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
unknown's avatar
unknown committed
853
    DBUG_PRINT("info", ("IO layer change in progress..."));
unknown's avatar
unknown committed
854 855 856 857 858
    if (sslaccept(ssl_acceptor_fd, net->vio, thd->variables.net_wait_timeout))
    {
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
      inc_host_errors(&thd->remote.sin_addr);
unknown's avatar
unknown committed
859
      return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
860
    }
unknown's avatar
unknown committed
861
    DBUG_PRINT("info", ("Reading user information over SSL layer"));
862
    if ((pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
863 864
	pkt_len < NORMAL_HANDSHAKE_SIZE)
    {
unknown's avatar
unknown committed
865 866
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
unknown's avatar
unknown committed
867 868 869 870
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
871 872 873
#endif

  if (end >= (char*) net->read_pos+ pkt_len +2)
unknown's avatar
unknown committed
874
  {
875 876
    inc_host_errors(&thd->remote.sin_addr);
    return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
877 878 879
  }

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
880
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
881
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
882 883
      opt_using_transactions)
    net->return_status= &thd->server_status;
unknown's avatar
unknown committed
884
  net->read_timeout=(uint) thd->variables.net_read_timeout;
unknown's avatar
unknown committed
885

886 887
  char *user= end;
  char *passwd= strend(user)+1;
unknown's avatar
unknown committed
888
  char *db= passwd;
889
  char db_buff[NAME_LEN+1];                     // buffer to store db in utf8
unknown's avatar
unknown committed
890
  char user_buff[USERNAME_LENGTH+1];		// buffer to store user in utf8
891 892 893
  uint dummy_errors;

  /*
unknown's avatar
unknown committed
894 895 896 897
    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'.
  */
898
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
unknown's avatar
unknown committed
899 900 901
    *passwd++ : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
unknown's avatar
unknown committed
902

unknown's avatar
unknown committed
903 904
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
unknown's avatar
unknown committed
905
  {
906 907 908
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info,
                             db, strlen(db),
909
                             thd->charset(), &dummy_errors)]= 0;
910
    db= db_buff;
unknown's avatar
unknown committed
911
  }
unknown's avatar
unknown committed
912

913 914 915 916
  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;
unknown's avatar
unknown committed
917

918 919
  if (thd->user)
    x_free(thd->user);
920 921
  if (!(thd->user= my_strdup(user, MYF(0))))
    return (ER_OUT_OF_RESOURCES);
unknown's avatar
unknown committed
922
  return check_user(thd, COM_CONNECT, passwd, passwd_len, db, TRUE);
unknown's avatar
unknown committed
923 924
}

925

926 927
void execute_init_command(THD *thd, sys_var_str *init_command_var,
			  rw_lock_t *var_mutex)
unknown's avatar
unknown committed
928 929 930 931
{
  Vio* save_vio;
  ulong save_client_capabilities;

932 933 934 935 936 937 938 939 940
  thd->proc_info= "Execution of init_command";
  /*
    We need to lock init_command_var because
    during execution of init_command_var query
    values of init_command_var can't be changed
  */
  rw_rdlock(var_mutex);
  thd->query= init_command_var->value;
  thd->query_length= init_command_var->value_length;
unknown's avatar
unknown committed
941 942
  save_client_capabilities= thd->client_capabilities;
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
943 944 945 946
  /*
    We don't need return result of execution to client side.
    To forbid this we should set thd->net.vio to 0.
  */
unknown's avatar
unknown committed
947 948 949
  save_vio= thd->net.vio;
  thd->net.vio= 0;
  dispatch_command(COM_QUERY, thd, thd->query, thd->query_length+1);
950
  rw_unlock(var_mutex);
unknown's avatar
unknown committed
951 952 953 954 955
  thd->client_capabilities= save_client_capabilities;
  thd->net.vio= save_vio;
}


unknown's avatar
unknown committed
956 957 958 959
pthread_handler_decl(handle_one_connection,arg)
{
  THD *thd=(THD*) arg;
  uint launch_time  =
unknown's avatar
unknown committed
960
    (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
unknown's avatar
unknown committed
961 962 963 964 965
  if (launch_time >= slow_launch_time)
    statistic_increment(slow_launch_threads,&LOCK_status );

  pthread_detach_this_thread();

966 967
#if !defined( __WIN__) && !defined(OS2)	// Win32 calls this in pthread_create
  // The following calls needs to be done before we call DBUG_ macros
968
  if (!(test_flags & TEST_NO_THREADS) & my_thread_init())
unknown's avatar
unknown committed
969
  {
970
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
971
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
972 973 974 975 976
    end_thread(thd,0);
    return 0;
  }
#endif

977 978 979 980 981 982 983
  /*
    handle_one_connection() is the only way a thread would start
    and would always be on top of the stack, therefore, the thread
    stack always starts at the address of the first local variable
    of handle_one_connection, which is thd. We need to know the
    start of the stack so that we could check for stack overruns.
  */
unknown's avatar
unknown committed
984 985 986 987
  DBUG_PRINT("info", ("handle_one_connection called by thread %d\n",
		      thd->thread_id));
  // now that we've called my_thread_init(), it is safe to call DBUG_*

unknown's avatar
unknown committed
988
#if defined(__WIN__)
unknown's avatar
unknown committed
989
  init_signals();				// IRENA; testing ?
unknown's avatar
unknown committed
990
#elif !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
991 992 993 994 995 996
  sigset_t set;
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif
  if (thd->store_globals())
  {
997
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
998
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
999 1000 1001 1002 1003 1004 1005 1006 1007 1008
    end_thread(thd,0);
    return 0;
  }

  do
  {
    int error;
    NET *net= &thd->net;
    thd->thread_stack= (char*) &thd;

1009
    if ((error=check_connection(thd)))
unknown's avatar
unknown committed
1010 1011
    {						// Wrong permissions
      if (error > 0)
1012
	net_printf(thd,error,thd->host_or_ip);
unknown's avatar
unknown committed
1013 1014
#ifdef __NT__
      if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
1015
	my_sleep(1000);				/* must wait after eof() */
unknown's avatar
unknown committed
1016
#endif
1017
      statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1018 1019
      goto end_thread;
    }
unknown's avatar
unknown committed
1020 1021 1022
#ifdef __NETWARE__
    netware_reg_user(thd->ip, thd->user, "MySQL");
#endif
1023
    if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1024 1025 1026 1027
      thd->options |= OPTION_BIG_SELECTS;
    if (thd->client_capabilities & CLIENT_COMPRESS)
      net->compress=1;				// Use compression

unknown's avatar
unknown committed
1028
    thd->version= refresh_version;
1029 1030 1031
    thd->proc_info= 0;
    thd->set_time();
    thd->init_for_queries();
unknown's avatar
unknown committed
1032
    if (sys_init_connect.value_length && !(thd->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1033
    {
1034 1035 1036
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
	thd->killed= 1;
unknown's avatar
unknown committed
1037
    }
unknown's avatar
unknown committed
1038 1039 1040 1041 1042
    while (!net->error && net->vio != 0 && !thd->killed)
    {
      if (do_command(thd))
	break;
    }
1043 1044
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
unknown's avatar
unknown committed
1045
    free_root(thd->mem_root,MYF(0));
unknown's avatar
unknown committed
1046
    if (net->error && net->vio != 0 && net->report_error)
unknown's avatar
unknown committed
1047
    {
1048
      if (!thd->killed && thd->variables.log_warnings > 1)
unknown's avatar
unknown committed
1049 1050 1051 1052 1053 1054
        sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
                          thd->thread_id,(thd->db ? thd->db : "unconnected"),
                          thd->user ? thd->user : "unauthenticated",
                          thd->host_or_ip,
                          (net->last_errno ? ER(net->last_errno) :
                           ER(ER_UNKNOWN_ERROR)));
1055
      send_error(thd,net->last_errno,NullS);
unknown's avatar
unknown committed
1056
      statistic_increment(aborted_threads,&LOCK_status);
unknown's avatar
unknown committed
1057
    }
1058 1059 1060 1061
    else if (thd->killed)
    {
      statistic_increment(aborted_threads,&LOCK_status);
    }
1062
    
unknown's avatar
unknown committed
1063
end_thread:
1064
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
    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;
  } while (!(test_flags & TEST_NO_THREADS));
  /* The following is only executed if we are not using --one-thread */
  return(0);					/* purecov: deadcode */
}

unknown's avatar
unknown committed
1076 1077
#endif /* EMBEDDED_LIBRARY */

1078 1079 1080 1081
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
1082

1083
extern "C" pthread_handler_decl(handle_bootstrap,arg)
unknown's avatar
unknown committed
1084
{
1085 1086 1087
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
unknown's avatar
unknown committed
1088

1089
  /* The following must be called before DBUG_ENTER */
1090
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
1091
  {
unknown's avatar
unknown committed
1092
#ifndef EMBEDDED_LIBRARY
1093
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
1094
#endif
1095
    thd->fatal_error();
1096
    goto end;
unknown's avatar
unknown committed
1097
  }
1098 1099
  DBUG_ENTER("handle_bootstrap");

unknown's avatar
unknown committed
1100
#ifndef EMBEDDED_LIBRARY
1101 1102
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1103
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1104
  sigset_t set;
1105 1106
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
1107
#endif
unknown's avatar
unknown committed
1108
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1109

1110
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1111 1112 1113 1114
    thd->options |= OPTION_BIG_SELECTS;

  thd->proc_info=0;
  thd->version=refresh_version;
1115
  thd->priv_user=thd->user=(char*) my_strdup("boot", MYF(MY_WME));
unknown's avatar
unknown committed
1116

1117
  buff= (char*) thd->net.buff;
1118
  thd->init_for_queries();
unknown's avatar
unknown committed
1119 1120
  while (fgets(buff, thd->net.max_packet, file))
  {
1121 1122
    ulong length= (ulong) strlen(buff);
    while (buff[length-1] != '\n' && !feof(file))
1123
    {
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
      /*
        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))
      {
        send_error(thd, thd->net.last_errno, NullS);
        thd->is_fatal_error= 1;
        break;
      }
      buff= (char*) thd->net.buff;
      fgets(buff + length, thd->net.max_packet - length, file);
      length+= (ulong) strlen(buff + length);
1137
    }
1138 1139
    if (thd->is_fatal_error)
      break;
unknown's avatar
unknown committed
1140
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1141
           buff[length-1] == ';'))
unknown's avatar
unknown committed
1142 1143
      length--;
    buff[length]=0;
1144
    thd->query_length=length;
unknown's avatar
unknown committed
1145 1146
    thd->query= thd->memdup_w_gap(buff, length+1, thd->db_length+1);
    thd->query[length] = '\0';
unknown's avatar
unknown committed
1147
    thd->query_id=query_id++;
1148
    if (mqh_used && thd->user_connect && check_mqh(thd, SQLCOM_END))
1149 1150 1151
    {
      thd->net.error = 0;
      close_thread_tables(thd);			// Free tables
unknown's avatar
unknown committed
1152
      free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1153 1154
      break;
    }
unknown's avatar
unknown committed
1155 1156
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
1157
    if (thd->is_fatal_error)
1158
      break;
unknown's avatar
unknown committed
1159
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1160
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
unknown's avatar
unknown committed
1161
  }
1162 1163 1164

  /* thd->fatal_error should be set in case something went wrong */
end:
unknown's avatar
unknown committed
1165
#ifndef EMBEDDED_LIBRARY
1166 1167 1168
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1169
  (void) pthread_cond_broadcast(&COND_thread_count);
1170 1171
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1172
#endif
1173
  DBUG_RETURN(0);				// Never reached
unknown's avatar
unknown committed
1174 1175
}

1176
    /* This works because items are allocated with sql_alloc() */
unknown's avatar
unknown committed
1177

1178
void free_items(Item *item)
unknown's avatar
unknown committed
1179
{
1180
  for (; item ; item=item->next)
1181
    item->delete_self();
unknown's avatar
unknown committed
1182 1183
}

1184 1185 1186 1187 1188 1189 1190 1191
    /* This works because items are allocated with sql_alloc() */

void cleanup_items(Item *item)
{
  for (; item ; item=item->next)
    item->cleanup();
}

unknown's avatar
unknown committed
1192 1193 1194 1195 1196 1197 1198
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;
1199
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1200
    DBUG_RETURN(1); // out of memory
unknown's avatar
unknown committed
1201
  table_list->db = db;
1202
  table_list->real_name = table_list->alias = tbl_name;
unknown's avatar
unknown committed
1203 1204 1205
  table_list->lock_type = TL_READ_NO_INSERT;
  table_list->next = 0;

1206 1207
  if (!db || check_db_name(db))
  {
1208
    net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1209 1210
    goto err;
  }
1211
  if (lower_case_table_names)
1212
    my_casedn_str(files_charset_info, tbl_name);
unknown's avatar
unknown committed
1213
  remove_escape(table_list->real_name);
1214 1215 1216 1217

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

unknown's avatar
unknown committed
1218
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1219 1220
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1221
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1222
  thd->query = tbl_name;
1223 1224
  if ((error = mysqld_dump_create_info(thd, table, -1)))
  {
1225
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1226 1227
    goto err;
  }
unknown's avatar
unknown committed
1228
  net_flush(&thd->net);
1229
  if ((error= table->file->dump(thd,fd)))
1230
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1231

unknown's avatar
unknown committed
1232 1233
err:
  close_thread_tables(thd);
unknown's avatar
unknown committed
1234
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1235 1236 1237
}


1238
#ifndef EMBEDDED_LIBRARY
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249

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

unknown's avatar
unknown committed
1250 1251 1252
bool do_command(THD *thd)
{
  char *packet;
unknown's avatar
unknown committed
1253 1254
  uint old_timeout;
  ulong packet_length;
unknown's avatar
unknown committed
1255 1256 1257 1258 1259
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
unknown's avatar
unknown committed
1260 1261 1262 1263
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1264
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1265 1266

  packet=0;
unknown's avatar
unknown committed
1267 1268 1269
  old_timeout=net->read_timeout;
  // Wait max for 8 hours
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
unknown's avatar
unknown committed
1270
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1271 1272 1273 1274

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1275 1276 1277 1278 1279
    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)
1280 1281
    {
      statistic_increment(aborted_threads,&LOCK_status);
1282
      DBUG_RETURN(TRUE);			// We have to close it.
1283
    }
1284
    send_error(thd,net->last_errno,NullS);
1285
    net->error= 0;
1286
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1287 1288 1289 1290 1291
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1292 1293
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
1294 1295 1296
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
1297
  }
unknown's avatar
unknown committed
1298
  net->read_timeout=old_timeout;		// restore it
1299 1300 1301 1302 1303 1304 1305 1306 1307
  /*
    packet_length contains length of data, as it was stored in packet
    header. In case of malformed header, packet_length can be zero.
    If packet_length is not zero, my_net_read ensures that this number
    of bytes was actually read from network. Additionally my_net_read
    sets packet[packet_length]= 0 (thus if packet_length == 0,
    command == packet[0] == COM_SLEEP).
    In dispatch_command packet[packet_length] points beyond the end of packet.
  */
unknown's avatar
unknown committed
1308
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1309
}
1310
#endif  /* EMBEDDED_LIBRARY */
1311

1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
/*
   Perform one connection-level (COM_XXXX) command.
  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
*/
1327

1328 1329 1330 1331
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1332
  bool error= 0;
1333 1334 1335
  DBUG_ENTER("dispatch_command");

  thd->command=command;
unknown's avatar
unknown committed
1336
  /*
1337 1338
    Commands which always take a long time are logged into
    the slow log only if opt_log_slow_admin_statements is set.
unknown's avatar
unknown committed
1339
  */
1340
  thd->enable_slow_log= TRUE;
unknown's avatar
unknown committed
1341
  thd->set_time();
unknown's avatar
unknown committed
1342 1343 1344 1345 1346
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
    query_id++;
  thread_running++;
1347
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1348
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1349

1350 1351
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1352
  switch (command) {
unknown's avatar
unknown committed
1353
  case COM_INIT_DB:
unknown's avatar
unknown committed
1354 1355 1356 1357 1358 1359 1360 1361 1362
  {
    LEX_STRING tmp;
    statistic_increment(com_stat[SQLCOM_CHANGE_DB],&LOCK_status);
    thd->convert_string(&tmp, system_charset_info,
			packet, strlen(packet), thd->charset());
    if (!mysql_change_db(thd, tmp.str))
      mysql_log.write(thd,command,"%s",thd->db);
    break;
  }
unknown's avatar
unknown committed
1363
#ifdef HAVE_REPLICATION
1364 1365
  case COM_REGISTER_SLAVE:
  {
1366
    if (!register_slave(thd, (uchar*)packet, packet_length))
1367
      send_ok(thd);
1368 1369
    break;
  }
1370
#endif
unknown's avatar
unknown committed
1371
  case COM_TABLE_DUMP:
1372 1373 1374 1375 1376 1377
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
    uint tbl_len= *(uchar*) (packet + db_len + 1);

    statistic_increment(com_other, &LOCK_status);
1378
    thd->enable_slow_log= opt_log_slow_admin_statements;
1379 1380 1381 1382 1383 1384 1385
    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);
    if (mysql_table_dump(thd, db, tbl_name, -1))
      send_error(thd); // dump to NET
    break;
  }
unknown's avatar
unknown committed
1386 1387
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1388
    thd->change_user();
1389
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1390

1391 1392
    statistic_increment(com_other, &LOCK_status);
    char *user= (char*) packet;
unknown's avatar
unknown committed
1393
    char *passwd= strend(user)+1;
unknown's avatar
unknown committed
1394 1395 1396 1397 1398
    /* 
      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).
    */
1399
    char db_buff[NAME_LEN+1];                 // buffer to store db in utf8 
unknown's avatar
unknown committed
1400 1401 1402 1403
    char *db= passwd;
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ? 
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1404
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1405
    /* Small check for incomming packet */
unknown's avatar
unknown committed
1406
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1407 1408 1409 1410
    {
      send_error(thd, ER_UNKNOWN_COM_ERROR);
      break;
    }
1411
#endif
1412
    /* Convert database name to utf8 */
1413
    uint dummy_errors;
1414 1415
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1416
                             thd->charset(), &dummy_errors)]= 0;
1417
    db= db_buff;
unknown's avatar
unknown committed
1418

1419 1420 1421 1422 1423 1424 1425
    /* Save user and privileges */
    uint save_master_access= thd->master_access;
    uint save_db_access= thd->db_access;
    uint save_db_length= thd->db_length;
    char *save_user= thd->user;
    char *save_priv_user= thd->priv_user;
    char *save_db= thd->db;
unknown's avatar
unknown committed
1426
    USER_CONN *save_user_connect= thd->user_connect;
unknown's avatar
unknown committed
1427 1428
    
    if (!(thd->user= my_strdup(user, MYF(0))))
1429 1430 1431 1432 1433
    {
      thd->user= save_user;
      send_error(thd, ER_OUT_OF_RESOURCES);
      break;
    }
unknown's avatar
unknown committed
1434

unknown's avatar
unknown committed
1435 1436
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1437
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1438

1439 1440 1441 1442 1443 1444 1445 1446
    if (res)
    {
      /* authentification failure, we shall restore old user */
      if (res > 0)
        send_error(thd, ER_UNKNOWN_COM_ERROR);
      x_free(thd->user);
      thd->user= save_user;
      thd->priv_user= save_priv_user;
unknown's avatar
unknown committed
1447
      thd->user_connect= save_user_connect;
1448 1449 1450 1451 1452 1453 1454 1455
      thd->master_access= save_master_access;
      thd->db_access= save_db_access;
      thd->db= save_db;
      thd->db_length= save_db_length;
    }
    else
    {
      /* we've authenticated new user */
unknown's avatar
unknown committed
1456 1457
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1458 1459 1460
      x_free((gptr) save_db);
      x_free((gptr) save_user);
    }
unknown's avatar
unknown committed
1461 1462
    break;
  }
unknown's avatar
unknown committed
1463 1464
  case COM_EXECUTE:
  {
1465
    mysql_stmt_execute(thd, packet, packet_length);
unknown's avatar
unknown committed
1466 1467 1468 1469
    break;
  }
  case COM_LONG_DATA:
  {
1470
    mysql_stmt_get_longdata(thd, packet, packet_length);
unknown's avatar
unknown committed
1471 1472 1473 1474
    break;
  }
  case COM_PREPARE:
  {
1475
    mysql_stmt_prepare(thd, packet, packet_length);
unknown's avatar
unknown committed
1476 1477
    break;
  }
unknown's avatar
unknown committed
1478 1479 1480 1481 1482
  case COM_CLOSE_STMT:
  {
    mysql_stmt_free(thd, packet);
    break;
  }
1483 1484 1485 1486 1487
  case COM_RESET_STMT:
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
unknown's avatar
unknown committed
1488 1489
  case COM_QUERY:
  {
1490 1491
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1492
    char *packet_end= thd->query + thd->query_length;
1493
    mysql_log.write(thd,command,"%s",thd->query);
1494
    DBUG_PRINT("query",("%-.4096s",thd->query));
1495
    mysql_parse(thd,thd->query, thd->query_length);
1496

1497
    while (!thd->killed && !thd->is_fatal_error && thd->lex->found_colon)
1498
    {
1499
      char *packet= thd->lex->found_colon;
1500
      /*
1501
        Multiple queries exits, execute them individually
1502
	in embedded server - just store them to be executed later 
1503
      */
1504
#ifndef EMBEDDED_LIBRARY
1505
      if (thd->lock || thd->open_tables || thd->derived_tables)
1506
        close_thread_tables(thd);
1507
#endif
1508
      ulong length= (ulong)(packet_end-packet);
1509

1510
      log_slow_statement(thd);
1511

1512
      /* Remove garbage at start of query */
unknown's avatar
unknown committed
1513
      while (my_isspace(thd->charset(), *packet) && length > 0)
1514 1515 1516 1517
      {
        packet++;
        length--;
      }
unknown's avatar
unknown committed
1518
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1519
      thd->query_length= length;
1520 1521
      thd->query= packet;
      thd->query_id= query_id++;
1522
      thd->set_time(); /* Reset the query start time. */
1523
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1524
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1525
#ifndef EMBEDDED_LIBRARY
1526
      mysql_parse(thd, packet, length);
1527
#else
unknown's avatar
unknown committed
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
      /*
	'packet' can point inside the query_rest's buffer
	so we have to do memmove here
       */
      if (thd->query_rest.length() > length)
      {
	memmove(thd->query_rest.c_ptr(), packet, length);
	thd->query_rest.length(length);
      }
      else
1538
	thd->query_rest.copy(packet, length, thd->query_rest.charset());
1539 1540 1541

      thd->server_status&= ~ (SERVER_QUERY_NO_INDEX_USED |
                              SERVER_QUERY_NO_GOOD_INDEX_USED);
1542 1543
      break;
#endif /*EMBEDDED_LIBRARY*/
1544 1545
    }

unknown's avatar
unknown committed
1546 1547 1548 1549 1550
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1551
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1552
#ifdef DONT_ALLOW_SHOW_COMMANDS
1553
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
1554 1555 1556
    break;
#else
  {
1557
    char *fields, *pend;
unknown's avatar
unknown committed
1558
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1559 1560
    LEX_STRING conv_name;

unknown's avatar
unknown committed
1561
    statistic_increment(com_stat[SQLCOM_SHOW_FIELDS],&LOCK_status);
unknown's avatar
unknown committed
1562 1563 1564
    bzero((char*) &table_list,sizeof(table_list));
    if (!(table_list.db=thd->db))
    {
1565
      send_error(thd,ER_NO_DB_ERROR);
unknown's avatar
unknown committed
1566 1567 1568
      break;
    }
    thd->free_list=0;
1569
    pend= strend(packet);
unknown's avatar
unknown committed
1570 1571 1572
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
    table_list.alias= table_list.real_name= conv_name.str;
1573
    packet= pend+1;
1574
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
unknown's avatar
unknown committed
1575 1576
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1577
    mysql_log.write(thd,command,"%s %s",table_list.real_name,fields);
1578
    if (lower_case_table_names)
unknown's avatar
unknown committed
1579
      my_casedn_str(files_charset_info, table_list.real_name);
unknown's avatar
unknown committed
1580 1581
    remove_escape(table_list.real_name);	// This can't have wildcards

unknown's avatar
unknown committed
1582 1583
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
		     0, 0))
unknown's avatar
unknown committed
1584
      break;
unknown's avatar
unknown committed
1585 1586
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1587 1588
      break;
    mysqld_list_fields(thd,&table_list,fields);
1589
    free_items(thd->free_list);
1590
    thd->free_list= 0;
unknown's avatar
unknown committed
1591 1592 1593 1594
    break;
  }
#endif
  case COM_QUIT:
1595
    /* We don't calculate statistics for this command */
1596
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1597 1598 1599 1600
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1601
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1602
    {
unknown's avatar
unknown committed
1603
      char *db=thd->strdup(packet), *alias;
1604
      HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1605

unknown's avatar
unknown committed
1606
      statistic_increment(com_stat[SQLCOM_CREATE_DB],&LOCK_status);
1607
      // null test to handle EOM
unknown's avatar
unknown committed
1608
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1609
      {
1610
	net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1611 1612
	break;
      }
unknown's avatar
unknown committed
1613
      if (check_access(thd,CREATE_ACL,db,0,1,0))
unknown's avatar
unknown committed
1614
	break;
1615
      mysql_log.write(thd,command,packet);
1616
      bzero(&create_info, sizeof(create_info));
1617
      if (mysql_create_db(thd, (lower_case_table_names == 2 ? alias : db),
1618
                          &create_info, 0) < 0)
unknown's avatar
unknown committed
1619
        send_error(thd, thd->killed ? ER_SERVER_SHUTDOWN : 0);
unknown's avatar
unknown committed
1620 1621
      break;
    }
unknown's avatar
unknown committed
1622
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1623
    {
unknown's avatar
unknown committed
1624
      statistic_increment(com_stat[SQLCOM_DROP_DB],&LOCK_status);
unknown's avatar
unknown committed
1625
      char *db=thd->strdup(packet), *alias;
1626
      // null test to handle EOM
unknown's avatar
unknown committed
1627
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1628
      {
1629
	net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1630 1631
	break;
      }
unknown's avatar
unknown committed
1632
      if (check_access(thd,DROP_ACL,db,0,1,0))
1633
	break;
unknown's avatar
unknown committed
1634 1635
      if (thd->locked_tables || thd->active_transaction())
      {
1636
	send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
1637
	break;
unknown's avatar
unknown committed
1638
      }
1639
      mysql_log.write(thd,command,db);
1640 1641
      if (mysql_rm_db(thd, (lower_case_table_names == 2 ? alias : db),
                      0, 0) < 0)
unknown's avatar
unknown committed
1642
        send_error(thd, thd->killed ? ER_SERVER_SHUTDOWN : 0);
unknown's avatar
unknown committed
1643 1644
      break;
    }
1645
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1646 1647
  case COM_BINLOG_DUMP:
    {
unknown's avatar
unknown committed
1648 1649 1650 1651
      ulong pos;
      ushort flags;
      uint32 slave_server_id;

unknown's avatar
unknown committed
1652
      statistic_increment(com_other,&LOCK_status);
1653
      thd->enable_slow_log= opt_log_slow_admin_statements;
unknown's avatar
unknown committed
1654
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1655
	break;
unknown's avatar
unknown committed
1656

1657
      /* TODO: The following has to be changed to an 8 byte integer */
1658 1659
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1660
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1661
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1662
	kill_zombie_dump_threads(slave_server_id);
1663
      thd->server_id = slave_server_id;
unknown's avatar
unknown committed
1664 1665 1666

      mysql_log.write(thd, command, "Log: '%s'  Pos: %ld", packet+10,
                      (long) pos);
1667
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1668
      unregister_slave(thd,1,1);
1669 1670 1671
      // fake COM_QUIT -- if we get here, the thread needs to terminate
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
1672 1673
      break;
    }
1674
#endif
unknown's avatar
unknown committed
1675 1676
  case COM_REFRESH:
    {
unknown's avatar
unknown committed
1677
      statistic_increment(com_stat[SQLCOM_FLUSH],&LOCK_status);
unknown's avatar
unknown committed
1678
      ulong options= (ulong) (uchar) packet[0];
unknown's avatar
unknown committed
1679
      if (check_global_access(thd,RELOAD_ACL))
unknown's avatar
unknown committed
1680
	break;
1681
      mysql_log.write(thd,command,NullS);
1682 1683 1684 1685
      if (reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, NULL))
        send_error(thd, 0);
      else
        send_ok(thd);
unknown's avatar
unknown committed
1686 1687
      break;
    }
1688
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1689
  case COM_SHUTDOWN:
1690
  {
unknown's avatar
unknown committed
1691
    statistic_increment(com_other,&LOCK_status);
unknown's avatar
unknown committed
1692
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
1693
      break; /* purecov: inspected */
1694
    /*
1695 1696 1697 1698
      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].
1699
    */
1700 1701
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
1702
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1703 1704 1705 1706 1707 1708 1709 1710
    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");
      send_error(thd);
      break;
    }
1711
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1712
    mysql_log.write(thd,command,NullS);
1713
    send_eof(thd);
unknown's avatar
unknown committed
1714 1715 1716
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
unknown's avatar
unknown committed
1717
#ifndef OS2
1718
    send_eof(thd);				// This is for 'quit request'
unknown's avatar
unknown committed
1719
#endif
1720
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1721
    close_thread_tables(thd);			// Free before kill
unknown's avatar
unknown committed
1722
    free_root(thd->mem_root,MYF(0));
1723
    free_root(&thd->transaction.mem_root,MYF(0));
unknown's avatar
unknown committed
1724 1725 1726
    kill_mysql();
    error=TRUE;
    break;
1727
  }
1728
#endif
unknown's avatar
unknown committed
1729 1730
  case COM_STATISTICS:
  {
1731
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1732
    statistic_increment(com_stat[SQLCOM_SHOW_STATUS],&LOCK_status);
unknown's avatar
unknown committed
1733
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1734
    char buff[200];
unknown's avatar
unknown committed
1735 1736 1737
#else
    char *buff= thd->net.last_error;
#endif
1738
    ulong uptime = (ulong) (thd->start_time - start_time);
unknown's avatar
unknown committed
1739
    sprintf((char*) buff,
1740
	    "Uptime: %ld  Threads: %d  Questions: %lu  Slow queries: %ld  Opens: %ld  Flush tables: %ld  Open tables: %u  Queries per second avg: %.3f",
unknown's avatar
unknown committed
1741 1742 1743 1744 1745
	    uptime,
	    (int) thread_count,thd->query_id,long_query_count,
	    opened_tables,refresh_version, cached_tables(),
	    uptime ? (float)thd->query_id/(float)uptime : 0);
#ifdef SAFEMALLOC
1746
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
1747
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
1748 1749
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
1750 1751
#endif
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1752
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
1753
    VOID(net_flush(net));
unknown's avatar
unknown committed
1754
#endif
unknown's avatar
unknown committed
1755 1756 1757
    break;
  }
  case COM_PING:
unknown's avatar
unknown committed
1758
    statistic_increment(com_other,&LOCK_status);
1759
    send_ok(thd);				// Tell client we are alive
unknown's avatar
unknown committed
1760 1761
    break;
  case COM_PROCESS_INFO:
unknown's avatar
unknown committed
1762
    statistic_increment(com_stat[SQLCOM_SHOW_PROCESSLIST],&LOCK_status);
unknown's avatar
unknown committed
1763
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
1764
      break;
1765
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1766 1767
    mysqld_list_processes(thd,
			  thd->master_access & PROCESS_ACL ? 
unknown's avatar
unknown committed
1768
			  NullS : thd->priv_user, 0);
unknown's avatar
unknown committed
1769 1770 1771
    break;
  case COM_PROCESS_KILL:
  {
unknown's avatar
unknown committed
1772
    statistic_increment(com_stat[SQLCOM_KILL],&LOCK_status);
1773
    ulong id=(ulong) uint4korr(packet);
unknown's avatar
unknown committed
1774 1775 1776
    kill_one_thread(thd,id);
    break;
  }
1777 1778 1779 1780 1781 1782 1783
  case COM_SET_OPTION:
  {
    statistic_increment(com_stat[SQLCOM_SET_OPTION], &LOCK_status);
    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;
unknown's avatar
unknown committed
1784
      send_eof(thd);
1785 1786 1787
      break;
    case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
1788
      send_eof(thd);
1789 1790 1791 1792 1793 1794 1795
      break;
    default:
      send_error(thd, ER_UNKNOWN_COM_ERROR);
      break;
    }
    break;
  }
unknown's avatar
unknown committed
1796
  case COM_DEBUG:
unknown's avatar
unknown committed
1797
    statistic_increment(com_other,&LOCK_status);
unknown's avatar
unknown committed
1798
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
1799 1800
      break;					/* purecov: inspected */
    mysql_print_status(thd);
1801
    mysql_log.write(thd,command,NullS);
1802
    send_eof(thd);
unknown's avatar
unknown committed
1803 1804 1805 1806 1807
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
1808
  case COM_END:
unknown's avatar
unknown committed
1809
  default:
1810
    send_error(thd, ER_UNKNOWN_COM_ERROR);
unknown's avatar
unknown committed
1811 1812
    break;
  }
1813
  if (thd->lock || thd->open_tables || thd->derived_tables)
unknown's avatar
unknown committed
1814 1815 1816 1817 1818
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }

1819
  if (thd->is_fatal_error)
1820
    send_error(thd,0);				// End of memory ?
unknown's avatar
unknown committed
1821

1822
  log_slow_statement(thd);
1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837

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


1838
void log_slow_statement(THD *thd)
1839
{
unknown's avatar
unknown committed
1840
  time_t start_of_query=thd->start_time;
1841
  thd->end_time();				// Set start time
1842

1843 1844 1845 1846 1847
  /*
    Do not log administrative statements unless the appropriate option is
    set; do not log into slow log if reading from backup.
  */
  if (thd->enable_slow_log && !thd->user_time)
unknown's avatar
unknown committed
1848
  {
1849 1850
    thd->proc_info="logging slow query";

1851 1852
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
1853 1854
	((thd->server_status &
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
1855
	 (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES)))
1856 1857 1858 1859
    {
      long_query_count++;
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
unknown's avatar
unknown committed
1860 1861 1862
  }
}

1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880

/*
  Read query from packet and store in thd->query
  Used in COM_QUERY and COM_PREPARE

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
    0	ok
    1	error;  In this case thd->fatal_error is set
*/

bool alloc_query(THD *thd, char *packet, ulong packet_length)
{
  packet_length--;				// Remove end null
1881
  /* Remove garbage at start and end of query */
unknown's avatar
unknown committed
1882
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
1883 1884 1885 1886 1887
  {
    packet++;
    packet_length--;
  }
  char *pos=packet+packet_length;		// Point at end null
unknown's avatar
unknown committed
1888
  while (packet_length > 0 &&
unknown's avatar
unknown committed
1889
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
1890 1891 1892 1893 1894
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
1895
  thd->query_length= 0;                        // Extra safety: Avoid races
1896 1897
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
1898 1899
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
1900 1901 1902
    return 1;
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
1903 1904 1905 1906

  /* Reclaim some memory */
  thd->packet.shrink(thd->variables.net_buffer_length);
  thd->convert_buffer.shrink(thd->variables.net_buffer_length);
1907 1908 1909 1910 1911 1912

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

1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929
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;
}


unknown's avatar
unknown committed
1930 1931 1932 1933 1934 1935
/****************************************************************************
** mysql_execute_command
** Execute command saved in thd and current_lex->sql_command
****************************************************************************/

void
1936
mysql_execute_command(THD *thd)
unknown's avatar
unknown committed
1937
{
1938
  int	res= 0;
1939
  LEX	*lex= thd->lex;
unknown's avatar
unknown committed
1940 1941
  bool slave_fake_lock= 0;
  MYSQL_LOCK *fake_prev_lock= 0;
unknown's avatar
unknown committed
1942
  SELECT_LEX *select_lex= &lex->select_lex;
1943
  TABLE_LIST *tables= (TABLE_LIST*) select_lex->table_list.first;
1944
  SELECT_LEX_UNIT *unit= &lex->unit;
unknown's avatar
unknown committed
1945 1946
  DBUG_ENTER("mysql_execute_command");

1947 1948 1949 1950 1951 1952
  /*
    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.
  */
1953 1954
  if (tables || &lex->select_lex != lex->all_selects_list ||
      lex->time_zone_tables_used)
1955 1956
    mysql_reset_errors(thd);

unknown's avatar
unknown committed
1957 1958 1959 1960
  /*
    When subselects or time_zone info is used in a query
    we create a new TABLE_LIST containing all referenced tables
    and set local variable 'tables' to point to this list.
1961
  */
1962 1963 1964 1965 1966
  if ((&lex->select_lex != lex->all_selects_list ||
       lex->time_zone_tables_used) &&
      lex->unit.create_total_list(thd, lex, &tables))
    DBUG_VOID_RETURN;

unknown's avatar
SCRUM  
unknown committed
1967
#ifdef HAVE_REPLICATION
1968 1969
  if (thd->slave_thread)
  {
unknown's avatar
unknown committed
1970
    if (lex->sql_command == SQLCOM_UPDATE_MULTI)
unknown's avatar
unknown committed
1971 1972 1973
    {
      DBUG_PRINT("info",("need faked locked tables"));
      
unknown's avatar
unknown committed
1974 1975
      if (check_multi_update_lock(thd, tables, &select_lex->item_list,
				  select_lex))
unknown's avatar
unknown committed
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986
        goto error;

      /* Fix for replication, the tables are opened and locked,
         now we pretend that we have performed a LOCK TABLES action */
	 
      fake_prev_lock= thd->locked_tables;
      if (thd->lock)
        thd->locked_tables= thd->lock;
      thd->lock= 0;
      slave_fake_lock= 1;
    }
unknown's avatar
unknown committed
1987
    /*
unknown's avatar
merge  
unknown committed
1988
      Skip if we are in the slave thread, some table rules have been
1989
      given and the table list says the query should not be replicated.
1990 1991 1992

      Exceptions are:
      - SET: we always execute it (Not that many SET commands exists in
unknown's avatar
unknown committed
1993 1994
        the binary log anyway -- only 4.1 masters write SET statements,
	in 5.0 there are no SET statements in the binary log)
1995 1996
      - DROP TEMPORARY TABLE IF EXISTS: we always execute it (otherwise we
        have stale files on slave caused by exclusion of one tmp table).
unknown's avatar
merge  
unknown committed
1997
    */
1998 1999
    if (!(lex->sql_command == SQLCOM_SET_OPTION) &&
	!(lex->sql_command == SQLCOM_DROP_TABLE &&
2000 2001
          lex->drop_temporary && lex->drop_if_exists) &&
        all_tables_not_ok(thd,tables))
unknown's avatar
unknown committed
2002 2003 2004
    {
      /* we warn the slave SQL thread */
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
2005
      reset_one_shot_variables(thd);
2006
      DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2007
    }
unknown's avatar
merge  
unknown committed
2008 2009
#ifndef TO_BE_DELETED
    /*
2010 2011 2012
      This is a workaround to deal with the shortcoming in 3.23.44-3.23.46
      masters in RELEASE_LOCK() logging. We re-write SELECT RELEASE_LOCK()
      as DO RELEASE_LOCK()
unknown's avatar
merge  
unknown committed
2013
    */
2014 2015 2016
    if (lex->sql_command == SQLCOM_SELECT)
    {
      lex->sql_command = SQLCOM_DO;
unknown's avatar
unknown committed
2017
      lex->insert_list = &select_lex->item_list;
2018
    }
unknown's avatar
merge  
unknown committed
2019
#endif
2020
  }
unknown's avatar
unknown committed
2021
#endif /* !HAVE_REPLICATION */
unknown's avatar
unknown committed
2022

2023 2024 2025 2026 2027
  /*
    When option readonly is set deny operations which change tables.
    Except for the replication thread and the 'super' users.
  */
  if (opt_readonly &&
unknown's avatar
unknown committed
2028
      !(thd->slave_thread || (thd->master_access & SUPER_ACL)) &&
2029 2030
      (uc_update_queries[lex->sql_command] > 0))
  {
unknown's avatar
unknown committed
2031
    net_printf(thd, ER_OPTION_PREVENTS_STATEMENT, "--read-only");
2032 2033
    DBUG_VOID_RETURN;
  }
2034

unknown's avatar
unknown committed
2035
  statistic_increment(com_stat[lex->sql_command],&LOCK_status);
unknown's avatar
unknown committed
2036 2037 2038
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2039 2040 2041 2042 2043 2044 2045
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
	param->select_limit= thd->variables.select_limit;
    }

2046
    select_result *result=lex->result;
unknown's avatar
unknown committed
2047 2048 2049 2050 2051
    if (tables)
    {
      res=check_table_access(thd,
			     lex->exchange ? SELECT_ACL | FILE_ACL :
			     SELECT_ACL,
unknown's avatar
unknown committed
2052
			     tables,0);
unknown's avatar
unknown committed
2053 2054 2055
    }
    else
      res=check_access(thd, lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
unknown's avatar
unknown committed
2056
		       any_db,0,0,0);
unknown's avatar
unknown committed
2057 2058 2059 2060 2061
    if (res)
    {
      res=0;
      break;					// Error message is given
    }
2062 2063 2064 2065
    /* 
       In case of single SELECT unit->global_parameters points on first SELECT
       TODO: move counters to SELECT_LEX
    */
2066 2067 2068
    unit->offset_limit_cnt= (ha_rows) unit->global_parameters->offset_limit;
    unit->select_limit_cnt= (ha_rows) (unit->global_parameters->select_limit+
      unit->global_parameters->offset_limit);
unknown's avatar
unknown committed
2069
    if (unit->select_limit_cnt <
2070
	(ha_rows) unit->global_parameters->select_limit)
2071
      unit->select_limit_cnt= HA_POS_ERROR;		// no limit
2072
    if (unit->select_limit_cnt == HA_POS_ERROR && !select_lex->next_select())
2073
      select_lex->options&= ~OPTION_FOUND_ROWS;
unknown's avatar
unknown committed
2074 2075

    if (!(res=open_and_lock_tables(thd,tables)))
unknown's avatar
unknown committed
2076
    {
unknown's avatar
unknown committed
2077
      if (lex->describe)
unknown's avatar
unknown committed
2078
      {
2079 2080 2081 2082 2083 2084 2085
	if (!(result= new select_send()))
	{
	  send_error(thd, ER_OUT_OF_RESOURCES);
	  DBUG_VOID_RETURN;
	}
	else
	  thd->send_explain_fields(result);
2086
	res= mysql_explain_union(thd, &thd->lex->unit, result);
unknown's avatar
unknown committed
2087 2088 2089 2090 2091
	if (lex->describe & DESCRIBE_EXTENDED)
	{
	  char buff[1024];
	  String str(buff,(uint32) sizeof(buff), system_charset_info);
	  str.length(0);
2092
	  thd->lex->unit.print(&str);
unknown's avatar
unknown committed
2093 2094 2095 2096
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2097
	result->send_eof();
2098
        delete result;
unknown's avatar
unknown committed
2099 2100 2101
      }
      else
      {
2102
	if (!result && !(result= new select_send()))
unknown's avatar
unknown committed
2103
	{
2104 2105
	  res= -1;
	  break;
unknown's avatar
unknown committed
2106
	}
unknown's avatar
unknown committed
2107
	query_cache_store_query(thd, tables);
2108 2109 2110
	res= handle_select(thd, lex, result);
        if (result != lex->result)
          delete result;
unknown's avatar
unknown committed
2111
      }
unknown's avatar
unknown committed
2112
    }
unknown's avatar
unknown committed
2113 2114
    break;
  }
unknown's avatar
unknown committed
2115
  case SQLCOM_PREPARE:
2116
  {
2117 2118 2119 2120
    char *query_str;
    uint query_len;
    if (lex->prepared_stmt_code_is_varref)
    {
2121
      /* This is PREPARE stmt FROM @var. */
2122 2123 2124 2125
      String str;
      CHARSET_INFO *to_cs= thd->variables.collation_connection;
      bool need_conversion;
      user_var_entry *entry;
2126
      String *pstr= &str;
2127
      uint32 unused;
2128
      /*
2129 2130 2131
        Convert @var contents to string in connection character set. Although
        it is known that int/real/NULL value cannot be a valid query we still
        convert it for error messages to uniform.
2132
      */
2133 2134
      if ((entry=
             (user_var_entry*)hash_search(&thd->user_vars,
2135 2136 2137 2138
                                          (byte*)lex->prepared_stmt_code.str,
                                          lex->prepared_stmt_code.length))
          && entry->value)
      {
2139 2140
        my_bool is_var_null;
        pstr= entry->val_str(&is_var_null, &str, NOT_FIXED_DEC);
2141 2142 2143 2144
        /*
          NULL value of variable checked early as entry->value so here
          we can't get NULL in normal conditions
        */
2145 2146
        DBUG_ASSERT(!is_var_null);
        if (!pstr)
2147 2148 2149 2150
        {
          res= -1;
          break;      // EOM (error should be reported by allocator)
        }
2151 2152
      }
      else
2153 2154 2155 2156 2157
      {
        /*
          variable absent or equal to NULL, so we need to set variable to
          something reasonable to get readable error message during parsing
        */
2158
        str.set("NULL", 4, &my_charset_latin1);
2159 2160
      }

2161
      need_conversion=
2162 2163
        String::needs_conversion(pstr->length(), pstr->charset(),
                                 to_cs, &unused);
2164

2165 2166
      query_len= need_conversion? (pstr->length() * to_cs->mbmaxlen) :
                                  pstr->length();
unknown's avatar
unknown committed
2167
      if (!(query_str= alloc_root(thd->mem_root, query_len+1)))
2168 2169 2170 2171
      {
        res= -1;
        break;        // EOM (error should be reported by allocator)
      }
2172

2173
      if (need_conversion)
2174 2175 2176 2177 2178 2179
      {
        uint dummy_errors;
        query_len= copy_and_convert(query_str, query_len, to_cs,
                                    pstr->ptr(), pstr->length(),
                                    pstr->charset(), &dummy_errors);
      }
2180
      else
2181
        memcpy(query_str, pstr->ptr(), pstr->length());
2182
      query_str[query_len]= 0;
2183 2184 2185
    }
    else
    {
2186 2187
      query_str= lex->prepared_stmt_code.str;
      query_len= lex->prepared_stmt_code.length;
2188
      DBUG_PRINT("info", ("PREPARE: %.*s FROM '%.*s' \n",
2189 2190
                          lex->prepared_stmt_name.length,
                          lex->prepared_stmt_name.str,
2191
                          query_len, query_str));
2192
    }
unknown's avatar
unknown committed
2193
    thd->command= COM_PREPARE;
2194 2195
    if (!mysql_stmt_prepare(thd, query_str, query_len + 1,
                            &lex->prepared_stmt_name))
unknown's avatar
unknown committed
2196 2197 2198 2199 2200
      send_ok(thd, 0L, 0L, "Statement prepared");
    break;
  }
  case SQLCOM_EXECUTE:
  {
2201
    DBUG_PRINT("info", ("EXECUTE: %.*s\n",
2202 2203 2204
                        lex->prepared_stmt_name.length,
                        lex->prepared_stmt_name.str));
    mysql_sql_stmt_execute(thd, &lex->prepared_stmt_name);
unknown's avatar
unknown committed
2205 2206 2207 2208 2209
    lex->prepared_stmt_params.empty();
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2210 2211 2212 2213
    Statement* stmt;
    DBUG_PRINT("info", ("DEALLOCATE PREPARE: %.*s\n", 
                        lex->prepared_stmt_name.length,
                        lex->prepared_stmt_name.str));
2214 2215
    /* We account deallocate in the same manner as mysql_stmt_close */
    statistic_increment(com_stmt_close, &LOCK_status);
2216
    if ((stmt= thd->stmt_map.find_by_name(&lex->prepared_stmt_name)))
unknown's avatar
unknown committed
2217
    {
2218 2219
      thd->stmt_map.erase(stmt);
      send_ok(thd);
unknown's avatar
unknown committed
2220
    }
2221
    else
2222 2223 2224 2225 2226 2227
    {
      res= -1;
      my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0),
               lex->prepared_stmt_name.length, lex->prepared_stmt_name.str,
               "DEALLOCATE PREPARE");
    }
unknown's avatar
unknown committed
2228 2229
    break;
  }
unknown's avatar
unknown committed
2230
  case SQLCOM_DO:
unknown's avatar
unknown committed
2231
    if (tables && ((res= check_table_access(thd, SELECT_ACL, tables,0)) ||
unknown's avatar
unknown committed
2232 2233 2234 2235 2236 2237
		   (res= open_and_lock_tables(thd,tables))))
	break;

    res= mysql_do(thd, *lex->insert_list);
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
2238 2239
    break;

2240
  case SQLCOM_EMPTY_QUERY:
2241
    send_ok(thd);
2242 2243
    break;

unknown's avatar
unknown committed
2244 2245 2246 2247
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2248
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2249
  case SQLCOM_PURGE:
2250
  {
unknown's avatar
unknown committed
2251
    if (check_global_access(thd, SUPER_ACL))
2252
      goto error;
2253
    // PURGE MASTER LOGS TO 'file'
2254 2255 2256
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2257 2258 2259 2260 2261 2262 2263 2264
  case SQLCOM_PURGE_BEFORE:
  {
    if (check_global_access(thd, SUPER_ACL))
      goto error;
    // PURGE MASTER LOGS BEFORE 'data'
    res = purge_master_logs_before_date(thd, lex->purge_time);
    break;
  }
2265
#endif
unknown's avatar
unknown committed
2266 2267
  case SQLCOM_SHOW_WARNS:
  {
2268 2269
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2270 2271 2272
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
unknown's avatar
unknown committed
2273 2274 2275 2276
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2277 2278
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
unknown's avatar
unknown committed
2279 2280
    break;
  }
unknown's avatar
unknown committed
2281 2282
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
2283
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2284
      goto error;
2285
    /* This query don't work now. See comment in repl_failsafe.cc */
unknown's avatar
unknown committed
2286
#ifndef WORKING_NEW_MASTER
2287
    net_printf(thd, ER_NOT_SUPPORTED_YET, "SHOW NEW MASTER");
unknown's avatar
unknown committed
2288 2289
    res= 1;
#else
unknown's avatar
unknown committed
2290
    res = show_new_master(thd);
unknown's avatar
unknown committed
2291
#endif
unknown's avatar
unknown committed
2292 2293
    break;
  }
2294

unknown's avatar
unknown committed
2295
#ifdef HAVE_REPLICATION
2296 2297
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2298
    if (check_global_access(thd, REPL_SLAVE_ACL))
2299 2300 2301 2302
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2303 2304
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2305
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2306 2307 2308 2309
      goto error;
    res = show_binlog_events(thd);
    break;
  }
2310 2311
#endif

unknown's avatar
unknown committed
2312
  case SQLCOM_BACKUP_TABLE:
2313 2314
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2315
	check_table_access(thd,SELECT_ACL, tables,0) ||
unknown's avatar
unknown committed
2316
	check_global_access(thd, FILE_ACL))
2317
      goto error; /* purecov: inspected */
2318
    thd->enable_slow_log= opt_log_slow_admin_statements;
2319
    res = mysql_backup_table(thd, tables);
unknown's avatar
unknown committed
2320

2321 2322
    break;
  }
unknown's avatar
unknown committed
2323
  case SQLCOM_RESTORE_TABLE:
2324 2325
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2326
	check_table_access(thd, INSERT_ACL, tables,0) ||
unknown's avatar
unknown committed
2327
	check_global_access(thd, FILE_ACL))
2328
      goto error; /* purecov: inspected */
2329
    thd->enable_slow_log= opt_log_slow_admin_statements;
2330 2331 2332
    res = mysql_restore_table(thd, tables);
    break;
  }
unknown's avatar
unknown committed
2333 2334 2335
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
    if (check_db_used(thd, tables) ||
unknown's avatar
unknown committed
2336 2337
        check_access(thd, INDEX_ACL, tables->db,
                     &tables->grant.privilege, 0, 0))
unknown's avatar
unknown committed
2338
      goto error;
2339
    res= mysql_assign_to_keycache(thd, tables, &lex->name_and_length);
unknown's avatar
unknown committed
2340 2341
    break;
  }
unknown's avatar
unknown committed
2342 2343 2344
  case SQLCOM_PRELOAD_KEYS:
  {
    if (check_db_used(thd, tables) ||
unknown's avatar
unknown committed
2345 2346
	check_access(thd, INDEX_ACL, tables->db,
                     &tables->grant.privilege, 0, 0))
2347
      goto error;
unknown's avatar
unknown committed
2348 2349 2350
    res = mysql_preload_keys(thd, tables);
    break;
  }
unknown's avatar
unknown committed
2351
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2352
  case SQLCOM_CHANGE_MASTER:
2353
  {
unknown's avatar
unknown committed
2354
    if (check_global_access(thd, SUPER_ACL))
2355
      goto error;
2356
    pthread_mutex_lock(&LOCK_active_mi);
2357
    res = change_master(thd,active_mi);
2358
    pthread_mutex_unlock(&LOCK_active_mi);
2359 2360
    break;
  }
unknown's avatar
unknown committed
2361
  case SQLCOM_SHOW_SLAVE_STAT:
2362
  {
2363 2364
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2365
      goto error;
2366
    pthread_mutex_lock(&LOCK_active_mi);
2367
    res = show_master_info(thd,active_mi);
2368
    pthread_mutex_unlock(&LOCK_active_mi);
2369 2370
    break;
  }
unknown's avatar
unknown committed
2371
  case SQLCOM_SHOW_MASTER_STAT:
2372
  {
2373 2374
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2375 2376 2377 2378
      goto error;
    res = show_binlog_info(thd);
    break;
  }
unknown's avatar
unknown committed
2379

2380
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
2381
    if (check_global_access(thd, SUPER_ACL))
2382
      goto error;
2383 2384 2385 2386
    if (end_active_trans(thd))
      res= -1;
    else
      res = load_master_data(thd);
2387
    break;
unknown's avatar
unknown committed
2388
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
2389 2390 2391
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
2392
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2393 2394 2395 2396 2397
	goto error;
      res = innodb_show_status(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
2398
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2399
  case SQLCOM_LOAD_MASTER_TABLE:
2400
  {
unknown's avatar
unknown committed
2401 2402
    if (!tables->db)
      tables->db=thd->db;
unknown's avatar
unknown committed
2403
    if (check_access(thd,CREATE_ACL,tables->db,&tables->grant.privilege,0,0))
unknown's avatar
unknown committed
2404 2405 2406 2407
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
unknown's avatar
unknown committed
2408
      if (check_grant(thd, CREATE_ACL, tables, 0, 1, 0))
2409
	goto error;
unknown's avatar
unknown committed
2410
    }
2411
    if (strlen(tables->real_name) > NAME_LEN)
unknown's avatar
unknown committed
2412
    {
2413
      net_printf(thd,ER_WRONG_TABLE_NAME, tables->real_name);
unknown's avatar
unknown committed
2414 2415
      break;
    }
2416
    pthread_mutex_lock(&LOCK_active_mi);
2417 2418 2419 2420
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2421
    if (!fetch_master_table(thd, tables->db, tables->real_name,
2422
			    active_mi, 0, 0))
2423
    {
2424
      send_ok(thd);
2425
    }
2426
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2427
    break;
2428
  }
unknown's avatar
unknown committed
2429
#endif /* HAVE_REPLICATION */
2430

unknown's avatar
unknown committed
2431
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
2432
  {
2433
    /* If CREATE TABLE of non-temporary table, do implicit commit */
2434 2435 2436 2437 2438 2439 2440 2441 2442 2443
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
    {
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
    else 
    {
unknown's avatar
unknown committed
2444 2445
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
2446
    }
unknown's avatar
unknown committed
2447
    /* Skip first table, which is the table we are creating */
2448 2449 2450
    TABLE_LIST *create_table, *create_table_local;
    tables= lex->unlink_first_table(tables, &create_table,
				    &create_table_local);
unknown's avatar
unknown committed
2451

unknown's avatar
unknown committed
2452 2453 2454
    if ((res= create_table_precheck(thd, tables, create_table)))
      goto unsent_create_error;

2455 2456 2457
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
2458
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
2459
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
unknown's avatar
unknown committed
2460
			   create_table->real_name) ||
unknown's avatar
unknown committed
2461
	append_file_to_dir(thd,&lex->create_info.index_file_name,
unknown's avatar
unknown committed
2462
			   create_table->real_name))
2463 2464
    {
      res=-1;
2465
      goto unsent_create_error;
2466
    }
2467
#endif
2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480
    /*
      If we are using SET CHARSET without DEFAULT, add an implicite
      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;
    }
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496
    /*
      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))
    {
      res= -1;
2497
      goto unsent_create_error;
2498
    }
2499
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
2500 2501 2502
    {
      select_result *result;

2503
      select_lex->options|= SELECT_NO_UNLOCK;
2504 2505 2506 2507
      unit->offset_limit_cnt= select_lex->offset_limit;
      unit->select_limit_cnt= select_lex->select_limit+
	select_lex->offset_limit;
      if (unit->select_limit_cnt < select_lex->select_limit)
unknown's avatar
unknown committed
2508
	unit->select_limit_cnt= HA_POS_ERROR;	// No limit
2509

unknown's avatar
unknown committed
2510
      if (!(res=open_and_lock_tables(thd,tables)))
2511
      {
unknown's avatar
unknown committed
2512 2513 2514 2515
	res= -1;				// If error
        if ((result=new select_create(create_table->db,
                                      create_table->real_name,
				      &lex->create_info,
2516 2517
                                      lex->create_list,
                                      lex->key_list,
2518 2519
                                      select_lex->item_list, lex->duplicates,
                                      lex->ignore)))
2520 2521 2522 2523 2524 2525
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
          select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
2526
          res=handle_select(thd, lex, result);
2527 2528
          select_lex->resolve_mode= SELECT_LEX::NOMATTER_MODE;
        }
2529 2530 2531
	//reset for PS
	lex->create_list.empty();
	lex->key_list.empty();
2532 2533
      }
    }
unknown's avatar
unknown committed
2534 2535
    else // regular create
    {
unknown's avatar
unknown committed
2536
      if (lex->name)
unknown's avatar
unknown committed
2537
        res= mysql_create_like_table(thd, create_table, &lex->create_info, 
unknown's avatar
unknown committed
2538 2539
                                     (Table_ident *)lex->name); 
      else
2540
      {
unknown's avatar
unknown committed
2541 2542
        res= mysql_create_table(thd,create_table->db,
			         create_table->real_name, &lex->create_info,
unknown's avatar
unknown committed
2543
			         lex->create_list,
2544
			         lex->key_list,0,0);
2545
      }
unknown's avatar
unknown committed
2546
      if (!res)
2547
	send_ok(thd);
unknown's avatar
unknown committed
2548
    }
2549 2550 2551 2552 2553
    /*
      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);
2554

2555 2556
unsent_create_error:
    // put tables back for PS rexecuting
2557 2558
    tables= lex->link_first_table_back(tables, create_table,
				       create_table_local);
unknown's avatar
unknown committed
2559
    break;
unknown's avatar
unknown committed
2560
  }
unknown's avatar
unknown committed
2561
  case SQLCOM_CREATE_INDEX:
unknown's avatar
unknown committed
2562
    if (check_one_table_access(thd, INDEX_ACL, tables))
unknown's avatar
unknown committed
2563
      goto error; /* purecov: inspected */
2564
    thd->enable_slow_log= opt_log_slow_admin_statements;
2565 2566 2567 2568
    if (end_active_trans(thd))
      res= -1;
    else
      res = mysql_create_index(thd, tables, lex->key_list);
unknown's avatar
unknown committed
2569 2570
    break;

unknown's avatar
unknown committed
2571
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2572
  case SQLCOM_SLAVE_START:
2573
  {
2574
    pthread_mutex_lock(&LOCK_active_mi);
2575
    start_slave(thd,active_mi,1 /* net report*/);
2576
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2577
    break;
2578
  }
unknown's avatar
unknown committed
2579
  case SQLCOM_SLAVE_STOP:
2580 2581 2582 2583 2584 2585
  /*
    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,
2586
      so it waits for the client thread because t is locked by it.
2587
    - then the client thread does SLAVE STOP.
2588 2589
      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.
2590 2591 2592 2593 2594
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
  if (thd->locked_tables || thd->active_transaction())
  {
2595
    send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
2596
    break;
2597
  }
2598
  {
2599
    pthread_mutex_lock(&LOCK_active_mi);
2600
    stop_slave(thd,active_mi,1/* net report*/);
2601
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2602
    break;
2603
  }
unknown's avatar
unknown committed
2604
#endif /* HAVE_REPLICATION */
2605

unknown's avatar
unknown committed
2606 2607
  case SQLCOM_ALTER_TABLE:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
2608
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
unknown's avatar
unknown committed
2609 2610 2611
    break;
#else
    {
unknown's avatar
unknown committed
2612
      ulong priv=0;
unknown's avatar
unknown committed
2613
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
unknown's avatar
unknown committed
2614
      {
2615
	net_printf(thd, ER_WRONG_TABLE_NAME, lex->name);
unknown's avatar
unknown committed
2616
	res= 1;
unknown's avatar
unknown committed
2617 2618
	break;
      }
2619
      if (!select_lex->db)
2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637
      {
        /*
          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)
          {
            send_error(thd,ER_NO_DB_ERROR);
            goto error;
          }
          select_lex->db= thd->db;
        }
        else
          select_lex->db=tables->db;
      }
unknown's avatar
unknown committed
2638 2639
      if (check_access(thd,ALTER_ACL,tables->db,&tables->grant.privilege,0,0) ||
	  check_access(thd,INSERT_ACL | CREATE_ACL,select_lex->db,&priv,0,0)||
unknown's avatar
unknown committed
2640
	  check_merge_table_access(thd, tables->db,
2641 2642 2643
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
2644 2645
      if (grant_option)
      {
unknown's avatar
unknown committed
2646
	if (check_grant(thd, ALTER_ACL, tables, 0, UINT_MAX, 0))
unknown's avatar
unknown committed
2647 2648 2649 2650 2651 2652
	  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));
	  tmp_table.real_name=lex->name;
2653
	  tmp_table.db=select_lex->db;
unknown's avatar
unknown committed
2654
	  tmp_table.grant.privilege=priv;
unknown's avatar
unknown committed
2655 2656
	  if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0,
			  UINT_MAX, 0))
unknown's avatar
unknown committed
2657 2658 2659
	    goto error;
	}
      }
2660 2661
      /* Don't yet allow changing of symlinks with ALTER TABLE */
      lex->create_info.data_file_name=lex->create_info.index_file_name=0;
unknown's avatar
unknown committed
2662
      /* ALTER TABLE ends previous transaction */
2663
      if (end_active_trans(thd))
unknown's avatar
unknown committed
2664 2665
	res= -1;
      else
unknown's avatar
unknown committed
2666
      {
2667
        thd->enable_slow_log= opt_log_slow_admin_statements;
2668
	res= mysql_alter_table(thd, select_lex->db, lex->name,
unknown's avatar
unknown committed
2669 2670
			       &lex->create_info,
			       tables, lex->create_list,
2671
			       lex->key_list,
2672
			       select_lex->order_list.elements,
2673
                               (ORDER *) select_lex->order_list.first,
2674
			       lex->duplicates, lex->ignore, &lex->alter_info);
unknown's avatar
unknown committed
2675
      }
unknown's avatar
unknown committed
2676 2677
      break;
    }
unknown's avatar
unknown committed
2678
#endif /*DONT_ALLOW_SHOW_COMMANDS*/
unknown's avatar
unknown committed
2679
  case SQLCOM_RENAME_TABLE:
unknown's avatar
unknown committed
2680 2681 2682
  {
    TABLE_LIST *table;
    if (check_db_used(thd,tables))
unknown's avatar
unknown committed
2683
      goto error;
unknown's avatar
unknown committed
2684 2685
    for (table=tables ; table ; table=table->next->next)
    {
unknown's avatar
unknown committed
2686
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
unknown's avatar
unknown committed
2687
		       &table->grant.privilege,0,0) ||
unknown's avatar
unknown committed
2688
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next->db,
unknown's avatar
unknown committed
2689
		       &table->next->grant.privilege,0,0))
unknown's avatar
unknown committed
2690 2691 2692
	goto error;
      if (grant_option)
      {
unknown's avatar
unknown committed
2693
	TABLE_LIST old_list,new_list;
unknown's avatar
unknown committed
2694 2695 2696 2697
	/*
	  we do not need initialize old_list and new_list because we will
	  come table[0] and table->next[0] there
	*/
unknown's avatar
unknown committed
2698 2699 2700
	old_list=table[0];
	new_list=table->next[0];
	old_list.next=new_list.next=0;
unknown's avatar
unknown committed
2701
	if (check_grant(thd, ALTER_ACL, &old_list, 0, UINT_MAX, 0) ||
unknown's avatar
unknown committed
2702
	    (!test_all_bits(table->next->grant.privilege,
2703
			    INSERT_ACL | CREATE_ACL) &&
unknown's avatar
unknown committed
2704 2705
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0,
			 UINT_MAX, 0)))
unknown's avatar
unknown committed
2706 2707 2708
	  goto error;
      }
    }
unknown's avatar
unknown committed
2709
    query_cache_invalidate3(thd, tables, 0);
2710 2711 2712
    if (end_active_trans(thd))
      res= -1;
    else if (mysql_rename_tables(thd,tables))
unknown's avatar
unknown committed
2713 2714
      res= -1;
    break;
unknown's avatar
unknown committed
2715
  }
2716
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2717 2718
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
2719
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
unknown's avatar
unknown committed
2720 2721 2722
    DBUG_VOID_RETURN;
#else
    {
unknown's avatar
unknown committed
2723
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2724 2725 2726 2727
	goto error;
      res = show_binlogs(thd);
      break;
    }
unknown's avatar
unknown committed
2728
#endif
2729
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
2730
  case SQLCOM_SHOW_CREATE:
unknown's avatar
unknown committed
2731
#ifdef DONT_ALLOW_SHOW_COMMANDS
2732
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
unknown's avatar
unknown committed
2733 2734
    DBUG_VOID_RETURN;
#else
unknown's avatar
unknown committed
2735
    {
unknown's avatar
unknown committed
2736 2737
      if (check_db_used(thd, tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, tables->db,
unknown's avatar
unknown committed
2738
		       &tables->grant.privilege,0,0))
unknown's avatar
unknown committed
2739
	goto error;
2740 2741 2742
      if (grant_option && check_grant(thd, SELECT_ACL, tables, 2, UINT_MAX, 0))
	goto error;
      res= mysqld_show_create(thd, tables);
unknown's avatar
unknown committed
2743 2744
      break;
    }
unknown's avatar
unknown committed
2745
#endif
2746 2747 2748
  case SQLCOM_CHECKSUM:
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2749
	check_table_access(thd, SELECT_ACL | EXTRA_ACL , tables,0))
2750
      goto error; /* purecov: inspected */
2751
    res = mysql_checksum_table(thd, tables, &lex->check_opt);
2752 2753
    break;
  }
unknown's avatar
unknown committed
2754
  case SQLCOM_REPAIR:
2755 2756
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2757
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables,0))
2758
      goto error; /* purecov: inspected */
2759
    thd->enable_slow_log= opt_log_slow_admin_statements;
2760
    res = mysql_repair_table(thd, tables, &lex->check_opt);
2761 2762 2763 2764 2765 2766
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      mysql_update_log.write(thd, thd->query, thd->query_length);
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
2767
	thd->clear_error(); // No binlog error generated
2768
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
2769 2770 2771
        mysql_bin_log.write(&qinfo);
      }
    }
2772 2773
    break;
  }
unknown's avatar
unknown committed
2774
  case SQLCOM_CHECK:
2775 2776
  {
    if (check_db_used(thd,tables) ||
2777
	check_table_access(thd, SELECT_ACL | EXTRA_ACL , tables,0))
2778
      goto error; /* purecov: inspected */
2779
    thd->enable_slow_log= opt_log_slow_admin_statements;
2780 2781 2782
    res = mysql_check_table(thd, tables, &lex->check_opt);
    break;
  }
unknown's avatar
unknown committed
2783 2784
  case SQLCOM_ANALYZE:
  {
unknown's avatar
unknown committed
2785
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2786
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables,0))
unknown's avatar
unknown committed
2787
      goto error; /* purecov: inspected */
2788
    thd->enable_slow_log= opt_log_slow_admin_statements;
2789
    res = mysql_analyze_table(thd, tables, &lex->check_opt);
2790 2791 2792 2793 2794 2795
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      mysql_update_log.write(thd, thd->query, thd->query_length);
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
2796
	thd->clear_error(); // No binlog error generated
2797
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
2798 2799 2800
        mysql_bin_log.write(&qinfo);
      }
    }
unknown's avatar
unknown committed
2801
    break;
unknown's avatar
unknown committed
2802
  }
2803

unknown's avatar
unknown committed
2804 2805
  case SQLCOM_OPTIMIZE:
  {
2806
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2807
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables,0))
unknown's avatar
unknown committed
2808
      goto error; /* purecov: inspected */
2809
    thd->enable_slow_log= opt_log_slow_admin_statements;
2810 2811 2812
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
      mysql_recreate_table(thd, tables, 1) :
      mysql_optimize_table(thd, tables, &lex->check_opt);
2813 2814 2815 2816 2817 2818
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      mysql_update_log.write(thd, thd->query, thd->query_length);
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
2819
	thd->clear_error(); // No binlog error generated
2820
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
2821 2822 2823
        mysql_bin_log.write(&qinfo);
      }
    }
unknown's avatar
unknown committed
2824 2825 2826
    break;
  }
  case SQLCOM_UPDATE:
unknown's avatar
unknown committed
2827 2828
    if (update_precheck(thd, tables))
      break;
2829 2830 2831 2832
    res= mysql_update(thd,tables,
                      select_lex->item_list,
                      lex->value_list,
                      select_lex->where,
2833
		      select_lex->order_list.elements,
2834 2835
                      (ORDER *) select_lex->order_list.first,
                      select_lex->select_limit,
2836
                      lex->duplicates, lex->ignore);
unknown's avatar
unknown committed
2837 2838
    if (thd->net.report_error)
      res= -1;
2839 2840
    break;
  case SQLCOM_UPDATE_MULTI:
unknown's avatar
unknown committed
2841
  {
2842
    if ((res= multi_update_precheck(thd, tables)))
unknown's avatar
unknown committed
2843 2844 2845 2846 2847 2848
      break;
    res= mysql_multi_update(thd,tables,
			    &select_lex->item_list,
			    &lex->value_list,
			    select_lex->where,
			    select_lex->options,
2849
			    lex->duplicates, lex->ignore, unit, select_lex);
unknown's avatar
unknown committed
2850
    break;
unknown's avatar
unknown committed
2851
  }
unknown's avatar
unknown committed
2852
  case SQLCOM_REPLACE:
2853 2854
  case SQLCOM_INSERT:
  {
2855
    if ((res= insert_precheck(thd, tables)))
unknown's avatar
unknown committed
2856
      break;
2857 2858 2859
    res= mysql_insert(thd,tables,lex->field_list,lex->many_values,
                      lex->update_list, lex->value_list,
                      lex->duplicates, lex->ignore);
unknown's avatar
unknown committed
2860 2861
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
2862
    break;
2863
  }
unknown's avatar
unknown committed
2864 2865 2866
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
2867
    TABLE_LIST *first_local_table= (TABLE_LIST *) select_lex->table_list.first;
unknown's avatar
unknown committed
2868 2869
    TABLE_LIST dup_tables;
    TABLE *insert_table;
unknown's avatar
unknown committed
2870
    if ((res= insert_precheck(thd, tables)))
2871
      break;
unknown's avatar
unknown committed
2872

2873 2874
    /* Fix lock for first table */
    if (tables->lock_type == TL_WRITE_DELAYED)
2875
      tables->lock_type= TL_WRITE;
2876

2877 2878
    /* Don't unlock tables until command is written to binary log */
    select_lex->options|= SELECT_NO_UNLOCK;
unknown's avatar
unknown committed
2879 2880

    select_result *result;
2881 2882 2883 2884
    unit->offset_limit_cnt= select_lex->offset_limit;
    unit->select_limit_cnt= select_lex->select_limit+select_lex->offset_limit;
    if (unit->select_limit_cnt < select_lex->select_limit)
      unit->select_limit_cnt= HA_POS_ERROR;		// No limit
unknown's avatar
unknown committed
2885

2886
    if (find_real_table_in_list(tables->next, tables->db, tables->real_name))
2887
    {
2888 2889
      /* Using same table for INSERT and SELECT */
      select_lex->options |= OPTION_BUFFER_RESULT;
unknown's avatar
unknown committed
2890
    }
2891

unknown's avatar
unknown committed
2892 2893 2894
    if ((res= open_and_lock_tables(thd, tables)))
      break;
      
unknown's avatar
unknown committed
2895
    insert_table= tables->table;
unknown's avatar
unknown committed
2896
    /* Skip first table, which is the table we are inserting in */
unknown's avatar
unknown committed
2897
    select_lex->table_list.first= (byte*) first_local_table->next;
unknown's avatar
unknown committed
2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912
    tables= (TABLE_LIST *) select_lex->table_list.first;
    dup_tables= *first_local_table;
    first_local_table->next= 0;
    if (select_lex->group_list.elements != 0)
    {
      /*
        When we are using GROUP BY we can't refere to other tables in the
        ON DUPLICATE KEY part
      */         
      dup_tables.next= 0;
    }

    if (!(res= mysql_prepare_insert(thd, tables, first_local_table,
				    &dup_tables, insert_table,
                                    lex->field_list, 0,
unknown's avatar
unknown committed
2913 2914
				    lex->update_list, lex->value_list,
				    lex->duplicates)) &&
unknown's avatar
unknown committed
2915 2916
        (result= new select_insert(insert_table, first_local_table,
				   &dup_tables, &lex->field_list,
unknown's avatar
unknown committed
2917
				   &lex->update_list, &lex->value_list,
2918
                                   lex->duplicates, lex->ignore)))
2919
    {
2920 2921 2922 2923 2924 2925 2926 2927 2928
      /*
        insert/replace from SELECT give its SELECT_LEX for SELECT,
        and item_list belong to SELECT
      */
      lex->select_lex.resolve_mode= SELECT_LEX::SELECT_MODE;
      res= handle_select(thd, lex, result);
      /* revert changes for SP */
      lex->select_lex.resolve_mode= SELECT_LEX::INSERT_MODE;
      delete result;
unknown's avatar
unknown committed
2929
      if (thd->net.report_error)
2930
        res= -1;
2931 2932 2933
    }
    else
      res= -1;
2934
    insert_table->insert_values= 0;        // Set by mysql_prepare_insert()
unknown's avatar
unknown committed
2935
    first_local_table->next= tables;
unknown's avatar
unknown committed
2936
    lex->select_lex.table_list.first= (byte*) first_local_table;
unknown's avatar
unknown committed
2937 2938
    break;
  }
2939
  case SQLCOM_TRUNCATE:
2940 2941 2942 2943 2944
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
unknown committed
2945
    if (check_one_table_access(thd, DELETE_ACL, tables))
unknown's avatar
unknown committed
2946
      goto error;
2947 2948 2949 2950 2951 2952
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
    if (thd->locked_tables || thd->active_transaction())
    {
2953
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION,NullS);
2954 2955
      goto error;
    }
2956
    res=mysql_truncate(thd, tables, 0);
2957
    break;
unknown's avatar
unknown committed
2958
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
2959
  {
unknown's avatar
unknown committed
2960 2961
    if ((res= delete_precheck(thd, tables)))
      break;
unknown's avatar
unknown committed
2962
    res = mysql_delete(thd,tables, select_lex->where,
2963
                       &select_lex->order_list,
unknown's avatar
unknown committed
2964
                       select_lex->select_limit, select_lex->options);
unknown's avatar
unknown committed
2965 2966
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
2967 2968
    break;
  }
2969
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
2970
  {
2971 2972
    TABLE_LIST *aux_tables=
      (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
unknown's avatar
unknown committed
2973 2974
    TABLE_LIST *target_tbl;
    uint table_count;
unknown's avatar
unknown committed
2975
    multi_delete *result;
unknown's avatar
unknown committed
2976

2977 2978
    if ((res= multi_delete_precheck(thd, tables, &table_count)))
      break;
unknown's avatar
unknown committed
2979

unknown's avatar
unknown committed
2980
    /* condition will be TRUE on SP re-excuting */
2981 2982
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
unknown's avatar
unknown committed
2983
    if (add_item_to_list(thd, new Item_null()))
2984
    {
unknown's avatar
unknown committed
2985
      res= -1;
2986
      break;
unknown's avatar
unknown committed
2987
    }
2988

unknown's avatar
unknown committed
2989 2990 2991 2992
    thd->proc_info="init";
    if ((res=open_and_lock_tables(thd,tables)))
      break;
    /* Fix tables-to-be-deleted-from list to point at opened tables */
unknown's avatar
unknown committed
2993 2994 2995
    for (target_tbl= (TABLE_LIST*) aux_tables;
	 target_tbl;
	 target_tbl= target_tbl->next)
unknown's avatar
unknown committed
2996
    {
2997 2998 2999
      TABLE_LIST *orig= target_tbl->table_list;
      target_tbl->table= orig->table;
      /*
unknown's avatar
unknown committed
3000
	 Multi-delete can't be constructed over-union => we always have
unknown's avatar
unknown committed
3001
	 single SELECT on top and have to check underlying SELECTs of it
3002
      */
3003 3004
      if (lex->select_lex.check_updateable_in_subqueries(orig->db,
                                                         orig->real_name))
3005
      {
3006 3007 3008 3009
        my_error(ER_UPDATE_TABLE_USED, MYF(0),
                 orig->real_name);
        res= -1;
        break;
3010
      }
unknown's avatar
unknown committed
3011
    }
3012

3013 3014
    if (!thd->is_fatal_error && (result= new multi_delete(thd,aux_tables,
							  table_count)))
unknown's avatar
unknown committed
3015
    {
3016 3017 3018
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3019
			select_lex->item_list,
unknown's avatar
unknown committed
3020
			select_lex->where,
3021
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
unknown's avatar
unknown committed
3022 3023
			(ORDER *)NULL,
			select_lex->options | thd->options |
unknown's avatar
unknown committed
3024
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK,
3025
			result, unit, select_lex);
unknown's avatar
unknown committed
3026 3027
      if (thd->net.report_error)
	res= -1;
3028
      delete result;
unknown's avatar
unknown committed
3029 3030 3031 3032 3033 3034
    }
    else
      res= -1;					// Error is not sent
    close_thread_tables(thd);
    break;
  }
unknown's avatar
unknown committed
3035
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
3036
  {
3037 3038
    if (!lex->drop_temporary)
    {
unknown's avatar
unknown committed
3039
      if (check_table_access(thd,DROP_ACL,tables,0))
3040 3041 3042 3043 3044 3045 3046
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
unknown's avatar
unknown committed
3047
    else
unknown's avatar
unknown committed
3048 3049 3050 3051 3052 3053
    {
      /*
	If this is a slave thread, we may sometimes execute some 
	DROP / * 40005 TEMPORARY * / TABLE
	that come from parts of binlogs (likely if we use RESET SLAVE or CHANGE
	MASTER TO), while the temporary table has already been dropped.
unknown's avatar
unknown committed
3054 3055
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
unknown's avatar
unknown committed
3056 3057 3058
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
3059

unknown's avatar
unknown committed
3060 3061
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
      thd->options|= OPTION_STATUS_NO_TRANS_UPDATE;
unknown's avatar
unknown committed
3062
    }
3063
    res= mysql_rm_table(thd,tables,lex->drop_if_exists, lex->drop_temporary);
unknown's avatar
unknown committed
3064 3065
  }
  break;
unknown's avatar
unknown committed
3066
  case SQLCOM_DROP_INDEX:
unknown's avatar
unknown committed
3067
    if (check_one_table_access(thd, INDEX_ACL, tables))
unknown's avatar
unknown committed
3068
      goto error;				/* purecov: inspected */
3069 3070 3071
    if (end_active_trans(thd))
      res= -1;
    else
3072
      res = mysql_drop_index(thd, tables, &lex->alter_info);
unknown's avatar
unknown committed
3073 3074
    break;
  case SQLCOM_SHOW_DATABASES:
3075
#if defined(DONT_ALLOW_SHOW_COMMANDS)
3076
    send_error(thd,ER_NOT_ALLOWED_COMMAND);   /* purecov: inspected */
unknown's avatar
unknown committed
3077 3078 3079
    DBUG_VOID_RETURN;
#else
    if ((specialflag & SPECIAL_SKIP_SHOW_DB) &&
unknown's avatar
unknown committed
3080
	check_global_access(thd, SHOW_DB_ACL))
unknown's avatar
unknown committed
3081 3082 3083 3084 3085
      goto error;
    res= mysqld_show_dbs(thd, (lex->wild ? lex->wild->ptr() : NullS));
    break;
#endif
  case SQLCOM_SHOW_PROCESSLIST:
unknown's avatar
unknown committed
3086
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
3087
      break;
unknown's avatar
unknown committed
3088 3089
    mysqld_list_processes(thd,
			  thd->master_access & PROCESS_ACL ? NullS :
unknown's avatar
unknown committed
3090
			  thd->priv_user,lex->verbose);
unknown's avatar
unknown committed
3091
    break;
unknown's avatar
unknown committed
3092 3093
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
unknown's avatar
unknown committed
3094 3095 3096 3097 3098 3099 3100
    break;
  case SQLCOM_SHOW_PRIVILEGES:
    res= mysqld_show_privileges(thd);
    break;
  case SQLCOM_SHOW_COLUMN_TYPES:
    res= mysqld_show_column_types(thd);
    break;
unknown's avatar
unknown committed
3101
  case SQLCOM_SHOW_STATUS:
3102
    res= mysqld_show(thd,(lex->wild ? lex->wild->ptr() : NullS),status_vars,
3103
		     OPT_GLOBAL, &LOCK_status);
unknown's avatar
unknown committed
3104 3105 3106
    break;
  case SQLCOM_SHOW_VARIABLES:
    res= mysqld_show(thd, (lex->wild ? lex->wild->ptr() : NullS),
3107 3108
		     init_vars, lex->option_type,
		     &LOCK_global_system_variables);
unknown's avatar
unknown committed
3109
    break;
unknown's avatar
unknown committed
3110 3111
  case SQLCOM_SHOW_LOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
3112
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
3113 3114 3115
    DBUG_VOID_RETURN;
#else
    {
unknown's avatar
unknown committed
3116
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0))
unknown's avatar
unknown committed
3117 3118 3119 3120 3121
	goto error;
      res= mysqld_show_logs(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
3122
  case SQLCOM_SHOW_TABLES:
3123
    /* FALL THROUGH */
unknown's avatar
unknown committed
3124
#ifdef DONT_ALLOW_SHOW_COMMANDS
3125
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
3126 3127 3128
    DBUG_VOID_RETURN;
#else
    {
3129
      char *db=select_lex->db ? select_lex->db : thd->db;
unknown's avatar
unknown committed
3130 3131
      if (!db)
      {
3132
	send_error(thd,ER_NO_DB_ERROR);	/* purecov: inspected */
unknown's avatar
unknown committed
3133 3134 3135
	goto error;				/* purecov: inspected */
      }
      remove_escape(db);				// Fix escaped '_'
3136
      if (check_db_name(db))
unknown's avatar
unknown committed
3137
      {
3138
        net_printf(thd,ER_WRONG_DB_NAME, db);
3139
        goto error;
unknown's avatar
unknown committed
3140
      }
unknown's avatar
unknown committed
3141
      if (check_access(thd,SELECT_ACL,db,&thd->col_access,0,0))
unknown's avatar
unknown committed
3142
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
3143
      if (!thd->col_access && check_grant_db(thd,db))
unknown's avatar
unknown committed
3144
      {
unknown's avatar
unknown committed
3145
	net_printf(thd, ER_DBACCESS_DENIED_ERROR,
unknown's avatar
unknown committed
3146 3147 3148 3149 3150
		   thd->priv_user,
		   thd->priv_host,
		   db);
	goto error;
      }
unknown's avatar
unknown committed
3151
      /* grant is checked in mysqld_show_tables */
3152
      if (lex->describe)
3153
        res= mysqld_extend_show_tables(thd,db,
3154
				       (lex->wild ? lex->wild->ptr() : NullS));
unknown's avatar
unknown committed
3155 3156 3157 3158 3159 3160
      else
	res= mysqld_show_tables(thd,db,
				(lex->wild ? lex->wild->ptr() : NullS));
      break;
    }
#endif
3161 3162 3163
  case SQLCOM_SHOW_OPEN_TABLES:
    res= mysqld_show_open_tables(thd,(lex->wild ? lex->wild->ptr() : NullS));
    break;
3164 3165
  case SQLCOM_SHOW_CHARSETS:
    res= mysqld_show_charsets(thd,(lex->wild ? lex->wild->ptr() : NullS));
3166
    break;
3167 3168 3169
  case SQLCOM_SHOW_COLLATIONS:
    res= mysqld_show_collations(thd,(lex->wild ? lex->wild->ptr() : NullS));
    break;
unknown's avatar
unknown committed
3170 3171
  case SQLCOM_SHOW_FIELDS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
3172
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
3173 3174 3175
    DBUG_VOID_RETURN;
#else
    {
3176
      char *db=tables->db;
unknown's avatar
unknown committed
3177
      remove_escape(db);			// Fix escaped '_'
3178
      remove_escape(tables->real_name);
3179
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
unknown's avatar
unknown committed
3180
		       &tables->grant.privilege, 0, 0))
unknown's avatar
unknown committed
3181
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
3182
      if (grant_option && check_grant(thd, SELECT_ACL, tables, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
3183 3184
	goto error;
      res= mysqld_show_fields(thd,tables,
unknown's avatar
unknown committed
3185 3186
			      (lex->wild ? lex->wild->ptr() : NullS),
			      lex->verbose);
unknown's avatar
unknown committed
3187 3188 3189 3190 3191
      break;
    }
#endif
  case SQLCOM_SHOW_KEYS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
3192
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
3193 3194 3195
    DBUG_VOID_RETURN;
#else
    {
3196
      char *db=tables->db;
unknown's avatar
unknown committed
3197
      remove_escape(db);			// Fix escaped '_'
3198
      remove_escape(tables->real_name);
unknown's avatar
unknown committed
3199
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
unknown's avatar
unknown committed
3200
		       &tables->grant.privilege, 0, 0))
unknown's avatar
unknown committed
3201
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
3202
      if (grant_option && check_grant(thd, SELECT_ACL, tables, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
3203 3204 3205 3206 3207 3208
	goto error;
      res= mysqld_show_keys(thd,tables);
      break;
    }
#endif
  case SQLCOM_CHANGE_DB:
3209
    mysql_change_db(thd,select_lex->db);
unknown's avatar
unknown committed
3210
    break;
3211

unknown's avatar
unknown committed
3212 3213 3214
  case SQLCOM_LOAD:
  {
    uint privilege= (lex->duplicates == DUP_REPLACE ?
3215
		     INSERT_ACL | DELETE_ACL : INSERT_ACL);
3216 3217

    if (!lex->local_file)
unknown's avatar
unknown committed
3218
    {
unknown's avatar
unknown committed
3219
      if (check_access(thd,privilege | FILE_ACL,tables->db,0,0,0))
unknown's avatar
unknown committed
3220 3221 3222 3223
	goto error;
    }
    else
    {
3224
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
unknown's avatar
unknown committed
3225
	  ! opt_local_infile)
3226
      {
3227
	send_error(thd,ER_NOT_ALLOWED_COMMAND);
3228 3229
	goto error;
      }
unknown's avatar
unknown committed
3230
      if (check_one_table_access(thd, privilege, tables))
unknown's avatar
unknown committed
3231 3232 3233
	goto error;
    }
    res=mysql_load(thd, lex->exchange, tables, lex->field_list,
3234
		   lex->duplicates, lex->ignore, (bool) lex->local_file, lex->lock_option);
unknown's avatar
unknown committed
3235 3236
    break;
  }
3237

unknown's avatar
unknown committed
3238
  case SQLCOM_SET_OPTION:
3239 3240
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
unknown's avatar
unknown committed
3241
    if (tables && ((res= check_table_access(thd, SELECT_ACL, tables,0)) ||
unknown's avatar
unknown committed
3242 3243
		   (res= open_and_lock_tables(thd,tables))))
      break;
3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
      my_printf_error(0, "The SET ONE_SHOT syntax is reserved for \
purposes internal to the MySQL server", MYF(0));
      res= -1;
      break;
    }
    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;
3258
      send_ok(thd);
3259
    }
unknown's avatar
unknown committed
3260 3261
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
3262
    break;
3263
  }
unknown's avatar
unknown committed
3264

unknown's avatar
unknown committed
3265
  case SQLCOM_UNLOCK_TABLES:
3266 3267 3268 3269 3270 3271
    /*
      It is critical for mysqldump --single-transaction --master-data that
      UNLOCK TABLES does not implicitely commit a connection which has only
      done FLUSH TABLES WITH READ LOCK + BEGIN. If this assumption becomes
      false, mysqldump will not work.
    */
unknown's avatar
unknown committed
3272
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
3273 3274
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
3275
      end_active_trans(thd);
unknown's avatar
unknown committed
3276
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3277 3278
    }
    if (thd->global_read_lock)
3279
      unlock_global_read_lock(thd);
3280
    send_ok(thd);
unknown's avatar
unknown committed
3281 3282
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
3283
    unlock_locked_tables(thd);
3284
    if (check_db_used(thd,tables) || end_active_trans(thd))
unknown's avatar
unknown committed
3285
      goto error;
unknown's avatar
unknown committed
3286
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, tables,0))
3287
      goto error;
unknown's avatar
unknown committed
3288
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
3289
    thd->options|= OPTION_TABLE_LOCK;
3290
    if (!(res= open_and_lock_tables(thd, tables)))
unknown's avatar
unknown committed
3291
    {
3292 3293 3294 3295
#ifdef HAVE_QUERY_CACHE
      if (thd->variables.query_cache_wlock_invalidate)
	query_cache.invalidate_locked_for_write(tables);
#endif /*HAVE_QUERY_CACHE*/
unknown's avatar
unknown committed
3296 3297
      thd->locked_tables=thd->lock;
      thd->lock=0;
3298
      send_ok(thd);
unknown's avatar
unknown committed
3299
    }
unknown's avatar
unknown committed
3300 3301
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3302 3303 3304
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3305
  {
3306 3307 3308 3309 3310
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
unknown committed
3311
    char *alias;
unknown's avatar
unknown committed
3312
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3313
    {
3314
      net_printf(thd,ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3315 3316
      break;
    }
3317 3318 3319 3320 3321 3322 3323
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
      For that reason, 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.
    */
3324
#ifdef HAVE_REPLICATION
3325 3326 3327
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3328 3329
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
3330
      break;
unknown's avatar
unknown committed
3331
    }
3332
#endif
unknown's avatar
unknown committed
3333
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0))
3334
      break;
unknown's avatar
unknown committed
3335
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
unknown's avatar
unknown committed
3336
			 &lex->create_info, 0);
3337 3338
    break;
  }
unknown's avatar
unknown committed
3339
  case SQLCOM_DROP_DB:
3340
  {
3341 3342 3343 3344 3345
    if (end_active_trans(thd))
    {
      res= -1;
      break;
    }
unknown's avatar
unknown committed
3346
    char *alias;
unknown's avatar
unknown committed
3347
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3348
    {
3349
      net_printf(thd, ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3350 3351
      break;
    }
3352 3353 3354 3355 3356 3357 3358
    /*
      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.
    */
3359
#ifdef HAVE_REPLICATION
3360 3361 3362
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3363 3364
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
3365
      break;
unknown's avatar
unknown committed
3366
    }
3367
#endif
unknown's avatar
unknown committed
3368
    if (check_access(thd,DROP_ACL,lex->name,0,1,0))
3369
      break;
3370 3371
    if (thd->locked_tables || thd->active_transaction())
    {
3372
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
3373 3374
      goto error;
    }
3375 3376
    res=mysql_rm_db(thd, (lower_case_table_names == 2 ? alias : lex->name),
                    lex->drop_if_exists, 0);
3377 3378
    break;
  }
3379 3380
  case SQLCOM_ALTER_DB:
  {
3381 3382
    char *db= lex->name ? lex->name : thd->db;
    if (!db)
3383
    {
3384 3385 3386 3387 3388 3389
      send_error(thd, ER_NO_DB_ERROR);
      goto error;
    }
    if (!strip_sp(db) || check_db_name(db))
    {
      net_printf(thd, ER_WRONG_DB_NAME, db);
3390 3391
      break;
    }
unknown's avatar
unknown committed
3392 3393 3394
    /*
      If in a slave thread :
      ALTER DATABASE DB may not be preceded by USE DB.
3395
      For that reason, maybe db_ok() in sql/slave.cc did not check the
unknown's avatar
unknown committed
3396 3397 3398 3399
      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
3400
    if (thd->slave_thread &&
3401 3402
	(!db_ok(db, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(db)))
unknown's avatar
unknown committed
3403 3404 3405 3406 3407
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
      break;
    }
#endif
3408
    if (check_access(thd, ALTER_ACL, db, 0, 1, 0))
3409 3410 3411
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
3412
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
3413 3414
      goto error;
    }
3415
    res= mysql_alter_db(thd, db, &lex->create_info);
3416 3417
    break;
  }
unknown's avatar
unknown committed
3418 3419 3420 3421
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3422
      net_printf(thd,ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3423 3424
      break;
    }
unknown's avatar
unknown committed
3425
    if (check_access(thd,SELECT_ACL,lex->name,0,1,0))
unknown's avatar
unknown committed
3426
      break;
unknown's avatar
unknown committed
3427
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
unknown's avatar
unknown committed
3428 3429
    break;
  }
unknown's avatar
unknown committed
3430
  case SQLCOM_CREATE_FUNCTION:
unknown's avatar
unknown committed
3431
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0))
unknown's avatar
unknown committed
3432 3433 3434
      break;
#ifdef HAVE_DLOPEN
    if (!(res = mysql_create_function(thd,&lex->udf)))
3435
      send_ok(thd);
unknown's avatar
unknown committed
3436
#else
3437
    net_printf(thd, ER_CANT_OPEN_LIBRARY, lex->udf.dl, 0, "feature disabled");
unknown's avatar
unknown committed
3438 3439 3440 3441
    res= -1;
#endif
    break;
  case SQLCOM_DROP_FUNCTION:
unknown's avatar
unknown committed
3442
    if (check_access(thd,DELETE_ACL,"mysql",0,1,0))
unknown's avatar
unknown committed
3443 3444
      break;
#ifdef HAVE_DLOPEN
3445
    if (!(res = mysql_drop_function(thd,&lex->udf.name)))
3446
      send_ok(thd);
unknown's avatar
unknown committed
3447 3448 3449 3450
#else
    res= -1;
#endif
    break;
unknown's avatar
unknown committed
3451
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3452 3453
  case SQLCOM_DROP_USER:
  {
unknown's avatar
unknown committed
3454
    if (check_access(thd, GRANT_ACL,"mysql",0,1,0))
3455 3456 3457 3458 3459 3460
      break;
    if (!(res= mysql_drop_user(thd, lex->users_list)))
    {
      mysql_update_log.write(thd, thd->query, thd->query_length);
      if (mysql_bin_log.is_open())
      {
3461
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3462 3463 3464 3465 3466 3467 3468 3469
	mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
unknown's avatar
unknown committed
3470
    if (check_access(thd, GRANT_ACL ,"mysql",0,1,0))
3471 3472 3473 3474 3475 3476
      break;
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
    {
      mysql_update_log.write(thd, thd->query, thd->query_length);
      if (mysql_bin_log.is_open())
      {
3477
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3478 3479 3480 3481 3482 3483
	mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
3484 3485 3486 3487
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
3488
		     tables ? tables->db : select_lex->db,
3489
		     tables ? &tables->grant.privilege : 0,
3490
		     tables ? 0 : 1, 0))
3491 3492
      goto error;

unknown's avatar
unknown committed
3493 3494 3495 3496
    /*
      Check that the user isn't trying to change a password for another
      user if he doesn't have UPDATE privilege to the MySQL database
    */
3497 3498 3499 3500 3501 3502 3503 3504 3505 3506

    if (thd->user)				// If not replication
    {
      LEX_USER *user;
      List_iterator <LEX_USER> user_list(lex->users_list);
      while ((user=user_list++))
      {
	if (user->password.str &&
	    (strcmp(thd->user,user->user.str) ||
	     user->host.str &&
unknown's avatar
unknown committed
3507
	     my_strcasecmp(&my_charset_latin1,
3508
                           user->host.str, thd->host_or_ip)))
3509
	{
3510 3511 3512
	  if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1))
	  {
	    send_error(thd, ER_PASSWORD_NOT_ALLOWED);
3513
	    goto error;
3514 3515
	  }
	  break;		  // We are allowed to do global changes
3516 3517 3518
	}
      }
    }
unknown's avatar
SCRUM  
unknown committed
3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531
    if (specialflag & SPECIAL_NO_RESOLVE)
    {
      LEX_USER *user;
      List_iterator <LEX_USER> user_list(lex->users_list);
      while ((user=user_list++))
      {
	if (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);
      }
    }
3532 3533 3534 3535 3536
    if (tables)
    {
      if (grant_option && check_grant(thd,
				      (lex->grant | lex->grant_tot_col |
				       GRANT_ACL),
unknown's avatar
unknown committed
3537
				      tables, 0, UINT_MAX, 0))
3538
	goto error;
unknown's avatar
unknown committed
3539 3540 3541
      if (!(res = mysql_table_grant(thd,tables,lex->users_list, lex->columns,
				    lex->grant,
				    lex->sql_command == SQLCOM_REVOKE)))
3542
      {
3543
	mysql_update_log.write(thd, thd->query, thd->query_length);
3544 3545
	if (mysql_bin_log.is_open())
	{
unknown's avatar
unknown committed
3546
          thd->clear_error();
3547
	  Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3548 3549 3550 3551 3552 3553 3554 3555
	  mysql_bin_log.write(&qinfo);
	}
      }
    }
    else
    {
      if (lex->columns.elements)
      {
3556
	send_error(thd,ER_ILLEGAL_GRANT_FOR_TABLE);
3557 3558 3559 3560 3561 3562 3563
	res=1;
      }
      else
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
3564
	mysql_update_log.write(thd, thd->query, thd->query_length);
3565 3566
	if (mysql_bin_log.is_open())
	{
unknown's avatar
unknown committed
3567
          thd->clear_error();
3568
	  Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3569 3570
	  mysql_bin_log.write(&qinfo);
	}
3571
	if (mqh_used && lex->sql_command == SQLCOM_GRANT)
3572
	{
unknown's avatar
unknown committed
3573 3574 3575
	  List_iterator <LEX_USER> str_list(lex->users_list);
	  LEX_USER *user;
	  while ((user=str_list++))
3576
	    reset_mqh(thd,user);
3577
	}
3578 3579 3580 3581
      }
    }
    break;
  }
unknown's avatar
SCRUM  
unknown committed
3582
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
unknown's avatar
unknown committed
3583
  case SQLCOM_RESET:
3584 3585 3586 3587 3588 3589 3590
    /* 
       RESET commands are never written to the binary log, so we have to
       initialize this variable because RESET shares the same code as FLUSH
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
unknown's avatar
unknown committed
3591
    if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, tables))
unknown's avatar
unknown committed
3592
      goto error;
3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610
    /*
      reload_acl_and_cache() will tell us if we are allowed to write to the
      binlog or not.
    */
    bool write_to_binlog;
    if (reload_acl_and_cache(thd, lex->type, tables, &write_to_binlog))
      send_error(thd, 0);
    else
    {
      /*
        We WANT to write and we CAN write.
        ! we write after unlocking the table.
      */
      if (!lex->no_write_to_binlog && write_to_binlog)
      {
        mysql_update_log.write(thd, thd->query, thd->query_length);
        if (mysql_bin_log.is_open())
        {
3611
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3612 3613 3614 3615 3616
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
    }
unknown's avatar
unknown committed
3617
    break;
3618
  }
unknown's avatar
unknown committed
3619 3620 3621
  case SQLCOM_KILL:
    kill_one_thread(thd,lex->thread_id);
    break;
unknown's avatar
unknown committed
3622
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
3623 3624
  case SQLCOM_SHOW_GRANTS:
    res=0;
3625 3626
    if ((thd->priv_user &&
	 !strcmp(thd->priv_user,lex->grant_user->user.str)) ||
unknown's avatar
unknown committed
3627
	!check_access(thd, SELECT_ACL, "mysql",0,1,0))
unknown's avatar
unknown committed
3628 3629 3630 3631
    {
      res = mysql_show_grants(thd,lex->grant_user);
    }
    break;
unknown's avatar
unknown committed
3632
#endif
3633
  case SQLCOM_HA_OPEN:
3634
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
3635
	check_table_access(thd,SELECT_ACL, tables,0))
3636 3637 3638 3639 3640 3641 3642 3643 3644
      goto error;
    res = mysql_ha_open(thd, tables);
    break;
  case SQLCOM_HA_CLOSE:
    if (check_db_used(thd,tables))
      goto error;
    res = mysql_ha_close(thd, tables);
    break;
  case SQLCOM_HA_READ:
3645 3646 3647 3648 3649
    /*
      There is no need to check for table permissions here, because
      if a user has no permissions to read a table, he won't be
      able to open it (with SQLCOM_HA_OPEN) in the first place.
    */
unknown's avatar
unknown committed
3650
    if (check_db_used(thd,tables))
3651
      goto error;
unknown's avatar
unknown committed
3652
    res = mysql_ha_read(thd, tables, lex->ha_read_mode, lex->backup_dir,
3653 3654
			lex->insert_list, lex->ha_rkey_mode, select_lex->where,
			select_lex->select_limit, select_lex->offset_limit);
3655 3656
    break;

unknown's avatar
unknown committed
3657
  case SQLCOM_BEGIN:
unknown's avatar
unknown committed
3658 3659 3660 3661 3662 3663
    if (thd->locked_tables)
    {
      thd->lock=thd->locked_tables;
      thd->locked_tables=0;			// Will be automaticly closed
      close_thread_tables(thd);			// Free tables
    }
unknown's avatar
unknown committed
3664 3665 3666 3667 3668 3669
    if (end_active_trans(thd))
    {
      res= -1;
    }
    else
    {
3670
      thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
unknown's avatar
unknown committed
3671 3672
		     OPTION_BEGIN);
      thd->server_status|= SERVER_STATUS_IN_TRANS;
3673 3674 3675
      if (!(lex->start_transaction_opt & MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT) ||
          !(res= ha_start_consistent_snapshot(thd)))
        send_ok(thd);
unknown's avatar
unknown committed
3676
    }
unknown's avatar
unknown committed
3677 3678
    break;
  case SQLCOM_COMMIT:
3679 3680 3681 3682 3683
    /*
      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...)
    */
unknown's avatar
unknown committed
3684
  {
3685
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
3686 3687
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    if (!ha_commit(thd))
unknown's avatar
unknown committed
3688
    {
3689
      send_ok(thd);
unknown's avatar
unknown committed
3690
    }
unknown's avatar
unknown committed
3691 3692 3693
    else
      res= -1;
    break;
unknown's avatar
unknown committed
3694
  }
unknown's avatar
unknown committed
3695 3696 3697
  case SQLCOM_ROLLBACK:
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    if (!ha_rollback(thd))
3698
    {
unknown's avatar
unknown committed
3699 3700 3701 3702 3703 3704 3705 3706 3707 3708
      /*
        If a non-transactional table was updated, warn; don't warn if this is a
        slave thread (because when a slave thread executes a ROLLBACK, it has
        been read from the binary log, so it's 100% sure and normal to produce
        error ER_WARNING_NOT_COMPLETE_ROLLBACK. If we sent the warning to the
        slave SQL thread, it would not stop the thread but just be printed in
        the error log; but we don't want users to wonder why they have this
        message in the error log, so we don't send it.
      */
      if ((thd->options & OPTION_STATUS_NO_TRANS_UPDATE) && !thd->slave_thread)
3709
	send_warning(thd,ER_WARNING_NOT_COMPLETE_ROLLBACK,0);
3710
      else
3711
	send_ok(thd);
3712
    }
unknown's avatar
unknown committed
3713 3714
    else
      res= -1;
3715
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
3716
    break;
unknown's avatar
unknown committed
3717 3718 3719
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
    if (!ha_rollback_to_savepoint(thd, lex->savepoint_name))
    {
unknown's avatar
unknown committed
3720
      if ((thd->options & OPTION_STATUS_NO_TRANS_UPDATE) && !thd->slave_thread)
unknown's avatar
unknown committed
3721
	send_warning(thd, ER_WARNING_NOT_COMPLETE_ROLLBACK, 0);
unknown's avatar
unknown committed
3722
      else
unknown's avatar
unknown committed
3723
	send_ok(thd);
unknown's avatar
unknown committed
3724 3725 3726 3727
    }
    else
      res= -1;
    break;
3728
  case SQLCOM_SAVEPOINT:
unknown's avatar
unknown committed
3729
    if (!ha_savepoint(thd, lex->savepoint_name))
unknown's avatar
unknown committed
3730
      send_ok(thd);
unknown's avatar
unknown committed
3731 3732
    else
      res= -1;
3733
    break;
unknown's avatar
unknown committed
3734
  default:					/* Impossible */
3735
    send_ok(thd);
unknown's avatar
unknown committed
3736 3737 3738
    break;
  }
  thd->proc_info="query end";			// QQ
3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751

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

unknown's avatar
unknown committed
3752
  if (res < 0)
3753
    send_error(thd,thd->killed ? ER_SERVER_SHUTDOWN : 0);
unknown's avatar
unknown committed
3754 3755

error:
unknown's avatar
unknown committed
3756 3757 3758 3759 3760 3761 3762 3763
  if (unlikely(slave_fake_lock))
  {
    DBUG_PRINT("info",("undoing faked lock"));
    thd->lock= thd->locked_tables;
    thd->locked_tables= fake_prev_lock;
    if (thd->lock == thd->locked_tables)
      thd->lock= 0;
  }
unknown's avatar
unknown committed
3764 3765 3766 3767
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
3768 3769
/*
  Check grants for commands which work only with one table and all other
3770
  tables belonging to subselects or implicitly opened tables.
unknown's avatar
unknown committed
3771

3772
  SYNOPSIS
unknown's avatar
unknown committed
3773 3774 3775 3776
    check_one_table_access()
    thd			Thread handler
    privilege		requested privelage
    tables		table list of command
unknown's avatar
unknown committed
3777 3778 3779

  RETURN
    0 - OK
unknown's avatar
unknown committed
3780
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
3781
*/
unknown's avatar
unknown committed
3782 3783

int check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *tables)
unknown's avatar
unknown committed
3784
{
unknown's avatar
unknown committed
3785 3786
  if (check_access(thd, privilege, tables->db, &tables->grant.privilege,0,0))
    return 1;
unknown's avatar
unknown committed
3787

unknown's avatar
unknown committed
3788
  /* Show only 1 table for check_grant */
unknown's avatar
unknown committed
3789
  if (grant_option && check_grant(thd, privilege, tables, 0, 1, 0))
unknown's avatar
unknown committed
3790
    return 1;
unknown's avatar
unknown committed
3791

3792
  /* Check rights on tables of subselects and implictly opened tables */
unknown's avatar
unknown committed
3793 3794
  TABLE_LIST *subselects_tables;
  if ((subselects_tables= tables->next))
unknown's avatar
unknown committed
3795
  {
unknown's avatar
unknown committed
3796
    if ((check_table_access(thd, SELECT_ACL, subselects_tables,0)))
unknown's avatar
unknown committed
3797 3798 3799
      return 1;
  }
  return 0;
unknown's avatar
unknown committed
3800 3801 3802
}


unknown's avatar
unknown committed
3803
/****************************************************************************
unknown's avatar
unknown committed
3804
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817

  NOTES
    The idea of EXTRA_ACL is that one will be granted access to the table if
    one has the asked privilege on any column combination of the table; For
    example to be able to check a table one needs to have SELECT privilege on
    any column of the table.

  RETURN
    0  ok
    1  If we can't get the privileges and we don't use table/column grants.

    save_priv	In this we store global and db level grants for the table
		Note that we don't store db level grants if the global grants
unknown's avatar
unknown committed
3818 3819
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
3820 3821 3822
****************************************************************************/

bool
unknown's avatar
unknown committed
3823
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
3824
	     bool dont_check_global_grants, bool no_errors)
unknown's avatar
unknown committed
3825
{
unknown's avatar
unknown committed
3826
  DBUG_ENTER("check_access");
3827 3828
  DBUG_PRINT("enter",("db: '%s'  want_access: %lu  master_access: %lu",
                      db ? db : "", want_access, thd->master_access));
unknown's avatar
unknown committed
3829 3830
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
unknown's avatar
unknown committed
3831
  bool  db_is_pattern= test(want_access & GRANT_ACL);
unknown's avatar
unknown committed
3832 3833
#endif
  ulong dummy;
unknown's avatar
unknown committed
3834 3835 3836 3837 3838
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

3839
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
3840
  {
3841
    if (!no_errors)
3842
      send_error(thd,ER_NO_DB_ERROR);	/* purecov: tested */
unknown's avatar
unknown committed
3843
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
3844 3845
  }

unknown's avatar
unknown committed
3846 3847 3848
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
unknown's avatar
unknown committed
3849 3850
  if ((thd->master_access & want_access) == want_access)
  {
3851 3852 3853 3854 3855 3856 3857
    /*
      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
    */
    db_access= thd->db_access;
    if (!(thd->master_access & SELECT_ACL) &&
unknown's avatar
unknown committed
3858
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
unknown's avatar
unknown committed
3859
      db_access=acl_get(thd->host, thd->ip, thd->priv_user, db, db_is_pattern);
3860
    *save_priv=thd->master_access | db_access;
unknown's avatar
unknown committed
3861
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
3862
  }
3863
  if (((want_access & ~thd->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
3864
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
3865
  {						// We can never grant this
3866
    if (!no_errors)
3867
      net_printf(thd,ER_ACCESS_DENIED_ERROR,
3868
		 thd->priv_user,
3869
		 thd->priv_host,
3870
		 thd->password ? ER(ER_YES) : ER(ER_NO));/* purecov: tested */
unknown's avatar
unknown committed
3871
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
3872 3873 3874
  }

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

unknown's avatar
unknown committed
3877
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
unknown's avatar
unknown committed
3878
    db_access=acl_get(thd->host, thd->ip, thd->priv_user, db, db_is_pattern);
unknown's avatar
unknown committed
3879 3880
  else
    db_access=thd->db_access;
3881 3882
  DBUG_PRINT("info",("db_access: %lu", db_access));
  /* Remove SHOW attribute and access rights we already have */
3883
  want_access &= ~(thd->master_access | EXTRA_ACL);
unknown's avatar
unknown committed
3884
  db_access= ((*save_priv=(db_access | thd->master_access)) & want_access);
3885 3886

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
3887
  if (db_access == want_access ||
3888
      ((grant_option && !dont_check_global_grants) &&
3889
       !(want_access & ~(db_access | TABLE_ACLS))))
unknown's avatar
unknown committed
3890
    DBUG_RETURN(FALSE);				/* Ok */
3891
  if (!no_errors)
3892
    net_printf(thd,ER_DBACCESS_DENIED_ERROR,
3893
	       thd->priv_user,
3894
	       thd->priv_host,
3895
	       db ? db : thd->db ? thd->db : "unknown"); /* purecov: tested */
unknown's avatar
unknown committed
3896
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
3897
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
3898 3899 3900
}


3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918
/*
  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
    One gets access rigth if one has ANY of the rights in want_access
    This is useful as one in most cases only need one global right,
    but in some case we want to check if the user has SUPER or
    REPL_CLIENT_ACL rights.

  RETURN
    0	ok
    1	Access denied.  In this case an error is sent to the client
*/
unknown's avatar
unknown committed
3919 3920

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
3921
{
unknown's avatar
unknown committed
3922 3923 3924
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
3925
  char command[128];
3926
  if ((thd->master_access & want_access))
unknown's avatar
unknown committed
3927 3928
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
3929
  net_printf(thd,ER_SPECIFIC_ACCESS_DENIED_ERROR,
unknown's avatar
unknown committed
3930 3931
	     command);
  return 1;
unknown's avatar
unknown committed
3932
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
3933 3934 3935
}


unknown's avatar
unknown committed
3936
/*
unknown's avatar
unknown committed
3937 3938
  Check the privilege for all used tables.  Table privileges are cached
  in the table list for GRANT checking
unknown's avatar
unknown committed
3939 3940
*/

3941
bool
unknown's avatar
unknown committed
3942
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
3943
		   bool no_errors)
unknown's avatar
unknown committed
3944
{
unknown's avatar
unknown committed
3945 3946
  uint found=0;
  ulong found_access=0;
unknown's avatar
unknown committed
3947 3948 3949
  TABLE_LIST *org_tables=tables;
  for (; tables ; tables=tables->next)
  {
3950 3951 3952 3953
    if (tables->derived ||
        (tables->table && (int)tables->table->tmp_table) ||
        my_tz_check_n_skip_implicit_tables(&tables,
                                           thd->lex->time_zone_tables_used))
unknown's avatar
unknown committed
3954
      continue;
unknown's avatar
unknown committed
3955 3956
    if ((thd->master_access & want_access) == (want_access & ~EXTRA_ACL) &&
	thd->db)
unknown's avatar
unknown committed
3957
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
3958
    else if (tables->db && tables->db == thd->db)
unknown's avatar
unknown committed
3959 3960 3961 3962 3963
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
3964 3965
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
			 0, no_errors))
unknown's avatar
unknown committed
3966 3967
	  return TRUE;				// Access denied
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
3968
	found=1;
unknown's avatar
unknown committed
3969 3970
      }
    }
3971
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
3972
			  0, no_errors))
3973
      return TRUE;
unknown's avatar
unknown committed
3974 3975
  }
  if (grant_option)
3976
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
unknown's avatar
unknown committed
3977
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
unknown's avatar
unknown committed
3978 3979 3980
  return FALSE;
}

3981 3982
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
3983 3984 3985 3986
{
  int error=0;
  if (table_list)
  {
3987
    /* Check that all tables use the current database */
3988 3989
    TABLE_LIST *tmp;
    for (tmp=table_list; tmp ; tmp=tmp->next)
3990 3991 3992 3993
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
3994
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
unknown's avatar
unknown committed
3995
			     table_list,0);
3996 3997 3998 3999
  }
  return error;
}

unknown's avatar
unknown committed
4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
  for (; tables ; tables=tables->next)
  {
    if (!tables->db)
    {
      if (!(tables->db=thd->db))
      {
	send_error(thd,ER_NO_DB_ERROR);	/* purecov: tested */
	return TRUE;				/* purecov: tested */
      }
    }
  }
  return FALSE;
}
4016

unknown's avatar
unknown committed
4017 4018 4019 4020 4021 4022 4023 4024 4025 4026
/****************************************************************************
	Check stack size; Send error if there isn't enough stack to continue
****************************************************************************/

#if STACK_DIRECTION < 0
#define used_stack(A,B) (long) (A - B)
#else
#define used_stack(A,B) (long) (B - A)
#endif

unknown's avatar
unknown committed
4027 4028 4029 4030
#ifndef DBUG_OFF
long max_stack_used;
#endif

4031
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
4032 4033 4034 4035 4036 4037 4038 4039
bool check_stack_overrun(THD *thd,char *buf __attribute__((unused)))
{
  long stack_used;
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
      (long) thread_stack_min)
  {
    sprintf(errbuff[0],ER(ER_STACK_OVERRUN),stack_used,thread_stack);
    my_message(ER_STACK_OVERRUN,errbuff[0],MYF(0));
4040
    thd->fatal_error();
unknown's avatar
unknown committed
4041 4042
    return 1;
  }
unknown's avatar
unknown committed
4043 4044 4045
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
unknown's avatar
unknown committed
4046 4047
  return 0;
}
4048
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
4049 4050 4051 4052

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

4053
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
unknown's avatar
unknown committed
4054 4055
{
  LEX	*lex=current_lex;
4056
  ulong old_info=0;
unknown's avatar
unknown committed
4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081
  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;
}

/****************************************************************************
4082
  Initialize global thd variables needed for query
unknown's avatar
unknown committed
4083 4084
****************************************************************************/

4085
void
unknown's avatar
unknown committed
4086
mysql_init_query(THD *thd, uchar *buf, uint length)
unknown's avatar
unknown committed
4087 4088
{
  DBUG_ENTER("mysql_init_query");
unknown's avatar
unknown committed
4089
  lex_start(thd, buf, length);
4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110
  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");
4111
  thd->free_list= 0;
4112 4113
  thd->select_number= 1;
  thd->total_warn_count= 0;                     // Warnings for this query
unknown's avatar
unknown committed
4114 4115
  thd->last_insert_id_used= thd->query_start_used= thd->insert_id_used=0;
  thd->sent_row_count= thd->examined_row_count= 0;
4116
  thd->is_fatal_error= thd->rand_used= thd->time_zone_used= 0;
unknown's avatar
unknown committed
4117 4118 4119
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
			  SERVER_QUERY_NO_INDEX_USED |
			  SERVER_QUERY_NO_GOOD_INDEX_USED);
unknown's avatar
unknown committed
4120
  thd->tmp_table_used= 0;
unknown's avatar
unknown committed
4121 4122
  if (opt_bin_log)
    reset_dynamic(&thd->user_var_events);
4123
  thd->clear_error();
unknown's avatar
unknown committed
4124 4125 4126
  DBUG_VOID_RETURN;
}

4127

4128 4129 4130
void
mysql_init_select(LEX *lex)
{
unknown's avatar
unknown committed
4131
  SELECT_LEX *select_lex= lex->current_select;
unknown's avatar
unknown committed
4132
  select_lex->init_select();
4133
  select_lex->select_limit= HA_POS_ERROR;
4134 4135
  if (select_lex == &lex->select_lex)
  {
4136
    DBUG_ASSERT(lex->result == 0);
4137 4138
    lex->exchange= 0;
  }
4139 4140
}

4141

unknown's avatar
unknown committed
4142
bool
unknown's avatar
unknown committed
4143
mysql_new_select(LEX *lex, bool move_down)
4144
{
unknown's avatar
unknown committed
4145 4146
  SELECT_LEX *select_lex;
  if (!(select_lex= new(lex->thd->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
4147
    return 1;
4148
  select_lex->select_number= ++lex->thd->select_number;
unknown's avatar
unknown committed
4149 4150
  select_lex->init_query();
  select_lex->init_select();
4151 4152 4153 4154 4155 4156 4157 4158
  /*
    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.
  */
  if (lex->thd->current_arena->is_stmt_prepare())
    select_lex->uncacheable|= UNCACHEABLE_PREPARE;

unknown's avatar
unknown committed
4159 4160
  if (move_down)
  {
4161
    lex->subqueries= TRUE;
unknown's avatar
unknown committed
4162
    /* first select_lex of subselect or derived table */
unknown's avatar
unknown committed
4163 4164
    SELECT_LEX_UNIT *unit;
    if (!(unit= new(lex->thd->mem_root) SELECT_LEX_UNIT()))
unknown's avatar
unknown committed
4165
      return 1;
unknown's avatar
unknown committed
4166

unknown's avatar
unknown committed
4167 4168
    unit->init_query();
    unit->init_select();
4169
    unit->thd= lex->thd;
unknown's avatar
unknown committed
4170
    unit->include_down(lex->current_select);
unknown's avatar
unknown committed
4171 4172
    unit->link_next= 0;
    unit->link_prev= 0;
4173
    unit->return_to= lex->current_select;
unknown's avatar
unknown committed
4174
    select_lex->include_down(unit);
4175
    // TODO: assign resolve_mode for fake subquery after merging with new tree
unknown's avatar
unknown committed
4176 4177
  }
  else
unknown's avatar
unknown committed
4178
  {
4179
    select_lex->include_neighbour(lex->current_select);
unknown's avatar
unknown committed
4180 4181 4182 4183 4184 4185 4186 4187
    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
      */
unknown's avatar
unknown committed
4188 4189
      if (!(fake= unit->fake_select_lex= new(lex->thd->mem_root) SELECT_LEX()))
        return 1;
unknown's avatar
unknown committed
4190 4191 4192 4193 4194
      fake->include_standalone(unit,
			       (SELECT_LEX_NODE**)&unit->fake_select_lex);
      fake->select_number= INT_MAX;
      fake->make_empty_select();
      fake->linkage= GLOBAL_OPTIONS_TYPE;
4195
      fake->select_limit= HA_POS_ERROR;
unknown's avatar
unknown committed
4196 4197
    }
  }
unknown's avatar
unknown committed
4198

4199
  select_lex->master_unit()->global_parameters= select_lex;
4200
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
4201
  lex->current_select= select_lex;
4202
  select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
unknown's avatar
unknown committed
4203
  return 0;
4204
}
unknown's avatar
unknown committed
4205

4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220
/*
  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)
{
4221
  THD *thd;
4222
  LEX *lex;
4223
  LEX_STRING tmp, null_lex_string;
4224 4225
  Item *var;
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
4226
  DBUG_ENTER("create_select_for_variable");
4227 4228

  thd= current_thd;
4229
  lex= thd->lex;
4230 4231 4232 4233
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
4234
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
4235 4236 4237 4238
  /*
    We set the name of Item to @@session.var_name because that then is used
    as the column name in the output.
  */
unknown's avatar
unknown committed
4239 4240 4241 4242 4243 4244
  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);
  }
4245 4246 4247
  DBUG_VOID_RETURN;
}

4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281
static TABLE_LIST* get_table_by_alias(TABLE_LIST* tl, const char* db,
  const char* alias)
{
  for (;tl;tl= tl->next)
  {
    if (!strcmp(db,tl->db) &&
        tl->alias && !my_strcasecmp(table_alias_charset,tl->alias,alias))
      return tl;
  }
  
  return 0;
}     

/* Sets up lex->auxilliary_table_list */
void fix_multi_delete_lex(LEX* lex)
{
  TABLE_LIST *tl;
  TABLE_LIST *good_list= (TABLE_LIST*)lex->select_lex.table_list.first;
  
  for (tl= (TABLE_LIST*)lex->auxilliary_table_list.first; tl; tl= tl->next)
  {
    TABLE_LIST* good_table= get_table_by_alias(good_list,tl->db,tl->alias);
    if (good_table && !good_table->derived)
    {
      /* 
          real_name points to a member of Table_ident which is
          allocated via thd->strmake() from THD memroot 
       */
      tl->real_name= good_table->real_name;
      tl->real_name_length= good_table->real_name_length;
      good_table->updating= tl->updating;
    }
  }
}  
4282

unknown's avatar
unknown committed
4283 4284
void mysql_init_multi_delete(LEX *lex)
{
unknown's avatar
unknown committed
4285
  lex->sql_command=  SQLCOM_DELETE_MULTI;
unknown's avatar
unknown committed
4286
  mysql_init_select(lex);
4287
  lex->select_lex.select_limit= lex->unit.select_limit_cnt=
unknown's avatar
unknown committed
4288
    HA_POS_ERROR;
unknown's avatar
unknown committed
4289
  lex->select_lex.table_list.save_and_clear(&lex->auxilliary_table_list);
4290
  lex->lock_option= using_update_log ? TL_READ_NO_INSERT : TL_READ;
unknown's avatar
unknown committed
4291
}
unknown's avatar
unknown committed
4292

4293

4294 4295 4296 4297
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
4298

4299
void mysql_parse(THD *thd, char *inBuf, uint length)
unknown's avatar
unknown committed
4300 4301 4302
{
  DBUG_ENTER("mysql_parse");

unknown's avatar
unknown committed
4303
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
4304
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
unknown's avatar
unknown committed
4305
  {
unknown's avatar
unknown committed
4306
    LEX *lex= thd->lex;
4307
    if (!yyparse((void *)thd) && ! thd->is_fatal_error)
unknown's avatar
unknown committed
4308
    {
unknown's avatar
unknown committed
4309
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4310
      if (mqh_used && thd->user_connect &&
4311
	  check_mqh(thd, lex->sql_command))
4312 4313 4314 4315
      {
	thd->net.error = 0;
      }
      else
unknown's avatar
unknown committed
4316
#endif
4317
      {
unknown's avatar
unknown committed
4318 4319 4320 4321
	if (thd->net.report_error)
	  send_error(thd, 0, NullS);
	else
	{
4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335
          /*
            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.
          */
          if (lex->found_colon &&
              (thd->query_length= (ulong)(lex->found_colon - thd->query)))
            thd->query_length--;
          /* Actually execute the query */
unknown's avatar
unknown committed
4336
	  mysql_execute_command(thd);
unknown's avatar
SCRUM  
unknown committed
4337
	  query_cache_end_of_result(thd);
unknown's avatar
unknown committed
4338
	}
4339
      }
unknown's avatar
unknown committed
4340 4341
    }
    else
4342 4343
    {
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
4344
			 thd->is_fatal_error));
unknown's avatar
unknown committed
4345
      query_cache_abort(&thd->net);
4346
    }
unknown's avatar
unknown committed
4347
    thd->proc_info="freeing items";
4348
    thd->end_statement();
4349
    DBUG_ASSERT(thd->change_list.is_empty());
unknown's avatar
unknown committed
4350
  }
unknown's avatar
unknown committed
4351 4352 4353 4354
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
4355
#ifdef HAVE_REPLICATION
4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366
/*
  Usable by the replication SQL thread only: just parse a query to know if it
  can be ignored because of replicate-*-table rules.

  RETURN VALUES
    0	cannot be ignored
    1	can be ignored
*/

bool mysql_test_parse_for_slave(THD *thd, char *inBuf, uint length)
{
unknown's avatar
unknown committed
4367
  LEX *lex= thd->lex;
4368 4369
  bool error= 0;

unknown's avatar
unknown committed
4370
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
4371
  if (!yyparse((void*) thd) && ! thd->is_fatal_error &&
4372 4373
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
    error= 1;                /* Ignore question */
4374
  thd->end_statement();
4375 4376
  return error;
}
unknown's avatar
unknown committed
4377
#endif
unknown's avatar
unknown committed
4378

4379

unknown's avatar
unknown committed
4380 4381 4382 4383 4384
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

unknown's avatar
unknown committed
4385
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
unknown's avatar
unknown committed
4386
		       char *length, char *decimals,
4387
		       uint type_modifier,
4388 4389
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
4390 4391
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
unknown's avatar
unknown committed
4392
		       uint uint_geom_type)
unknown's avatar
unknown committed
4393 4394
{
  register create_field *new_field;
4395
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
4396
  uint allowed_type_modifier=0;
4397
  char warn_buff[MYSQL_ERRMSG_SIZE];
unknown's avatar
unknown committed
4398 4399 4400 4401
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
4402
    net_printf(thd, ER_TOO_LONG_IDENT, field_name); /* purecov: inspected */
unknown's avatar
unknown committed
4403 4404 4405 4406 4407
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
4408
    lex->key_list.push_back(new Key(Key::PRIMARY, NullS, HA_KEY_ALG_UNDEF,
4409
				    0, lex->col_list));
unknown's avatar
unknown committed
4410 4411 4412 4413 4414
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
4415
    lex->key_list.push_back(new Key(Key::UNIQUE, NullS, HA_KEY_ALG_UNDEF, 0,
unknown's avatar
unknown committed
4416 4417 4418 4419
				    lex->col_list));
    lex->col_list.empty();
  }

4420
  if (default_value)
unknown's avatar
unknown committed
4421
  {
4422
    /* 
unknown's avatar
unknown committed
4423 4424
      Default value should be literal => basic constants =>
      no need fix_fields()
4425 4426 4427
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
4428
    */
4429 4430 4431 4432 4433 4434 4435 4436
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
    {
      net_printf(thd, ER_INVALID_DEFAULT, field_name);
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
unknown's avatar
unknown committed
4437
    {
4438
      default_value= 0;
4439 4440 4441
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
unknown's avatar
unknown committed
4442
	net_printf(thd,ER_INVALID_DEFAULT,field_name);
4443 4444 4445 4446 4447
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
unknown's avatar
unknown committed
4448
      net_printf(thd, ER_INVALID_DEFAULT, field_name);
unknown's avatar
unknown committed
4449 4450 4451
      DBUG_RETURN(1);
    }
  }
4452 4453 4454 4455 4456 4457 4458

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
    net_printf(thd, ER_INVALID_ON_UPDATE, field_name);
    DBUG_RETURN(1);
  }
    
unknown's avatar
unknown committed
4459 4460 4461 4462
  if (!(new_field=new create_field()))
    DBUG_RETURN(1);
  new_field->field=0;
  new_field->field_name=field_name;
4463
  new_field->def= default_value;
unknown's avatar
unknown committed
4464 4465 4466 4467 4468 4469 4470 4471 4472 4473
  new_field->flags= type_modifier;
  new_field->unireg_check= (type_modifier & AUTO_INCREMENT_FLAG ?
			    Field::NEXT_NUMBER : Field::NONE);
  new_field->decimals= decimals ? (uint) set_zone(atoi(decimals),0,
						  NOT_FIXED_DEC-1) : 0;
  new_field->sql_type=type;
  new_field->length=0;
  new_field->change=change;
  new_field->interval=0;
  new_field->pack_length=0;
4474
  new_field->charset=cs;
unknown's avatar
unknown committed
4475
  new_field->geom_type= (Field::geometry_type) uint_geom_type;
unknown's avatar
unknown committed
4476

4477 4478 4479 4480 4481 4482 4483 4484
  if (!comment)
  {
    new_field->comment.str=0;
    new_field->comment.length=0;
  }
  else
  {
    /* In this case comment is always of type Item_string */
unknown's avatar
unknown committed
4485 4486
    new_field->comment.str=   (char*) comment->str;
    new_field->comment.length=comment->length;
4487
  }
4488 4489
  if (length && !(new_field->length= (uint) atoi(length)))
    length=0; /* purecov: inspected */
unknown's avatar
unknown committed
4490 4491 4492
  uint sign_len=type_modifier & UNSIGNED_FLAG ? 0 : 1;

  if (new_field->length && new_field->decimals &&
4493
      new_field->length < new_field->decimals+1 &&
unknown's avatar
unknown committed
4494
      new_field->decimals != NOT_FIXED_DEC)
4495
    new_field->length=new_field->decimals+1; /* purecov: inspected */
unknown's avatar
unknown committed
4496 4497 4498

  switch (type) {
  case FIELD_TYPE_TINY:
4499
    if (!length) new_field->length=MAX_TINYINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4500 4501 4502
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_SHORT:
4503
    if (!length) new_field->length=MAX_SMALLINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4504 4505 4506
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_INT24:
4507
    if (!length) new_field->length=MAX_MEDIUMINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4508 4509 4510
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONG:
4511
    if (!length) new_field->length=MAX_INT_WIDTH+sign_len;
unknown's avatar
unknown committed
4512 4513 4514
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONGLONG:
4515
    if (!length) new_field->length=MAX_BIGINT_WIDTH;
unknown's avatar
unknown committed
4516 4517 4518 4519 4520 4521
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_NULL:
    break;
  case FIELD_TYPE_DECIMAL:
    if (!length)
unknown's avatar
unknown committed
4522 4523
    {
      if ((new_field->length= new_field->decimals))
4524 4525
        new_field->length++;
      else
unknown's avatar
unknown committed
4526 4527
        new_field->length= 10;                  // Default length for DECIMAL
    }
4528 4529 4530 4531 4532 4533
    if (new_field->length < MAX_FIELD_WIDTH)	// Skip wrong argument
    {
      new_field->length+=sign_len;
      if (new_field->decimals)
	new_field->length++;
    }
unknown's avatar
unknown committed
4534
    break;
4535 4536
  case FIELD_TYPE_STRING:
  case FIELD_TYPE_VAR_STRING:
4537
    if (new_field->length <= MAX_FIELD_CHARLENGTH || default_value)
4538 4539 4540 4541
      break;
    /* Convert long CHAR() and VARCHAR columns to TEXT or BLOB */
    new_field->sql_type= FIELD_TYPE_BLOB;
    sprintf(warn_buff, ER(ER_AUTO_CONVERT), field_name, "CHAR",
unknown's avatar
unknown committed
4542
	    (cs == &my_charset_bin) ? "BLOB" : "TEXT");
4543 4544 4545
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_AUTO_CONVERT,
		 warn_buff);
    /* fall through */
unknown's avatar
unknown committed
4546 4547 4548 4549
  case FIELD_TYPE_BLOB:
  case FIELD_TYPE_TINY_BLOB:
  case FIELD_TYPE_LONG_BLOB:
  case FIELD_TYPE_MEDIUM_BLOB:
unknown's avatar
unknown committed
4550
  case FIELD_TYPE_GEOMETRY:
4551 4552 4553 4554 4555
    if (new_field->length)
    {
      /* The user has given a length to the blob column */
      if (new_field->length < 256)
	type= FIELD_TYPE_TINY_BLOB;
4556
      else if (new_field->length < 65536)
4557 4558 4559 4560 4561 4562 4563 4564
	type= FIELD_TYPE_BLOB;
      else if (new_field->length < 256L*256L*256L)
	type= FIELD_TYPE_MEDIUM_BLOB;
      else
	type= FIELD_TYPE_LONG_BLOB;
      new_field->length= 0;
    }
    new_field->sql_type= type;
unknown's avatar
unknown committed
4565 4566 4567 4568 4569 4570
    if (default_value)				// Allow empty as default value
    {
      String str,*res;
      res=default_value->val_str(&str);
      if (res->length())
      {
4571
	net_printf(thd,ER_BLOB_CANT_HAVE_DEFAULT,field_name); /* purecov: inspected */
unknown's avatar
unknown committed
4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590
	DBUG_RETURN(1); /* purecov: inspected */
      }
      new_field->def=0;
    }
    new_field->flags|=BLOB_FLAG;
    break;
  case FIELD_TYPE_YEAR:
    if (!length || new_field->length != 2)
      new_field->length=4;			// Default length
    new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
    break;
  case FIELD_TYPE_FLOAT:
    /* change FLOAT(precision) to FLOAT or DOUBLE */
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    if (length && !decimals)
    {
      uint tmp_length=new_field->length;
      if (tmp_length > PRECISION_FOR_DOUBLE)
      {
4591
	net_printf(thd,ER_WRONG_FIELD_SPEC,field_name);
unknown's avatar
unknown committed
4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620
	DBUG_RETURN(1);
      }
      else if (tmp_length > PRECISION_FOR_FLOAT)
      {
	new_field->sql_type=FIELD_TYPE_DOUBLE;
	new_field->length=DBL_DIG+7;			// -[digits].E+###
      }
      else
	new_field->length=FLT_DIG+6;			// -[digits].E+##
      new_field->decimals= NOT_FIXED_DEC;
      break;
    }
    if (!length)
    {
      new_field->length =  FLT_DIG+6;
      new_field->decimals= NOT_FIXED_DEC;
    }
    break;
  case FIELD_TYPE_DOUBLE:
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    if (!length)
    {
      new_field->length = DBL_DIG+7;
      new_field->decimals=NOT_FIXED_DEC;
    }
    break;
  case FIELD_TYPE_TIMESTAMP:
    if (!length)
      new_field->length= 14;			// Full date YYYYMMDDHHMMSS
4621
    else if (new_field->length != 19)
unknown's avatar
unknown committed
4622
    {
4623 4624 4625 4626
      /*
        We support only even TIMESTAMP lengths less or equal than 14
        and 19 as length of 4.1 compatible representation.
      */
unknown's avatar
unknown committed
4627 4628 4629
      new_field->length=((new_field->length+1)/2)*2; /* purecov: inspected */
      new_field->length= min(new_field->length,14); /* purecov: inspected */
    }
4630
    new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650
    if (default_value)
    {
      /* Grammar allows only NOW() value for ON UPDATE clause */
      if (default_value->type() == Item::FUNC_ITEM && 
          ((Item_func*)default_value)->functype() == Item_func::NOW_FUNC)
      {
        new_field->unireg_check= (on_update_value?Field::TIMESTAMP_DNUN_FIELD:
                                                  Field::TIMESTAMP_DN_FIELD);
        /*
          We don't need default value any longer moreover it is dangerous.
          Everything handled by unireg_check further.
        */
        new_field->def= 0;
      }
      else
        new_field->unireg_check= (on_update_value?Field::TIMESTAMP_UN_FIELD:
                                                  Field::NONE);
    }
    else
    {
4651 4652 4653 4654 4655 4656 4657 4658
      /*
        If we have default TIMESTAMP NOT NULL column without explicit DEFAULT
        or ON UPDATE values then for the sake of compatiblity we should treat
        this column as having DEFAULT NOW() ON UPDATE NOW() (when we don't
        have another TIMESTAMP column with auto-set option before this one)
        or DEFAULT 0 (in other cases).
        So here we are setting TIMESTAMP_OLD_FIELD only temporary, and will
        replace this value by TIMESTAMP_DNUN_FIELD or NONE later when
4659
        information about all TIMESTAMP fields in table will be availiable.
4660 4661 4662

        If we have TIMESTAMP NULL column without explicit DEFAULT value
        we treat it as having DEFAULT NULL attribute.
4663
      */
4664 4665 4666 4667 4668
      new_field->unireg_check= on_update_value ?
                               Field::TIMESTAMP_UN_FIELD :
                               (new_field->flags & NOT_NULL_FLAG ?
                                Field::TIMESTAMP_OLD_FIELD:
                                Field::NONE);
4669
    }
unknown's avatar
unknown committed
4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685
    break;
  case FIELD_TYPE_DATE:				// Old date type
    if (protocol_version != PROTOCOL_VERSION-1)
      new_field->sql_type=FIELD_TYPE_NEWDATE;
    /* fall trough */
  case FIELD_TYPE_NEWDATE:
    new_field->length=10;
    break;
  case FIELD_TYPE_TIME:
    new_field->length=10;
    break;
  case FIELD_TYPE_DATETIME:
    new_field->length=19;
    break;
  case FIELD_TYPE_SET:
    {
4686
      if (interval_list->elements > sizeof(longlong)*8)
unknown's avatar
unknown committed
4687
      {
4688 4689
        net_printf(thd,ER_TOO_BIG_SET,field_name); /* purecov: inspected */
        DBUG_RETURN(1);				/* purecov: inspected */
unknown's avatar
unknown committed
4690
      }
4691
      new_field->pack_length= get_set_pack_length(interval_list->elements);
4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702

      List_iterator<String> it(*interval_list);
      String *tmp;
      while ((tmp= it++))
        new_field->interval_list.push_back(tmp);
      /*
        Set fake length to 1 to pass the below conditions.
        Real length will be set in mysql_prepare_table()
        when we know the character set of the column
      */
      new_field->length= 1;
unknown's avatar
unknown committed
4703 4704 4705 4706
    }
    break;
  case FIELD_TYPE_ENUM:
    {
4707
      // Should be safe
4708
      new_field->pack_length= get_enum_pack_length(interval_list->elements);
4709 4710 4711 4712 4713 4714

      List_iterator<String> it(*interval_list);
      String *tmp;
      while ((tmp= it++))
        new_field->interval_list.push_back(tmp);
      new_field->length= 1; // See comment for FIELD_TYPE_SET above.
unknown's avatar
unknown committed
4715
    }
4716
    break;
unknown's avatar
unknown committed
4717 4718
  }

4719 4720
  if ((new_field->length > MAX_FIELD_CHARLENGTH && type != FIELD_TYPE_SET && 
       type != FIELD_TYPE_ENUM) ||
unknown's avatar
unknown committed
4721
      (!new_field->length && !(new_field->flags & BLOB_FLAG) &&
4722
       type != FIELD_TYPE_STRING &&
unknown's avatar
SCRUM  
unknown committed
4723
       type != FIELD_TYPE_VAR_STRING && type != FIELD_TYPE_GEOMETRY))
unknown's avatar
unknown committed
4724
  {
4725
    net_printf(thd,ER_TOO_BIG_FIELDLENGTH,field_name,
4726
	       MAX_FIELD_CHARLENGTH);		/* purecov: inspected */
unknown's avatar
unknown committed
4727 4728 4729 4730 4731
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  type_modifier&= AUTO_INCREMENT_FLAG;
  if ((~allowed_type_modifier) & type_modifier)
  {
4732
    net_printf(thd,ER_WRONG_FIELD_SPEC,field_name);
unknown's avatar
unknown committed
4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753
    DBUG_RETURN(1);
  }
  if (!new_field->pack_length)
    new_field->pack_length=calc_pack_length(new_field->sql_type ==
					    FIELD_TYPE_VAR_STRING ?
					    FIELD_TYPE_STRING :
					    new_field->sql_type,
					    new_field->length);
  lex->create_list.push_back(new_field);
  lex->last_field=new_field;
  DBUG_RETURN(0);
}

/* 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
unknown's avatar
unknown committed
4754
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
4755 4756 4757 4758
{
  ORDER *order;
  Item	**item_ptr;

unknown's avatar
unknown committed
4759
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
unknown's avatar
unknown committed
4760 4761 4762 4763 4764
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
4765
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
4766 4767 4768 4769 4770 4771 4772 4773
  return 0;
}


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

static void remove_escape(char *name)
{
4774 4775
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
4776 4777
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
4778
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
4779 4780 4781 4782 4783 4784
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
/*    if ((l = ismbchar(name, name+MBMAXLEN))) { Wei He: I think it's wrong */
4785 4786
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
unknown's avatar
unknown committed
4787 4788 4789 4790 4791 4792 4793 4794
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
4795
      name++;					// Skip '\\'
unknown's avatar
unknown committed
4796 4797 4798 4799 4800 4801 4802 4803 4804 4805
    *to++= *name;
  }
  *to=0;
}

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


unknown's avatar
unknown committed
4806
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
unknown's avatar
unknown committed
4807 4808 4809
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
unknown's avatar
unknown committed
4810
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
unknown's avatar
unknown committed
4811
    DBUG_RETURN(1);
unknown's avatar
unknown committed
4812 4813
  order->item_ptr= item;
  order->item= &order->item_ptr;
unknown's avatar
unknown committed
4814 4815 4816
  order->asc = asc;
  order->free_me=0;
  order->used=0;
unknown's avatar
unknown committed
4817
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
4818 4819 4820 4821
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840
/*
  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
*/

unknown's avatar
unknown committed
4841 4842
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
4843
					     LEX_STRING *alias,
unknown's avatar
unknown committed
4844 4845
					     ulong table_options,
					     thr_lock_type lock_type,
4846 4847
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
unknown's avatar
unknown committed
4848
                                             LEX_STRING *option)
unknown's avatar
unknown committed
4849 4850 4851 4852 4853 4854 4855 4856
{
  register TABLE_LIST *ptr;
  char *alias_str;
  DBUG_ENTER("add_table_to_list");

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
unknown's avatar
unknown committed
4857
  if (check_table_name(table->table.str,table->table.length) ||
4858
      table->db.str && check_db_name(table->db.str))
unknown's avatar
unknown committed
4859
  {
4860
    net_printf(thd, ER_WRONG_TABLE_NAME, table->table.str);
unknown's avatar
unknown committed
4861 4862 4863 4864
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
4865 4866 4867 4868 4869 4870
  {
    if (table->sel)
    {
      net_printf(thd,ER_DERIVED_MUST_HAVE_ALIAS);
      DBUG_RETURN(0);
    }
4871
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
4872
      DBUG_RETURN(0);
4873
  }
unknown's avatar
unknown committed
4874
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
4875
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
4876
  if (table->db.str)
4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887
  {
    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
  {
4888 4889
    /* The following can't be "" as we may do 'casedn_str()' on it */
    ptr->db= empty_c_string;
4890 4891
    ptr->db_length= 0;
  }
4892 4893
  if (thd->current_arena->is_stmt_prepare())
    ptr->db= thd->strdup(ptr->db);
unknown's avatar
unknown committed
4894

4895
  ptr->alias= alias_str;
4896 4897
  if (lower_case_table_names && table->table.length)
    my_casedn_str(files_charset_info, table->table.str);
unknown's avatar
unknown committed
4898
  ptr->real_name=table->table.str;
4899
  ptr->real_name_length=table->table.length;
4900
  ptr->lock_type=   lock_type;
unknown's avatar
unknown committed
4901 4902
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
4903
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
4904
  ptr->derived=	    table->sel;
unknown's avatar
unknown committed
4905
  ptr->cacheable_table= 1;
4906 4907 4908 4909 4910 4911
  if (use_index_arg)
    ptr->use_index=(List<String> *) thd->memdup((gptr) use_index_arg,
						sizeof(*use_index_arg));
  if (ignore_index_arg)
    ptr->ignore_index=(List<String> *) thd->memdup((gptr) ignore_index_arg,
						   sizeof(*ignore_index_arg));
unknown's avatar
unknown committed
4912
  ptr->option= option ? option->str : 0;
unknown's avatar
unknown committed
4913
  /* check that used name is unique */
4914
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
4915
  {
4916
    for (TABLE_LIST *tables=(TABLE_LIST*) table_list.first ;
unknown's avatar
unknown committed
4917
	 tables ;
unknown's avatar
unknown committed
4918
	 tables=tables->next)
unknown's avatar
unknown committed
4919
    {
4920 4921
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
4922
      {
4923
	net_printf(thd,ER_NONUNIQ_TABLE,alias_str); /* purecov: tested */
unknown's avatar
unknown committed
4924 4925
	DBUG_RETURN(0);				/* purecov: tested */
      }
unknown's avatar
unknown committed
4926 4927
    }
  }
unknown's avatar
unknown committed
4928
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next);
unknown's avatar
unknown committed
4929 4930 4931
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
4932

unknown's avatar
unknown committed
4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945
/*
  Set lock for all tables in current select level

  SYNOPSIS:
    set_lock_for_tables()
    lock_type			Lock to set for tables

  NOTE:
    If lock is a write lock, then tables->updating is set 1
    This is to get tables_ok to know that the table is updated by the
    query
*/

unknown's avatar
unknown committed
4946
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
unknown's avatar
unknown committed
4947 4948 4949 4950 4951 4952
{
  bool for_update= lock_type >= TL_READ_NO_INSERT;
  DBUG_ENTER("set_lock_for_tables");
  DBUG_PRINT("enter", ("lock_type: %d  for_update: %d", lock_type,
		       for_update));

unknown's avatar
unknown committed
4953
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first ;
unknown's avatar
unknown committed
4954 4955 4956 4957 4958 4959 4960 4961 4962
       tables ;
       tables=tables->next)
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
4963

unknown's avatar
unknown committed
4964 4965
void add_join_on(TABLE_LIST *b,Item *expr)
{
4966
  if (expr)
4967
  {
4968 4969 4970 4971 4972 4973 4974 4975
    if (!b->on_expr)
      b->on_expr=expr;
    else
    {
      // This only happens if you have both a right and left join
      b->on_expr=new Item_cond_and(b->on_expr,expr);
    }
    b->on_expr->top_level_item();
4976
  }
unknown's avatar
unknown committed
4977 4978 4979
}


4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997
/*
  Mark that we have a NATURAL JOIN between two tables

  SYNOPSIS
    add_join_natural()
    a			Table to do normal join with
    b			Do normal join with this table
  
  IMPLEMENTATION
    This function just marks that table b should be joined with a.
    The function setup_cond() will create in b->on_expr a list
    of equal condition between all fields of the same name.

    SELECT * FROM t1 NATURAL LEFT JOIN t2
     <=>
    SELECT * FROM t1 LEFT JOIN t2 ON (t1.i=t2.i and t1.j=t2.j ... )
*/

unknown's avatar
unknown committed
4998 4999 5000 5001 5002
void add_join_natural(TABLE_LIST *a,TABLE_LIST *b)
{
  b->natural_join=a;
}

5003
/*
5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
    thd			Thread handler
    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
                        pointer where, if it is not NULL, reload_acl_and_cache()
                        will put 0 if it thinks we really should not write to
                        the binlog. Otherwise it will put 1.

  RETURN
    0	 ok
    !=0  error
5021 5022
*/

5023 5024
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
unknown's avatar
unknown committed
5025 5026 5027
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
5028
  bool tmp_write_to_binlog= 1;
unknown's avatar
SCRUM  
unknown committed
5029
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
5030 5031
  if (options & REFRESH_GRANT)
  {
5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052
    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)))
      thd->store_globals();
    if (thd)
    {
      (void)acl_reload(thd);
      (void)grant_reload(thd);
      if (mqh_used)
        reset_mqh(thd, (LEX_USER *) NULL, TRUE);
    }
    if (tmp_thd)
    {
      delete tmp_thd;
      /* Remember that we don't have a THD */
      my_pthread_setspecific_ptr(THR_THD,  0);
      thd= 0;
    }
unknown's avatar
unknown committed
5053
  }
unknown's avatar
SCRUM  
unknown committed
5054
#endif
unknown's avatar
unknown committed
5055 5056
  if (options & REFRESH_LOG)
  {
5057
    /*
unknown's avatar
unknown committed
5058 5059
      Flush the normal query log, the update log, the binary log,
      the slow query log, and the relay log (if it exists).
5060
    */
unknown's avatar
unknown committed
5061

unknown's avatar
unknown committed
5062 5063 5064 5065 5066
    /*
      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)
5067 5068
    */
    tmp_write_to_binlog= 0;
unknown's avatar
unknown committed
5069 5070 5071 5072
    mysql_log.new_file(1);
    mysql_update_log.new_file(1);
    mysql_bin_log.new_file(1);
    mysql_slow_log.new_file(1);
unknown's avatar
unknown committed
5073
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
5074
    if (mysql_bin_log.is_open() && expire_logs_days)
5075 5076 5077
    {
      long purge_time= time(0) - expire_logs_days*24*60*60;
      if (purge_time >= 0)
5078
	mysql_bin_log.purge_logs_before_date(purge_time);
5079
    }
5080
    pthread_mutex_lock(&LOCK_active_mi);
5081
    rotate_relay_log(active_mi);
5082
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
5083
#endif
unknown's avatar
unknown committed
5084 5085
    if (ha_flush_logs())
      result=1;
unknown's avatar
unknown committed
5086 5087
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
5088
  }
unknown's avatar
unknown committed
5089
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
5090 5091
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
5092
    query_cache.pack();				// FLUSH QUERY CACHE
unknown's avatar
unknown committed
5093 5094 5095 5096
    options &= ~REFRESH_QUERY_CACHE; //don't flush all cache, just free memory
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
5097
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
5098
  }
unknown's avatar
unknown committed
5099
#endif /*HAVE_QUERY_CACHE*/
5100 5101 5102 5103 5104
  /*
    Note that if REFRESH_READ_LOCK bit is set then REFRESH_TABLES is set too
    (see sql_yacc.yy)
  */
  if (options & (REFRESH_TABLES | REFRESH_READ_LOCK)) 
unknown's avatar
unknown committed
5105
  {
5106
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
5107
    {
5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118
      /*
        We must not try to aspire a global read lock if we have a write
        locked table. This would lead to a deadlock when trying to
        reopen (and re-lock) the table after the flush.
      */
      if (thd->locked_tables)
      {
        THR_LOCK_DATA **lock_p= thd->locked_tables->locks;
        THR_LOCK_DATA **end_p= lock_p + thd->locked_tables->lock_count;

        for (; lock_p < end_p; lock_p++)
unknown's avatar
unknown committed
5119
        {
5120 5121 5122 5123 5124
          if ((*lock_p)->type == TL_WRITE)
          {
            my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
            return 1;
          }
unknown's avatar
unknown committed
5125
        }
5126
      }
unknown's avatar
unknown committed
5127 5128 5129 5130
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
5131
      tmp_write_to_binlog= 0;
5132 5133
      if (lock_global_read_lock(thd))
	return 1;
5134 5135 5136
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
      make_global_read_lock_block_commit(thd);
unknown's avatar
unknown committed
5137
    }
5138 5139
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
5140
    my_dbopt_cleanup();
unknown's avatar
unknown committed
5141 5142 5143 5144 5145 5146 5147
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
  if (options & REFRESH_STATUS)
    refresh_status();
  if (options & REFRESH_THREADS)
    flush_thread_cache();
unknown's avatar
unknown committed
5148
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
5149
  if (options & REFRESH_MASTER)
5150 5151
  {
    tmp_write_to_binlog= 0;
5152 5153
    if (reset_master(thd))
      result=1;
5154
  }
5155
#endif
unknown's avatar
unknown committed
5156
#ifdef OPENSSL
5157 5158 5159 5160 5161 5162
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
unknown's avatar
unknown committed
5163
#ifdef HAVE_REPLICATION
5164 5165
 if (options & REFRESH_SLAVE)
 {
5166
   tmp_write_to_binlog= 0;
5167
   pthread_mutex_lock(&LOCK_active_mi);
5168
   if (reset_slave(thd, active_mi))
5169
     result=1;
5170
   pthread_mutex_unlock(&LOCK_active_mi);
5171
 }
5172
#endif
5173
 if (options & REFRESH_USER_RESOURCES)
5174
   reset_mqh(thd,(LEX_USER *) NULL);
5175 5176
 if (write_to_binlog)
   *write_to_binlog= tmp_write_to_binlog;
5177
 return result;
unknown's avatar
unknown committed
5178 5179
}

5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191
/*
  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
*/

5192
void kill_one_thread(THD *thd, ulong id)
unknown's avatar
unknown committed
5193 5194 5195
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
5196 5197
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
5198 5199 5200 5201
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
5202 5203
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
5204 5205 5206
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219
  if (tmp)
  {
    if ((thd->master_access & SUPER_ACL) ||
	!strcmp(thd->user,tmp->user))
    {
      tmp->awake(1 /*prepare to die*/);
      error=0;
    }
    else
      error=ER_KILL_DENIED_ERROR;
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }

unknown's avatar
unknown committed
5220
  if (!error)
5221
    send_ok(thd);
unknown's avatar
unknown committed
5222
  else
5223
    net_printf(thd,error,id);
unknown's avatar
unknown committed
5224 5225
}

unknown's avatar
unknown committed
5226

unknown's avatar
unknown committed
5227 5228 5229 5230 5231 5232 5233 5234
/* Clear most status variables */

static void refresh_status(void)
{
  pthread_mutex_lock(&LOCK_status);
  for (struct show_var_st *ptr=status_vars; ptr->name; ptr++)
  {
    if (ptr->type == SHOW_LONG)
5235
      *(ulong*) ptr->value= 0;
unknown's avatar
unknown committed
5236
  }
unknown's avatar
unknown committed
5237 5238
  /* Reset the counters of all key caches (default and named). */
  process_key_caches(reset_key_cache_counters);
unknown's avatar
unknown committed
5239 5240
  pthread_mutex_unlock(&LOCK_status);
}
5241 5242 5243 5244


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

unknown's avatar
unknown committed
5245 5246
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name)
5247
{
5248
  char buff[FN_REFLEN],*ptr, *end;
5249 5250 5251 5252 5253 5254 5255
  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))
  {
5256
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
5257 5258 5259 5260
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
5261
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
5262
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
5263 5264
    return 1;					// End of memory
  *filename_ptr=ptr;
5265
  strxmov(ptr,buff,table_name,NullS);
5266 5267
  return 0;
}
5268

5269

5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283
/*
  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;
5284
  if (thd->lex->current_select != &thd->lex->select_lex)
5285 5286
  {
    char command[80];
5287 5288
    strmake(command, thd->lex->yylval->symbol.str,
	    min(thd->lex->yylval->symbol.length, sizeof(command)-1));
5289
    net_printf(thd, ER_CANT_USE_OPTION_HERE, command);
5290 5291 5292 5293
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
5294

unknown's avatar
unknown committed
5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313
/*
  Setup locking for multi-table updates. Used by the replication slave.
  Replication slave SQL thread examines (all_tables_not_ok()) the
  locking state of referenced tables to determine if the query has to
  be executed or ignored. Since in multi-table update, the 
  'default' lock is read-only, this lock is corrected early enough by
  calling this function, before the slave decides to execute/ignore.

  SYNOPSIS
    check_multi_update_lock()
    thd		Current thread
    tables	List of user-supplied tables
    fields	List of fields requiring update

  RETURN VALUES
    0	ok
    1	error
*/
static bool check_multi_update_lock(THD *thd, TABLE_LIST *tables, 
unknown's avatar
unknown committed
5314
				    List<Item> *fields, SELECT_LEX *select_lex)
unknown's avatar
unknown committed
5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330
{
  bool res= 1;
  TABLE_LIST *table;
  DBUG_ENTER("check_multi_update_lock");
  
  if (check_db_used(thd, tables))
    goto error;

  /*
    Ensure that we have UPDATE or SELECT privilege for each table
    The exact privilege is checked in mysql_multi_update()
  */
  for (table= tables ; table ; table= table->next)
  {
    TABLE_LIST *save= table->next;
    table->next= 0;
unknown's avatar
unknown committed
5331 5332 5333
    if ((check_access(thd, UPDATE_ACL, table->db, &table->grant.privilege,0,1) ||
        (grant_option && check_grant(thd, UPDATE_ACL, table,0,1,1))) &&
	check_one_table_access(thd, SELECT_ACL, table))
unknown's avatar
unknown committed
5334 5335 5336 5337
	goto error;
    table->next= save;
  }
    
unknown's avatar
unknown committed
5338
  if (mysql_multi_update_lock(thd, tables, fields, select_lex))
unknown's avatar
unknown committed
5339 5340 5341 5342 5343 5344 5345
    goto error;
  
  res= 0;
  
error:
  DBUG_RETURN(res);
}
unknown's avatar
unknown committed
5346

unknown's avatar
unknown committed
5347

unknown's avatar
unknown committed
5348
Comp_creator *comp_eq_creator(bool invert)
unknown's avatar
unknown committed
5349
{
unknown's avatar
unknown committed
5350
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
unknown's avatar
unknown committed
5351 5352
}

unknown's avatar
unknown committed
5353

unknown's avatar
unknown committed
5354
Comp_creator *comp_ge_creator(bool invert)
unknown's avatar
unknown committed
5355
{
unknown's avatar
unknown committed
5356
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
unknown's avatar
unknown committed
5357 5358
}

unknown's avatar
unknown committed
5359

unknown's avatar
unknown committed
5360
Comp_creator *comp_gt_creator(bool invert)
unknown's avatar
unknown committed
5361
{
unknown's avatar
unknown committed
5362
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
unknown's avatar
unknown committed
5363 5364
}

unknown's avatar
unknown committed
5365

unknown's avatar
unknown committed
5366
Comp_creator *comp_le_creator(bool invert)
unknown's avatar
unknown committed
5367
{
unknown's avatar
unknown committed
5368
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
unknown's avatar
unknown committed
5369 5370
}

unknown's avatar
unknown committed
5371

unknown's avatar
unknown committed
5372
Comp_creator *comp_lt_creator(bool invert)
unknown's avatar
unknown committed
5373
{
unknown's avatar
unknown committed
5374
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
unknown's avatar
unknown committed
5375 5376
}

unknown's avatar
unknown committed
5377

unknown's avatar
unknown committed
5378
Comp_creator *comp_ne_creator(bool invert)
unknown's avatar
unknown committed
5379
{
unknown's avatar
unknown committed
5380
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
unknown's avatar
unknown committed
5381
}
unknown's avatar
unknown committed
5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401


/*
  Construct ALL/ANY/SOME subquery Item

  SYNOPSIS
    all_any_subquery_creator()
    left_expr - pointer to left expression
    cmp - compare function creator
    all - true if we create ALL subquery
    select_lex - pointer on parsed subquery structure

  RETURN VALUE
    constructed Item (or 0 if out of memory)
*/
Item * all_any_subquery_creator(Item *left_expr,
				chooser_compare_func_creator cmp,
				bool all,
				SELECT_LEX *select_lex)
{
unknown's avatar
unknown committed
5402
  if ((cmp == &comp_eq_creator) && !all)       //  = ANY <=> IN
unknown's avatar
unknown committed
5403
    return new Item_in_subselect(left_expr, select_lex);
unknown's avatar
unknown committed
5404 5405

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

  Item_allany_subselect *it=
5409
    new Item_allany_subselect(left_expr, (*cmp)(all), select_lex, all);
unknown's avatar
unknown committed
5410
  if (all)
5411
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
unknown's avatar
unknown committed
5412

5413
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
unknown's avatar
unknown committed
5414
}
5415 5416


5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431
/*
  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.
*/

int mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
{
  List<create_field> fields;
5432 5433 5434
  ALTER_INFO alter_info;
  alter_info.flags= ALTER_ADD_INDEX;
  alter_info.is_simple= 0;
5435 5436 5437 5438 5439 5440 5441
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_create_index");
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->real_name,
				&create_info, table_list,
5442
				fields, keys, 0, (ORDER*)0,
5443
				DUP_ERROR, 0, &alter_info));
5444 5445 5446
}


5447
int mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
5448 5449 5450 5451 5452 5453 5454 5455
{
  List<create_field> fields;
  List<Key> keys;
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_drop_index");
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;
5456 5457 5458
  alter_info->clear();
  alter_info->flags= ALTER_DROP_INDEX;
  alter_info->is_simple= 0;
5459 5460
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->real_name,
				&create_info, table_list,
5461
				fields, keys, 0, (ORDER*)0,
5462
				DUP_ERROR, 0, alter_info));
5463
}
unknown's avatar
merge  
unknown committed
5464 5465


5466 5467 5468 5469 5470
/*
  Multi update query pre-check

  SYNOPSIS
    multi_update_precheck()
unknown's avatar
unknown committed
5471 5472
    thd		Thread handler
    tables	Global table list
5473

unknown's avatar
unknown committed
5474
  RETURN VALUE
unknown's avatar
unknown committed
5475 5476 5477
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
5478
*/
unknown's avatar
unknown committed
5479

5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499
int multi_update_precheck(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("multi_update_precheck");
  const char *msg= 0;
  TABLE_LIST *table;
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
  TABLE_LIST *update_list= (TABLE_LIST*)select_lex->table_list.first;

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
    my_error(ER_WRONG_VALUE_COUNT, MYF(0));
    DBUG_RETURN(-1);
  }
  /*
    Ensure that we have UPDATE or SELECT privilege for each table
    The exact privilege is checked in mysql_multi_update()
  */
  for (table= update_list; table; table= table->next)
  {
5500 5501 5502 5503 5504 5505
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
                           &table->grant.privilege, 0, 1) ||
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
5506 5507
	(check_access(thd, SELECT_ACL, table->db,
		      &table->grant.privilege, 0, 0) ||
unknown's avatar
unknown committed
5508
	 grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
5509
      DBUG_RETURN(1);
unknown's avatar
unknown committed
5510 5511 5512 5513 5514

    /*
      We assign following flag only to copy of table, because it will
      be checked only if query contains subqueries i.e. only if copy exists
    */
5515
    if (table->table_list)
unknown's avatar
unknown committed
5516
      table->table_list->table_in_update_from_clause= 1;
5517
  }
unknown's avatar
unknown committed
5518 5519 5520
  /*
    Is there tables of subqueries?
  */
5521
  if (&lex->select_lex != lex->all_selects_list || lex->time_zone_tables_used)
5522
  {
5523
    DBUG_PRINT("info",("Checking sub query list"));
5524 5525
    for (table= tables; table; table= table->next)
    {
5526 5527 5528 5529
      if (my_tz_check_n_skip_implicit_tables(&table,
                                             lex->time_zone_tables_used))
        continue;
      else if (table->table_in_update_from_clause)
5530 5531 5532 5533 5534 5535 5536 5537 5538
      {
	/*
	  If we check table by local TABLE_LIST copy then we should copy
	  grants to global table list, because it will be used for table
	  opening.
	*/
	if (table->table_list)
	  table->grant= table->table_list->grant;
      }
5539
      else if (!table->derived)
5540 5541 5542
      {
	if (check_access(thd, SELECT_ACL, table->db,
			 &table->grant.privilege, 0, 0) ||
unknown's avatar
unknown committed
5543
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566
	  DBUG_RETURN(1);
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
  else if (select_lex->select_limit && select_lex->select_limit !=
	   HA_POS_ERROR)
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
    DBUG_RETURN(-1);
  }
  DBUG_RETURN(0);
}

/*
  Multi delete query pre-check

  SYNOPSIS
    multi_delete_precheck()
unknown's avatar
unknown committed
5567 5568 5569
    thd			Thread handler
    tables		Global table list
    table_count		Pointer to table counter
5570

unknown's avatar
unknown committed
5571
  RETURN VALUE
unknown's avatar
unknown committed
5572 5573 5574
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
5575
*/
unknown's avatar
unknown committed
5576

5577 5578 5579 5580 5581 5582 5583
int multi_delete_precheck(THD *thd, TABLE_LIST *tables, uint *table_count)
{
  DBUG_ENTER("multi_delete_precheck");
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  TABLE_LIST *aux_tables=
    (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
  TABLE_LIST *delete_tables= (TABLE_LIST *)select_lex->table_list.first;
unknown's avatar
unknown committed
5584 5585 5586
  TABLE_LIST *target_tbl;

  *table_count= 0;
5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598

  /* 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))
    DBUG_RETURN(1);
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
    my_error(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE, MYF(0));
    DBUG_RETURN(-1);
  }
unknown's avatar
unknown committed
5599
  for (target_tbl= aux_tables; target_tbl; target_tbl= target_tbl->next)
5600 5601 5602 5603
  {
    (*table_count)++;
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
5604
    walk= get_table_by_alias(delete_tables,target_tbl->db,target_tbl->alias);
5605 5606
    if (!walk)
    {
unknown's avatar
unknown committed
5607 5608
      my_error(ER_UNKNOWN_TABLE, MYF(0), target_tbl->real_name,
	       "MULTI DELETE");
5609 5610 5611 5612
      DBUG_RETURN(-1);
    }
    if (walk->derived)
    {
unknown's avatar
unknown committed
5613 5614
      my_error(ER_NON_UPDATABLE_TABLE, MYF(0), target_tbl->real_name,
	       "DELETE");
5615 5616
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
5617 5618
    walk->lock_type= target_tbl->lock_type;
    target_tbl->table_list= walk;	// Remember corresponding table
unknown's avatar
unknown committed
5619 5620 5621
    
    /* in case of subselects, we need to set lock_type in
     * corresponding table in list of all tables */
5622 5623 5624 5625 5626
    if (walk->table_list)
    {
      target_tbl->table_list= walk->table_list;
      walk->table_list->lock_type= walk->lock_type;
    }
5627 5628 5629 5630 5631
  }
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
5632 5633 5634 5635 5636
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
unknown's avatar
unknown committed
5637 5638
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
5639 5640

  RETURN VALUE
unknown's avatar
unknown committed
5641 5642 5643
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
unknown's avatar
unknown committed
5644
*/
unknown's avatar
unknown committed
5645

unknown's avatar
unknown committed
5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663
int update_precheck(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("update_precheck");
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
  {
    my_error(ER_WRONG_VALUE_COUNT, MYF(0));
    DBUG_RETURN(-1);
  }
  DBUG_RETURN((check_db_used(thd, tables) ||
	       check_one_table_access(thd, UPDATE_ACL, tables)) ? 1 : 0);
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
unknown's avatar
unknown committed
5664 5665
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
5666 5667

  RETURN VALUE
unknown's avatar
unknown committed
5668 5669 5670
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
unknown's avatar
unknown committed
5671
*/
unknown's avatar
unknown committed
5672

unknown's avatar
unknown committed
5673 5674 5675 5676 5677
int delete_precheck(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
    DBUG_RETURN(1);
unknown's avatar
unknown committed
5678
  /* Set privilege for the WHERE clause */
unknown's avatar
unknown committed
5679 5680 5681 5682 5683 5684 5685 5686 5687 5688
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
  DBUG_RETURN(0);
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
unknown's avatar
unknown committed
5689 5690
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
5691 5692

  RETURN VALUE
unknown's avatar
unknown committed
5693 5694 5695
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
unknown's avatar
unknown committed
5696
*/
unknown's avatar
unknown committed
5697

5698
int insert_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
5699 5700 5701 5702
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

unknown's avatar
unknown committed
5703 5704 5705 5706
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
5707 5708 5709
  ulong privilege= INSERT_ACL |
                   (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                   (lex->duplicates == DUP_UPDATE ? UPDATE_ACL : 0);
unknown's avatar
unknown committed
5710 5711

  if (check_one_table_access(thd, privilege, tables))
5712
    DBUG_RETURN(1);
unknown's avatar
unknown committed
5713

unknown's avatar
unknown committed
5714
  if (lex->update_list.elements != lex->value_list.elements)
unknown's avatar
unknown committed
5715 5716 5717 5718
  {
    my_error(ER_WRONG_VALUE_COUNT, MYF(0));
    DBUG_RETURN(-1);
  }
5719 5720
  DBUG_RETURN(0);
}
unknown's avatar
unknown committed
5721 5722 5723 5724 5725 5726 5727


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
unknown's avatar
unknown committed
5728 5729 5730
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
unknown's avatar
unknown committed
5731 5732

  RETURN VALUE
unknown's avatar
unknown committed
5733 5734
    0   OK
    1   Error (message is sent to user)
unknown's avatar
unknown committed
5735
*/
unknown's avatar
unknown committed
5736

unknown's avatar
unknown committed
5737 5738 5739 5740
int create_table_precheck(THD *thd, TABLE_LIST *tables,
			  TABLE_LIST *create_table)
{
  LEX *lex= thd->lex;
5741 5742 5743
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
  int error= 1;                                 // Error message is given
unknown's avatar
unknown committed
5744
  DBUG_ENTER("create_table_precheck");
5745 5746 5747

  want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
              CREATE_TMP_ACL : CREATE_ACL);
unknown's avatar
unknown committed
5748 5749 5750 5751 5752 5753
  lex->create_info.alias= create_table->alias;
  if (check_access(thd, want_priv, create_table->db,
		   &create_table->grant.privilege, 0, 0) ||
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797
    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 */

    /*
      For temporary tables or PREPARED STATEMETNS we don't have to check
      if the created table exists
    */
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
        ! thd->current_arena->is_stmt_prepare() &&
        find_real_table_in_list(tables, create_table->db,
                                create_table->real_name))
    {
      net_printf(thd,ER_UPDATE_TABLE_USED, create_table->real_name);

      goto err;
    }
    if (lex->create_info.used_fields & HA_CREATE_USED_UNION)
    {
      TABLE_LIST *tab;
      for (tab= tables; tab; tab= tab->next)
      {
        if (find_real_table_in_list((TABLE_LIST*) lex->create_info.
                                    merge_list.first,
                                    tables->db, tab->real_name))
        {
          net_printf(thd, ER_UPDATE_TABLE_USED, tab->real_name);
          goto err;
        }
      }  
    }    

    if (tables && check_table_access(thd, SELECT_ACL, tables,0))
      goto err;
  }
  error= 0;

err:
  DBUG_RETURN(error);
unknown's avatar
unknown committed
5798
}
unknown's avatar
unknown committed
5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834


/*
  negate given expression

  SYNOPSIS
    negate_expression()
    thd  therad handler
    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);
}